java冒泡排序代码

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

为湘潭县等地区用户提供了全套网页设计制作服务，及湘潭县网站建设行业解决方案。主营业务为网站制作、成都做网站、湘潭县网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

冒泡排序算法的运作如下:

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public class BubbleSort{  

public static void main(String[] args){  

int score[] = {67, 69, 75, 87, 89, 90, 99, 100};  

for (int i = 0; i  score.length -1; i++){    //最多做n-1趟排序  

for(int j = 0 ;j  score.length - i - 1; j++){    //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)  

if(score[j]  score[j + 1]){    //把小的值交换到后面  

int temp = score[j];  

score[j] = score[j + 1];  

score[j + 1] = temp;  

}  

}              

System.out.print("第" + (i + 1) + "次排序结果：");  

for(int a = 0; a  score.length; a++){  

System.out.print(score[a] + "\t");  

}  

System.out.println("");  

}  

System.out.print("最终排序结果：");  

for(int a = 0; a  score.length; a++){  

System.out.print(score[a] + "\t");  

}  

}  

}

java中排序算法代码

package temp;

import sun.misc.Sort;

/**

* @author zengjl

* @version 1.0

* @since 2007-08-22

* @Des java几种基本排序方法

*/

/**

* SortUtil:排序方法

* 关于对排序方法的选择：这告诉我们，什么时候用什么排序最好。当人们渴望先知道排在前面的是谁时，

* 我们用选择排序；当我们不断拿到新的数并想保持已有的数始终有序时，我们用插入排序；当给出的数

* 列已经比较有序，只需要小幅度的调整一下时，我们用冒泡排序。

*/

public class SortUtil extends Sort {

/**

* 插入排序法

* @param data

* @Des 插入排序(Insertion Sort)是，每次从数列中取一个还没有取出过的数，并按照大小关系插入到已经取出的数中使得已经取出的数仍然有序。

*/

public int[] insertSort(int[] data) {

1/11页

int temp;

for (int i = 1; i data.length; i++) {

for (int j = i; (j 0) (data[j] data[j - 1]); j--) {

swap(data, j, j - 1);

}

}

return data;

}

/**

* 冒泡排序法

* @param data

* @return

* @Des 冒泡排序(Bubble Sort)分为若干趟进行，每一趟排序从前往后比较每两个相邻的元素的大小（因此一趟排序要比较n-1对位置相邻的数）并在

* 每次发现前面的那个数比紧接它后的数大时交换位置；进行足够多趟直到某一趟跑完后发现这一趟没有进行任何交换操作（最坏情况下要跑n-1趟，

* 这种情况在最小的数位于给定数列的最后面时发生）。事实上，在第一趟冒泡结束后，最后面那个数肯定是最大的了，于是第二次只需要对前面n-1

* 个数排序，这又将把这n-1个数中最小的数放到整个数列的倒数第二个位置。这样下去，冒泡排序第i趟结束后后面i个数都已经到位了，第i+1趟实

* 际上只考虑前n-i个数（需要的比较次数比前面所说的n-1要小）。这相当于用数学归纳法证明了冒泡排序的正确性

java冒泡排序法代码

冒泡排序是比较经典的排序算法。代码如下：

for(int i=1;iarr.length;i++){

for(int j=1;jarr.length-i;j++){

//交换位置

}    

拓展资料：

原理：比较两个相邻的元素，将值大的元素交换至右端。

思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。

第一趟比较完成后，最后一个数一定是数组中最大的一个数，所以第二趟比较的时候最后一个数不参与比较；

第二趟比较完成后，倒数第二个数也一定是数组中第二大的数，所以第三趟比较的时候最后两个数不参与比较；

依次类推，每一趟比较次数-1；

??

举例说明：要排序数组：int[] arr={6,3,8,2,9,1}; 

for(int i=1;iarr.length;i++){

for(int j=1;jarr.length-i;j++){

//交换位置

}    

参考资料：冒泡排序原理

java语言：对包含5个元素的一维数组用冒泡法进行排序，编程实现并输出排序后的结果。

代码：

public class test {

private static void sort(Integer arr[], int n) {

if (n = 1) return;       //如果只有一个元素就不用排序了

for (int i = 0; i n; ++i) {

// 提前退出冒泡循环的标志位,即一次比较中没有交换任何元素，这个数组就已经是有序的了

boolean flag = false;

for (int j = 0; j n - i - 1; ++j) {        //此处你可能会疑问的jn-i-1，因为冒泡是把每轮循环中较大的数飘到后面，

// 数组下标又是从0开始的，i下标后面已经排序的个数就得多减1，总结就是i增多少，j的循环位置减多少

if (arr[j] arr[j + 1]) {        //即这两个相邻的数是逆序的，交换

int temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

flag = true;

}

}

if (!flag) break;//没有数据交换，数组已经有序，退出排序

}

}

public static void main(String[] args) {

Integer arr[] = {2, 6, 3, 67, 54};

sort(arr, arr.length);

System.out.println("冒泡排序后的数组为");

for (Integer i : arr) {

System.out.println(i);

}

}

}

java排序代码

整数转成字符串后排序。import java.util.Arrays;import java.util.Collections;import java.util.List;public class Test { public static void main(String[] args) { List list = Arrays.asList("1", "10", "12", "3", "2", "4", "5"); Collections.sort(list); System.out.println(Arrays.toString(list.toArray())); }}

请用java语言编写排序程序。

参考代码如下，可以按需求自己修改

import java.util.Date;

public class SortThread {

public static void main(String[] args) {

//产生一个随机数组

int[] ary = getArray();

//启动冒泡排序线程

new Thread(new MaoPao(ary)).start();

//启动快速排序线程

new Thread(new KuaiSu(ary)).start();

}

private static int[] getArray() {

//建议数字n不要超过1百万，十万左右就好了

int n = (int) (Math.random()*1000000)+11;

int[] ary= new int[n];

System.out.println("n的值是" + n);

for (int i = 0; i  ary.length; i++) {

ary[i] = (int) (Math.random()*100000);

}

return ary;

}

}

//冒泡排序

class MaoPao implements Runnable {

int[] ary;

public MaoPao(int[] ary) {

this.ary = ary;

}

@Override

public void run() {

long st = System.currentTimeMillis();

System.out.println(new Date() + "冒泡排序线程：开始执行排序");

for (int i = 0; i  ary.length - 1; i++) {

for (int j = 0; j  ary.length - i - 1; j++) {

if (ary[j]  ary[j + 1]) {

int temp = ary[j];

ary[j] = ary[j + 1];

ary[j + 1] = temp;

}

}

}

long et = System.currentTimeMillis();

System.out.println(new Date() + "冒泡排序线程完成排序,耗费时间" + (et - st) + "毫秒");

for (int i = 0; i  ary.length; i++) {

System.out.println(ary[i]+" ");

}

}

}

//快速排序

class KuaiSu implements Runnable {

int[] ary;

public KuaiSu(int[] ary) {

this.ary = ary;

}

@Override

public void run() {

long st = System.currentTimeMillis();

System.out.println(new Date() + "快速排序线程：开始执行排序");

quickSort(ary, 1, ary.length);

long et = System.currentTimeMillis();

System.out.println(new Date() + "快速排序线程排序完成,耗费时间" + (et - st) + "毫秒");

for (int i = 0; i  ary.length; i++) {

System.out.println(ary[i]+" ");

}

}

public static int Partition(int a[], int p, int r) {

int x = a[r - 1];

int i = p - 1;

int temp;

for (int j = p; j = r - 1; j++) {

if (a[j - 1] = x) {

i++;

temp = a[j - 1];

a[j - 1] = a[i - 1];

a[i - 1] = temp;

}

}

temp = a[r - 1];

a[r - 1] = a[i + 1 - 1];

a[i + 1 - 1] = temp;

return i + 1;

}

public static void quickSort(int a[], int p, int r) {

if (p  r) {

int q = Partition(a, p, r);

quickSort(a, p, q - 1);

quickSort(a, q + 1, r);

}

}

}