交换排序--快排

快速排序实际上是对冒泡排序的一种改进，他的核心部分是找到支点（随机在数组里取一个，一般为第一个）在能够把他分为两个子组的情况下，在数组中的位置。然后再这个基础上，对两个子组进行同种方法处理，即使用递归，从而达到排序的目的。

我们先假设低位高位指针分别为low和high，支点为flag，数组名为a，初始化low= 0，high=a.length-1

还是那个数组int[] a = new int[]{22,545,45,67,28,99,454,225,65,7,10,4845,455,787,1};

找到枢纽的循环里有两个过程：

1，是将数组从右向左遍历，遇到比flag大的则high--，否则和枢纽调换

2，将数组从左往右遍历，遇到比flag小的则low++，否则和枢纽调换

之后就是递归了，不多说看代码

public int findLow(int a[],int low,int high) {
        int tmp;
        int i,j;
        while(low!=high) {
            for(i = high;i >= 0;i--) {
                if(a[i]>=a[low]&&low<high) {
                    high--;
                }else {
                    tmp = a[i];
                    a[i] = a[low];   //调换
                    a[low] = tmp;
                }
            }
            for(j = 0;j<high;j++) {
                if(a[j]<=a[low]&&low<high) {
                    low++;
                }else {
                    tmp = a[j];
                    a[j] = a[low];    //调换
                    a[low] = tmp;
                }
            }
        }
        System.out.println("找到枢纽在数组中的最终位置"+low);  //为了体现出找到枢纽所在位置，加了一句注释
        return low;
    }
    public void QuikSort(int a[],int low,int high) {
        int flag;
        if(low<high) {
            flag = findLow(a,low,high);
            QuikSort(a,low,flag-1);  //递归
            QuikSort(a,flag+1,high);
        }
        //由于递归，这里如果输出数组会很麻烦，所以这里只给出函数体，去外部输出数组
    }

View Code

 

结果如下：

找到枢纽在数组中的最终位置0
找到枢纽在数组中的最终位置3
找到枢纽在数组中的最终位置1
找到枢纽在数组中的最终位置4
找到枢纽在数组中的最终位置5
找到枢纽在数组中的最终位置6
找到枢纽在数组中的最终位置7
找到枢纽在数组中的最终位置8
找到枢纽在数组中的最终位置9
找到枢纽在数组中的最终位置10
找到枢纽在数组中的最终位置11
找到枢纽在数组中的最终位置12
找到枢纽在数组中的最终位置13
1
7
10
45
22
28
65
67
99
225
454
455
545
787
4845

View Code

 

算法特点：

时间复杂度方面，我们可以看到，它的快排的次数取决于递归树的深度，我查了资料（公式并没有推），它的时间复杂度是最好的情况是O(nlog2n)，最坏的情况就是待排序的数组已经是排好序的，这个时候总的关键字比较次数会最多，为n²/2，理论上，平均情况下，它的时间复杂度还是O(nlog2n)。

稳定性方面，它是不稳定的。

适用性方面，它适用于顺序结构，很难用于链式（这个我试过，真的不是很容易。。。。），快排内部排序方法中最快的那种，适用于初始无序，n比较大的情况

转载于:https://www.cnblogs.com/Yintianhao/p/9157409.html