排序算法之選擇排序-直接選擇排序與堆排序

1.直接選擇排序

1.1 算法思想

1.1.1 設待排序記錄放置在a[n]數組中，第一趟從a[0]開始，通過n-1次比較，從n個記錄中選出關鍵字最小的記錄，記爲n[k]，並交換a[0]與a[k]。

1.1.2 第二趟從a[1]開始，通過n-2次比較，從n個記錄中選出關鍵字最小的記錄，記爲n[k]，並交換a[1]與a[k]。

1.1.3 以此類推，經過n趟，排序完成。

1.2 算法圖解

1.3 代碼與結果

public class ChooseSort {

    public static void main(String[] args) {
        int a[]={49,38,65,97,76,13,27,49};
        Csort(a);
        for(int i=0;i<a.length;i++)
        {
            System.out.println(a[i]);
        }
    }

    public static void Csort(int[] a)
    {
        for(int i=0;i<a.length;i++)
        {
            int k=i;
            for(int j=i+1;j<a.length;j++)
            {
                if(a[j]<a[k])
                {
                    k=j;
                }
            }
            if(k!=i)
            {
                int temp =a[i];
                a[i]=a[k];
                a[k]=temp;
            }
        }
    }
}

13 27 38 49 49 65 76 97 

1.4 總結

1.4.1 時間複雜度O(n2)，空間複雜度O(1)

1.4.2 是穩定排序

 

2.堆排序

2.1 算法思想

建初堆，調整堆，堆排序！

2.1.1 建初堆，從最後一個不爲樹的葉結點開始依次調整堆，知道成爲一個大根堆。

2.1.2 調整堆，假設a[s+1...m]已經是堆得情況下，將a[s...m]調整爲堆，比較2s+1與2s+2的大小(數組以0開始)，取較大值，與a[s]進行比較，若a[s]較大，則結束。否則，交換a[s]與a[2s+1]和a[2s+2]中的較大者，並繼續進行上述操作。

2.1.3 推排序，將堆頂元素和末尾元素進行交換，並調整堆。再將堆頂元素和倒數第二個元素進行交換，並調整堆。重複上述操作至排序完成。

2.2 算法圖解

 

2.3 代碼與結果

public class HeapSort {

    //調整堆
    public static void adjustHeap(int[] a,int s,int m)
    {
        int temp=a[s];
        for(int j=2*s+1;j<=m;j=j*2)
        {
            if(j<m&&a[j]<a[j+1]) j++;
            if(temp>a[j]) break;
            a[s]=a[j];
            s=j;
        }
        a[s]=temp;
    }


    //建初堆
    public  static  void createHeap(int[] a)
    {
        for(int i=a.length/2;i>=0;i--)
        {
            adjustHeap(a,i,a.length-1);
        }
    }

    //堆排序

    public static void Hsort(int[] a)
    {
        createHeap(a);
        for(int i=a.length-1;i>=1;i--)
        {
            int temp=a[0];
            a[0]=a[i];
            a[i]=temp;
            adjustHeap(a,0,i-1);
        }
    }

    public static void main(String[] args) {
        int a[]={49,38,65,97,76,13,27,49};
        Hsort(a);
        for(int i=0;i<a.length;i++)
        {
            System.out.println(a[i]+" ");
        }
    }
}

13 27 38 49 49 65 76 97 

2.4 總結

2.4.1 時間複雜度O(nlogn) 空間複雜度O(1)

2.4.2 是不穩定排序