排序（java）

数组排序（力扣）

排序数组

题目：
给你一个整数数组 nums，请你将该数组升序排列。

示例 1：
输入：nums = [5,2,3,1]
输出：[1,2,3,5]

示例 2：
输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

提示：
1 <= nums.length <= 5 * 104
-5 * 104 <= nums[i] <= 5 * 104

方法一：直接插入排序

原理：当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。

public void inserSort(int[] arr){
            //选择第一个为起始数据
            for(int i = 1; i < arr.length;i++){
                //待插入数据
                int temp = arr[i];
                
                //需要比较数组的最大下标
                int j = i-1;
                //从后往前比较
                for(;j >= 0;j--){
                    //升序：数据大的后移
                    if(temp < arr[j]){
                        arr[j+1] = arr[j];
                    }else {
                        break;
                    }
                }
                //将数据插入对应位置
                arr[j+1] = temp;
            }
    }

方法二：希尔排序
原理：希尔排序法又称缩小增量法。希尔排序法的基本思想是：
先选定一个整数（一般为：每排序一趟则gap = gap/2，初始gap为数组长度/2）把待排序数据按当前步长（gap）分成组，所有距离相同的数据分在同一组内，并对每一组内的数据进行排序。然后，重复上述分组和排序的工作。当步长（gap）=1时（此时为直接插入排序），所有数据在统一组内排好序。如下图gap = 5（10个数据/2）

public void shellSort(int[] nums){
     int gap = nums.length;
     //当步长为1时相当于是直接插入排序
        while(gap > 1){
            gap /= 2;
            //以gap步长进行分组
            for(int i = gap; i < nums.length;i++){
                //待插入的数据
                int temp = nums[i];
                //本轮数据插入组内的最大下标
                int j = i - gap;
                //将待插入数据在组内进行排序
                for(;j >= 0; j-= gap){
                    if(temp < nums[j]){
                        nums[j + gap] = nums[j];
                    }else {
                        break;
                    }
                }
                nums[j + gap] = temp;
            }
        }
}

方法三：堆排序（升序大根堆，降序小根堆）
一般使用向下调整法建堆，建堆后再将堆顶元素（此时是整个数组最大值）放到队尾，再将堆进行调整保持堆顶（除了被放至堆尾的元素）为最大元素

class Solution {
    public int[] sortArray(int[] nums) {
      //1.升序创建大根堆
        creatBigHeap(nums);
      //2.大根堆创建完成后，将堆按照升序排列在数组中
      int end = nums.length - 1;
      for(int i = end; i > 0; i--){
          //最大值放到数组末尾
          swap(nums,0,i);
          //向下调整
          shiftDown(nums,0,i);
      }
      return nums;
    }
    
    public void creatBigHeap(int[] nums){
        //寻找父节点下标
        int len = nums.length;
        for(int parent = (nums.length - 1 -1) / 2; parent >= 0; parent--){
            //向下调整，使之成为大根堆
            shiftDown(nums,parent,len);
        }
    }

    public void shiftDown(int[] nums,int parent,int len){
        //找父节点的左孩子
        int child = parent * 2 + 1;
        //保证左孩子存在
        while(child < len){
            //保证右孩子存在
            if(child + 1 < len && nums[child] < nums[child + 1]){
                //调整，保证child下标为最大值
                child++;
            }
            //调整为大根堆，孩子节点大，则与父节点交换
            if(nums[child] > nums[parent]){
                swap(nums,child,parent);
                //上一步交换一旦发生，会影响大根堆结构（不再是大根堆），所以要向下调整
                parent = child;
                child = parent * 2 + 1;
            }else {
                //交换未发生，则堆未发生变化，不需要向下调整
                break;
            }

        }
    }
  
    public void swap(int[] nums,int i,int j){
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

方法三：冒泡排序（优化）

class Solution {
    public int[] bubbleSort(int[] nums) {
    	//标志位：记录第i趟排序时数据是否有序
        int flag = 0;
        //排序所需趟数
        for(int i = 0;i < nums.length - 1;i++){
        	//先假设该趟数组有序
            flag = 1;
            for(int j = 0;j < nums.length - 1 - i;j++ ){
            	//（升序）找到前面数据大于后面数据->无序
                if(nums[j] > nums[j + 1]){
                    int tmp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = tmp;
                    //标志位清零，本趟无序
                    flag = 0;
                }
        }
        //如果本趟有序了，直接跳出循环排序结束
        if(flag == 1){
            break;
        }
    }
    return nums;   
    }
}