Java常用排序

1、冒泡排序

思路：数组长度为n，从前往后两两相邻的数据比较大小，根据条件交换位置,，第一轮交换n-1次后就把最大（或最小）的数挪到了最后，则第二轮最后一个数据就不用比较了并把第二大（或小）数挪到了倒数第二位置，经过n轮排序后就实现了整体排序。循环控制可以使用for或者while，根据个人喜好。

代码：

package com.xtm.reflect;
public class BubbleSort {
	public static void main(String[] args) {	
          int[] a = {13,21,10,124,34,9,25,0,-24,99};
          pringArray(a);
          int len = a.length;
          for(int i=0;i<len;i++){//控制排序轮数
               for(int j=0;j<len-i-1;j++){//控制每轮比较次数
                   //比较两相邻数据大小，根据条件交换位置
            	   int tmp ;
            	   if(a[j]>a[j+1]){
            		   tmp = a[j];
            		   a[j] = a[j+1];
            		   a[j+1] = tmp;
            	   }
               }
          }
          System.out.println("");
          pringArray(a);
	}
	private static void pringArray(int[] a) {
		int i = 0;
		int max = a.length;
		while(i<max){
			System.out.print(a[i++]+"\t");
		}
		
	}

}

或者：

package com.xtm.reflect;
public class BubbleSort {
	public static void main(String[] args) {	
          int[] a = {13,21,10,124,34,9,25,0,-24,99};
          pringArray(a);
          int len = a.length;
          for(int i=0;i<len;i++){
               for(int j=1;j<len-i;j++){
            	   int tmp ;
            	   if(a[j-1]>a[j]){
            		   tmp = a[j-1];
            		   a[j-1] = a[j];
            		   a[j] = tmp;
            	   }
               }
          }
          System.out.println("");
          pringArray(a);
	}
	private static void pringArray(int[] a) {
		int i = 0;
		int max = a.length;
		while(i<max){
			System.out.print(a[i++]+"\t");
		}
		
	}

}

或者

package com.xtm.reflect;

public class BubbleSort {
	public static void main(String[] args) {
		int[] a = { 13, 21, 10, 124, 34, 9, 25, 0, -24, 99 };
		pringArray(a);
		int len = a.length;
		int i = 0;
		while (i < len) {
			int j = 1;
			int tmp;
			while (j < len - i) {
				if (a[j - 1] < a[j]) {
					tmp = a[j - 1];
					a[j - 1] = a[j];
					a[j] = tmp;
				}
				j++;
			}
			i++;

		}
		System.out.println("");
		pringArray(a);
	}

	private static void pringArray(int[] a) {
		int i = 0;
		int max = a.length;
		while (i < max) {
			System.out.print(a[i++] + "\t");
		}

	}

}

以上的执行结果相同：

13	21	10	124	34	9	25	0	-24	99	
-24	0	9	10	13	21	25	34	99	124	

比较总次数分析：

假设数组长度为len,则需要len-1轮
第一轮 ：len-1次
第二轮 ：len-2次
     ... ...
第len-2轮  : 2次
第len-1轮  : 1次

复杂度：

总次数=(len-1)+(len-2)+...+(len-（len-2）)+(len-(len-1))
      =len*(len-1)-(1+2+...+len-1)
      =len*(len-1)-(len*(len-1)/2)
      =len*len-len-len*len/2+len/2
      =len*len/2-len/2
      =(len*len-len)/2

2.选择排序

package com.xtm.tree;

public class MySort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] data = {12,1,3,14,3,12,19,3};
		
		int len = data.length;
		//冒泡排序
//		for(int i=0;i<len-1;i++){
//			for(int j=0;j<len-i-1;j++){
//				if(data[j]>data[j+1]){
//					int temp = data[j];
//					data[j] = data[j+1];
//					data[j+1] =  temp;
//				}
//			}
//		}
		
	    //选择排序
		for(int i=0;i<len-1;i++){
			for(int j=i+1;j<len;j++){
				if(data[i]>data[j]){
					int temp = data[i];
					data[i] = data[j];
					data[j] = temp;
				}
			}
		}
		for(int i=0;i<len;i++){
			System.out.print("\t"+data[i]);
		}

	}

}

运行结果：

1	3	3	3	12	12	14	19

3.快速排序

package com.xtm.tree;

public class FastSort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] data = {22,12,1,4,19,0,10};
		fastSort(data,0,data.length-1);
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]+"\t");
		}

	}

	private static void fastSort(int[] array, int low, int hight) {
		int i,j,base,tmp;
		if(low>hight){
			return;
		}
		i=low;
		j=hight;
		base=array[low];
		while(i<j){//还没碰撞
			while(array[j]>=base && i<j){//从右向左找到小于基准数
				j--;
			}
			while(array[i]<=base && i<j){//从左向右找到大于基准数
				i++;
			}
			//交换
			if(i<j){
				tmp = array[j];
				array[j]=array[i];
				array[i]=tmp;
			}
			
		}
		//碰撞了，碰撞点和基准数交换
		array[low]=array[i];
		array[i]= base;
		
		//碰撞点前部分继续
		fastSort(array, low, j-1);
		//碰撞点后部分继续
		fastSort(array, j+1, hight);
		
	}

}

运行结果：

0	1	4	10	12	19	22