排序算法—选择排序

【选择排序】

1.选择排序

选择排序的基本思想：每一趟从待排序记录中选出关键字最小的记录，按顺序放到已经排好序的子序列中，直到全部记录排序完毕。

选择排序算法的应用，包括直接选择排序和堆排序两种。

2.直接选择排序

直接选择排序的基本思想：n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

• 初始状态：无序区为R[1...n]，有序区为空；
• 第1趟排序：在无序区R[1..n]中选择出关键字最小的记录R[k]，将它与无序区间的第1个记录R[1]交换，使得R[1]和R[2...n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
• 第i趟排序：第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R[i..n]()。该趟排序从当前无序区中选出关键字最小的记录R[k],将它与无序区的第1个记录R[i]交换，使得R[1..i-1]和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。这样n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

例如

---

初始序列：       9 0 5 3 7 8 4 2 1

              <找最小数>                 <找最大数>                          

第1趟：0 9 5 3 7 8 4 2 1      1 0 5 3 7 8 4 2 9

第2趟：0 1 9 5 3 7 8 4 2      1 0 5 3 7 2 4 8 9

第3趟：0 1 2 9 5 3 7 8 4      1 0 5 3 4 2 7 8 9   

第4趟：0 1 2 3 9 5 7 8 4      1 0 2 3 4 5 7 8 9     

第5趟:  0 1 2 3 4 9 5 7 8       1 0 2 3 4 5 7 8 9            

第6趟：0 1 2 3 4 5 9 7 8      1 0 2 3 4 5 7 8 9          

第7趟:  0 1 2 3 4 5 7 9 8       1 0 2 3 4 5 7 8 9           

第8趟:  0 1 2 3 4 5 7 8 9       0 1 2 3 4 5 7 8 9                

n-1=9-1=8趟

---

时间复杂度及空间复杂度及稳定性

时间复杂度	O(n^2)
空间复杂度	O(1)
稳定性	不稳定

3.堆排序

堆：堆实际上是一棵完全二叉树。堆分为大顶堆和小顶堆。

堆排序的基本思想：利用大顶堆堆顶记录的是最大关键字这一特性，使得每次从无序中选择最大记录。

• 将初始待排关键字序列（R1，R2，....Rn)构建成大顶堆，此堆为初始的无序区；
• 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,...Rn-1)和新的有序区(Rn)，且满足R[1,2,...n-1]<=R[n];
• 由于交换后新的栈顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,...Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2,...Rn-2)和新的有序区(Rn-1,Rn)。重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

操作过程：

• 初始化堆：将R[1..n]构造为堆；
• 将当前无序区的堆顶元素R[1]同该区间的最后一个记录交换，然后将新的无序区调整为新的堆。

对于堆排序，最重要的两个操作：构造初始堆（对所有非叶子节点都进行调整）和调整堆。

时间复杂度及空间复杂度及稳定性

时间复杂度	O(nlogn)
空间复杂度	O(1)
稳定性	不稳定

代码如下：

import java.util.Arrays;

public class Selection {

    //【直接选择排序——找最大数】
    public static void selectSort1(int[] array){
        //每次选最大的数
        for(int i=0;i<array.length-1;i++){
            //无序区间[0,arrry.length-i)
            //有序区间[array.length-i,array.length)
            int max=0;
            for(int j=1;j<array.length-i;j++){
                if(array[j]>=array[max]){
                    max=j;
                }
            }
            //交换无序区间最后一个数和最大的数
            swap(array,max,array.length-i-1);
        }
    }
    //【直接选择排序——找最小数】
    public static void selectSort2(int[] array){
      for(int i=0;i<array.length-1;i++){
          int min=i;
         for(int j=i+1;j<array.length;j++) {
              if (array[j] <= array[min]) {
                  min=j;
              }
          }
          swap(array,min,i);
      }
    }
    public static void swap(int[]array,int i,int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
    //【堆排序】
    //调整堆
    public static void heapify(int[] array,int size,int index){
        while(true){
            int left = 2 * index + 1;
            if (left >= size) {
                return;
            }
            int max = left;
            //找出孩子结点中最大的结点下标
            if (left + 1 < size && array[left + 1] > array[left]) {//找最大
                max = left + 1;
            }
            //比较该根结点与最大的孩子结点的大小，如果孩子结点大，则换位置
            if (array[index] >= array[max]) {//比较
                return;
            }
            swap(array,index, max);//交换
            index = max;
        }
    }
    //建堆
    public static void createHeap(int[]array,int size){
        for(int i=(size-2)/2;i>=0;i--){
            heapify(array,size,i);

        }
    }
    public static void heapSort(int[]array){
        createHeap(array,array.length);
        for(int i=0;i<array.length-1;i++){
            //无序[0,array.length-i)
            //无序区间的长度：array.length-i-1
            swap(array,0,array.length-i-1);
            heapify(array,array.length-i-1,0);
        }
    }

    public static void main(String[]args){
        int[]array={9,0,5,3,7,8,4,2,1};
        selectSort1(array);
        System.out.println(Arrays.toString(array));
        selectSort2(array);
        System.out.println(Arrays.toString(array));
        heapSort(array);
        System.out.println(Arrays.toString(array));
    }
}