排序算法之选择排序-直接选择排序与堆排序

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 是不稳定排序