排序（1）

目录

一 插入排序

1.直接插入排序

2.希尔排序

二 选择排序

1.选择排序

2.堆排序

---

一 插入排序

1.直接插入排序

概念：

从一组数据的第2个数据i开始，i和后面一个数据比较，如果后面的数据比i大则交换位置，然后继续往后比较，如果比i小则结束，然后i从3开始往后比较；以此类推

 i-1比i小，交换位置，后面没有数据了i变成2

  i-1比i小，交换位置，i-1比i大i变成3，以此类推

代码：

public class Sort {
    // 直接插入排序
    public static void insertSort(int[] nums) {
        int m = 1;
        for (; m < nums.length; m++) {
            int n = m-1;
            int tmp = nums[m];
            while(n >= 0){
                if(nums[n] > tmp){
                    nums[n+1] = nums[n];
                    n--;
                }else{
                    nums[n+1] = tmp;
                    break;
                }
            }
            if(n == -1){
                nums[n+1] = tmp;
            }
        }
    }
}

属性：

时间复杂度在数据趋于有序的时候是O（n）的时候，在最坏的情况下为O（n^2）;

空间复杂度：O（1）

稳定性：稳定

注：稳定性是指在一组数据中前后有两个相同的数据，在调试完后这两个相同数据的位置不会进行交换

2.希尔排序

概念：

希尔排序是在直接插入排序的基础上进行改进，首先需要一个part为每次交换数据的间隔，一般情况下将part设为数组len的一半；

 part为3的情况下，i也从1开始遍历，然后和往后三个的6开始比较，1比6小，进行交换；然后i往后走，5和7开始比较，5比7小，进行交换； 

然后将part除2，也就是变成1，这时候就变成了直接插入排序了，但这时候数据已经趋于有序，所以遍历的次数会少很多；

 代码：

希尔排序的代码只要在直接插入排序的代码中进行修改就可以了

public class Sort {
    // 希尔排序
    public static void shellSort(int[] nums){
         int part = nums.length;
         while(part > 0){
             part = part/2;
             shell(part, nums);
         }
    }

    private static void shell(int part, int[] nums){
        //将直接插入排序中的1改为了part
        int m = part;
        for (; m < nums.length; m++) {
            int n = m-part;
            int tmp = nums[m];
            while(n >= 0){
                if(nums[n] > tmp){
                    nums[n+part] = nums[n];
                    n = n - part;
                }else{
                    nums[n+part] = tmp;
                    break;
                }
            }
            if(n < 0){
                nums[n+part] = tmp;
            }
        }
    }
}

属性：

时间复杂度：在最坏的情况下为O（n^2）,最好的情况下为O（n）因为每次进行递归的次数无法判断，时间复杂度一般被认为O（n^1.3）；

空间复杂度：O（1）；

稳定性：稳定；

二 选择排序

1.选择排序

概念：

设i=0，然后从i开始遍历一遍数组，找到最小的那个数据的位置用min记录，然后将i位置的数据和min位置的数据交换，然后i++；

交换，然后 i++

 以此类推

代码：

public class Sort{
    //选择排序
    public static void selectSort(int[] nums){
        for (int i = 0; i < nums.length; i++) {
            int min = i;
            for (int j = i; j < nums.length; j++) {
                if(nums[j] < nums[min]){
                    min = j;
                }
            }
            int tmp = nums[min];
            nums[min] = nums[i];
            nums[i] = tmp;
        }
    }
}

属性：

时间复杂度：O（n^2）

空间复杂度：O（n）

稳定性：不稳定

2.堆排序

概念：

先将一个数组变成大堆的形式，然后用i记录这个堆的最后一个节点，因为大堆的root节点肯定是这个数组中的最大值，然后将root节点和i节点进行交换，再将i-1之内的范围进行向下调整，这样root节点就是第二大的节点，i--；以此类推

 将root和i节点交换

然后i-1范围内向下i调整 ，i--

代码：

public class Sort{
// 堆排序
    public static void heapSort(int[] nums){
        for (int i = (nums.length - 2) / 2; i >= 0 ; i--) {
            shiftDown(i, nums, nums.length);
        }
        int usedsize = nums.length - 1;
        while(usedsize > 0){
            int tmp = nums[0];
            nums[0] = nums[usedsize];
            nums[usedsize] = tmp;
            shiftDown(0, nums, usedsize--);
        }
    }

    private static void shiftDown(int root, int[] nums, int usedsize){
        int left;
        while((left = root * 2 + 1) < usedsize){
            if(left + 1 != usedsize){
                if(nums[left] < nums [left + 1]){
                    left = left + 1;
                }
            }
            if(nums[root] < nums[left]){
                int tmp = nums[root];
                nums[root] = nums[left];
                nums[left] = tmp;
                root = left;
            }else {
                break;
            }
        }
    }

}

属性：

时间复杂度： O（nlogn）

空间复杂度：O（1）

稳定性：不稳定