经典排序算法 - 冒泡和快排总结

排序有很多种方法，但人们首先总会想起冒泡和快排，现在总结一下这两种经典算法。

1. 冒泡

    public void bubbleSort(int[] a){
        for (int i = 0; i < a.length-1&&flag; i++) {
            for (int j = 0; j < a.length-i-1; j++) {
                if(a[j]>a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                    }
                }
            }
        for (int i : a) {
        System.out.print(i+" ");//循环输出数组a
        }
        }

 

冒泡排序还可以优化，例如当第一次冒泡时发现所有数字已经按照顺序排列，则跳出循环，不必在进行后面的n-2次冒泡，可以如果数据量大的话节约的时间很明显。

优化原理是增进一个标签flag，当内层循环中的a[j]>a[j+1]没有执行时结束外层循环。

//优化的冒泡排序
    public void bubbleSortOptimized(int[] a){
        boolean flag = true;
        for (int i = 0; i < a.length-1&&flag; i++) {
            flag = false;
            for (int j = 0; j < a.length-i-1; j++) {
                if(a[j]>a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                    flag = true;
                    }
                }
            }
        for (int i : a) {
        System.out.print(i+" ");//循环输出数组a
        }
        }

 冒泡另一种优化：

void bubble2(int a[],int n)
{
    bool flag = true;
    int k = n;
    while(flag)
    {
        flag = false;
        for(int i=1;i<k;i++)
        {
            if(a[i-1]>a[i])
            {
                swap(&a[i-1],&a[i]);
                flag = true;
            }
        }
        k--;
    }
}

 

2. 快排

    public int getSortIndex(int[] a, int left, int right){
        int temp = a[left];
        while(left<right){
        while(left < right && a[right]>=temp){
        right--;
        }
        a[left] = a[right];
        while(left < right && a[left] <= temp){
        left++;
        }
        a[right] = a[left];
        }
        a[left] = temp;
        return left;
        }
    
    
    public void quickSort(int[] a, int left, int right){
                if(left < right){
                    int index = this.getSortIndex(a, left, right);
                    this.quickSort(a, left, index-1);
                    this.quickSort(a, index+1, right);
        }
    }
        
    public void quickSort(int[] a){
        if(a!=null && a.length>0){
        this.quickSort(a, 0, a.length-1);
        }
        for (int i : a) {
            System.out.print(i+" ");//循环输出数组a
        }
        }

 

测试用例：

    public static void main(String[] args) {
        int[] a = {12,49,38,52,53,65,97,2,13,51};
        Sort s = new Sort();
        System.out.println("\n"+"result of bubbleSort(a): ");
        s.bubbleSort(a);
        System.out.println("\n"+"result of bubbleSortOptimized(a): ");
        s.bubbleSortOptimized(a);
        System.out.println("\n"+"result of quickSort(a): ");
        s.quickSort(a);
//        System.out.println(Arrays.toString(a));

    }

测试结果：

result of bubbleSort(a): 
2 12 13 38 49 51 52 53 65 97 
result of bubbleSortOptimized(a): 
2 12 13 38 49 51 52 53 65 97 
result of quickSort(a): 
2 12 13 38 49 51 52 53 65 97