常用排序算法

1. 冒泡算法

//冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。
//用时间复杂度来说：
//　　1.如果我们的数据正序，只需要走一趟即可完成排序。所需的比较次数C和记录移动次数M均达到最小值，即：Cmin=n-1;Mmin=0;所以，冒泡排序最好的时间复杂度为O(n)。
//　　2.如果很不幸我们的数据是反序的，则需要进行n-1趟排序。每趟排序要进行n-i次比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：冒泡排序的最坏时间复杂度为：O(n2) 。
//综上所述：冒泡排序总的平均时间复杂度为：O(n2) 。

public class MaoPao {

    public static void main(String[] args) {
        int a[] = { 2, 8, 5, 6, 8, 9, 2, 23, 3 };
        MaoPao mp = new MaoPao();
        mp.maopaopx(a);
        for (int b : a) {
            System.out.println(b);
        }
    }

    public void maopaopx(int a[]) {
//        N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数
        for (int i = 0; i < a.length-1 ; i++) {
            for (int j = 0; j < a.length-1-i; j++) {
                if (a[j] > a[j+1]) {
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
    }

}
 

2. 快速排序

//快速排序的原理：选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素。
//一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的交换位置，如果没有继续比较下一个，直到找到第一个比基准值小的值才交换。找到这个值之后，又从前往后开始比较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的值才交换。直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值来说，左右两边就是有序的了。
//接着分别比较左右两边的序列，重复上述的循环。

public class KuaiPai {

    public static void main(String[] args) {
        int a[] = { 7,4, 8, 5, 6, 9, 2, 23, 3 };
        KuaiPai kp = new KuaiPai();
        int left = 0;
        int right = a.length-1;
        kp.kp(a,left,right);
        
    }
    public void kp(int a[],int left,int right) {
        int start = left;
        int end = right;
        int key = a[left];
        while (start<end) {
            //从后往前比较
            while (start<end && key<=a[end]) {//如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
                end--;
            }
            if (key>a[end]) {
                int temp = a[end];
                a[end]=a[start];
                a[start]=temp;
            }
            //从前往后比较
            while (start<end && key>=a[start]) {//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
                start ++;
            }
            if (key < a[start]) {
                int temp = a[end];
                a[end]=a[start];
                a[start]=temp;
            }
        }
        //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
        for (int b : a) {
            System.out.print(b+" ");
        }
        System.out.println();
        //start = end = key所在位置
        //递归
        if (start>left) kp(a,left,start-1);//左边序列。第一个索引位置到关键值索引-1
        if (end<right) kp (a,end+1,right);//右边序列。从关键值索引+1到最后一个
    }

}