常用排序--冒泡/快速排序

冒泡排序是两个相临位置的数据进行比较，按照逻辑从大到小还是从小到大进行调换，确定一个数字为一趟.

•若文件初状为正序，则一趟起泡就可完成排序，排序码的比较次数为n-1，且没有记录移动，时间复杂度是O(n)

•若文件初态为逆序，则需要n-1趟起泡，每趟进行n-i次排序码的比较，且每次比较都移动三次，比较和移动次数均达到最大值∶O(n2)

•起泡排序平均时间复杂度为O(n2)

public class Maopao {
	public static void main(String[] args) {
		int [] target={5,3,4,2,11,8,7};
		int t =0;
		int length = target.length;
		for(int i=0;i<length-1;i++){
			for(int j=0;j<length-1;j++){
				if(target[j]<target[j+1]){
					t=target[j];
					target[j]=target[j+1];
					target[j+1]=t;
				}
			}
			System.out.println("第"+(i+1)+"趟排序结果");
			for(int sig1=0;sig1<target.length-1;sig1++){
				System.out.print(target[sig1]+"\t");
			}
			System.out.println("");
		}
		System.out.println("*********************最后结果*****************");
		for(int b:target){
			System.out.print(b+"\t");
		}
	}
}

第1趟排序结果
5	4	3	11	8	7	
第2趟排序结果
5	4	11	8	7	3	
第3趟排序结果
5	11	8	7	4	3	
第4趟排序结果
11	8	7	5	4	3	
第5趟排序结果
11	8	7	5	4	3	
第6趟排序结果
11	8	7	5	4	3	
*********************最后结果*****************
11	8	7	5	4	3	2	

快速排序

public class KuaiPai {
	public static void main(String[] args) {
		int[] target={24,3,12,22,11,15,6};
		quickSort(target,0,target.length-1);
		for(int a:target){
			System.out.print(a+"\t");
		}
	}
	
	
	private static void quickSort(int[] a, int low, int high) {
        if(low<high){ //如果不加这个判断递归会无法退出导致堆栈溢出异常
            int middle = getMiddle(a,low,high);
            //递归调用
            quickSort(a, 0, middle-1);//基数左边
            quickSort(a, middle+1, high);//基数右边
        }
    }
	
	public static int getMiddle(int[]a,int left,int right){
		int tmp = a[left];
		while(left<right){
			while(right>left&a[right]>tmp){//右边往做移动
				right--;
			}
			while(right>left&a[left]<tmp){//左边往右移动
				left++;
			}
			if(left<right){//只要是两者不相遇会交换并且再次进行下去
				int t=0;
				t = a[right];
				a[right] = a[left];
				a[left]=t;
			}
		}
		a[left] = tmp;//左右相遇交换中间数据和基数
		return left;
	}
}

快速排序是不稳定的排序。

快速排序的时间复杂度为O(nlogn)。

当n较大时使用快排比较好，当序列基本有序时用快排反而不好。

最坏情况O(n^2)

最好情况

logn * n

平均时间复杂度是O(nlogn)