选择类排序

一、基本思想

每一趟在n-i+1(i=1,2,...,n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。

二、简单选择排序

    //遍历每个数，每次选择最小的数放在最前面。
    // 进行下标为i的数时，从n-i个数中选出最小的数，并将最小的数和第i个记录进行交换。
    //有序：[0,i)
    //无序：[i,array.length)

public class SelectSort {
    //简单选择排序
    //遍历每个数，每次选择最小的数放在最前面。
    // 进行下标为i的数时，从n-i个数中选出最小的数，并将最小的数和第i个记录进行交换。
    //有序：[0,i)
    //无序：[i,array.length)
    private static void selectSort(int[] array){
     for(int i=0;i<array.length;i++){
         int min=i;//记录最小值的下标
         for(int j=i;j<array.length;j++){
             if(array[j]<array[min]){
                 min=j;
             }
         }
         //判断最小值的下标是否是i
         if(min!=i){
             //交换
             int t=array[i];
             array[i]=array[min];
             array[min]=t;
         }
     }
    }

    public static void main(String[] args) {
        int[] array=new int[]{65,32,12,56,42,1,9,6};
        selectSort(array);
        for(int item:array){
            System.out.print(item+" ");
        }
    }
}

时间复杂度：

最好：O(n^2)       最坏：O(n^2)        平均：O(n^2)

空间复杂度：

O(1)

稳定性：

不稳定

举例：3a,3b,2  进行选择排序后变为2，3b，3a，因此不稳定。

三、堆排序（升序）

思想：利用堆的根结点是最大值的特点，先建大堆，此时的根结点是堆内元素最大的一个值，然后每次将最后一个结点和根结点进行交换，然后对新的堆和新的根结点进行向下调整。

堆排序中主要解决两个问题：一是按堆定义建初堆；二是去掉最大元之后，重建堆，获得次大元，以此类推。

public class SelectSort {
    //向下调整堆（堆化）  大堆
    private static void heapify(int[] array,int size,int index){
        int max=2*index+1;
        while(max<size){
            if(max+1<size&&array[max+1]>array[max]){
                max=max+1;//选出较大的孩子
            }
            //判断根结点值和较大孩子结点值
            if(array[index]>=array[max]){
                break;
            }
            //交换两个值
            int temp=array[index];
            array[index]=array[max];
            array[max]=temp;
            //重新赋值
            index=max;
            max=2*max+1;
        }
    }
    //建堆的过程
    //思想：叶子结点本来就是一个堆，因此从最后一个非叶子结点开始，向下调整堆。最后一个非叶子节点就是最后一个叶子结点的双亲结点
    private static void createHeap(int[] array){
        for(int i=(array.length-2)/2;i>=0;i--){
            heapify(array,array.length,i);
        }
    }
    //堆排序
    private static void heapSort(int[] array){
        createHeap(array);//建大堆
        //减治算法  根结点一定是最大的元素
        for(int i=0;i<array.length;i++){
            //先将最后一个元素和根结点进行交换，然后对根结点进行向下调整
            int temp=array[0];
            array[0]=array[array.length-1-i];
            array[array.length-1-i]=temp;
            //然后再对根结点进行向下调整(整个堆变为数组的长度-1-i，因为要除去最后一个结点（原来堆的最大值））
            heapify(array,array.length-1-i,0);
        }
    }

    public static void main(String[] args) {
        int[] array=new int[]{7,6,2,3,4,5,5,10,9,1,3};
        heapSort(array);
        for(int item:array){
            System.out.print(item+" ");
        }

    }
}

时间复杂度：

最好/最坏/平均：O(n*log(n))

空间复杂度：

O(1)

稳定性：

不稳定