經典排序算法 - 冒泡和快排總結

排序有不少種方法，但人們首先總會想起冒泡和快排，如今總結一下這兩種經典算法。

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