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

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

•若文件初状为正序，则一趟起泡就可完成排序，排序码的比较次数为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)