8种排序算法总结

常用排序算法的复杂度分析整理

具体分析如下：

交换排序

冒泡排序（BubbleSort）

冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较它是O（n ^ 2）的算法。
步骤：
（1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。
（2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
（ 3）针对所有的元素重复以上的步骤，除了最后一个。。
（4）持续不断对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public class bubble {
   
    public static void main(String[] args){
   
//        int[] arr =new int[0];
//        int[] arr={7,5,6,3,2,4,0,8};
        int[] arr= new int[]{
   2,4,1,6,5,9,8,7,6};
        int temp;
        //一共要比较 i 趟  ，从0趟开始比较 每趟比较出 比较数中最小的一个数 排到上面 来
        for (int i = 0; i < arr.length-1; i++) {
   
                //每一趟要比较 j次 ，从j到0次比较 ，每次 比较两个数 小数往上排一位 ，再用小数和上面一位 比较 ，一次类推。。。。
                //j>i 因为每一趟 都会比出比较数中的 最小一位 ，那么 下一趟的比较中就不用再包含 已是最小的那个了。
                for (int j =arr.length-1; j >i ; j--) {
   
                        //开始是拿最后一个数和上面一个数比
                        if (arr[j]<arr[j-1]){
   
                         temp = arr[j];
                            arr[j]=arr[j-1];
                            arr[j-1]=temp;
                        }
                }
        }
    }
}

快速排序（QuickSort）

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个项目要Ο（n log n）次比较。在实际上Ο（n2），快速排序通常明显比其他Ο（n log n）算法转换，因为它的内部循环可以在大部分的架构上很有潜力效率地被实现出来，并且在大部分真实世界的数据，可以决定设计的选择，减少所需时间的二次方项之可能性。
快速排序是一个就地排序，分而治之，大规模递归的算法。
（1）如果不多于1个数据，直接返回。
（2）一般选择序列最左边的值作为分支点数据。从本质上来说，它是归并并排序的就地版本。。
（3）将序列片段2部分，一部分都大于支点数据，另外一部分都小于支点数据。
（4）对两边利用递归归零数列。
快速排序比大部分排序算法都要快。的情况下写出比快速排序快的算法，但是就通常情况而言，没有比它重启的了。快速排序是递归的，对于内存非常有限的机器来说，它不是一个好的选择。

public class QuickSort {
   
    public static void sort(int a[], int low, int hight) {
   
        int i, j, index;
        if (low > hight) {
    return; }
        i = low;
        j = hight;
        index = a[i]; // 用子表的第一个记录做基准
        //先从大开始和基准数比较
        while (i < j) {
    // 从表的两端交替向中间扫描
            while (i < j && a[j] >= index)
                j--;
            if (i < j)//进入这个分支说明 i<j 并且 index>a[j]
                a[i++] = a[j];//将基准数处 赋值成a[j] 并i++
            while (i < j && a[i] < index)//在从小和基准数比较
                i++;
            if (i < j) // 用比基准大的记录替换高位记录
                a[j--] = a[i];
        }
        a[i] = index;// 将基准数值替换回 a[i]
        sort(a, low, i - 1); // 对低子表进行递归排序
        sort(a, i + 1, hight); // 对高子表进行递归排序
    }
    public static void quickSort(int a[]) {
   
        sort(a, 0, a.length - 1);
    }

    public static void main(String[] args) {
   

        int a[] = {
    49, 38, 65, 97, 76, 13, 27, 49 }