排序算法总结

排序算法总结。

待排序的数目比较小时，可以采用插入排序和简单选择排序。

如果待排序的记录按关键字基本有序，则宜采用直接插入排序和冒泡排序。

912. 排序数组 测试程序

补充

Random random = new Random();
random.nextInt(num);//生成的数是左闭右开的，[0, num)

冒泡排序

但超时，在输入顺序是逆序时最慢

    public void bubbleSort(int[] nums){
        int n = nums.length;

        for(int i = 0; i < n - 1; i++){
            boolean flag = true;
            for(int j = 0; j < n - i  - 1 ; j++){
                if(nums[j] > nums[j + 1]){
                    swap(nums, j, j+1);
                    flag = false;
                }
            }
            if(flag == true) break;
        }
    }

    public void swap(int[] nums, int left, int right){
        int temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
    }

快速排序

三路快排

public void quickSort(int[] nums, int left, int right){
    if(left >= right) return;
    int pivotIndex = random.nextInt(right - left + 1) + left;
    swap(nums, pivotIndex, left);

    int pivot = nums[left];

    int lt = left + 1;
    int gt = right;
    //[left + 1, lt) [lt..i) (gt, right]
    int i = left + 1;
    while(i <= gt){
        if(nums[i] < pivot){
            swap(nums, lt, i);
            lt++;
            i++;
        }else if(nums[i] == pivot){
            i++;
        }else{
            swap(nums, gt, i);
            gt--;
        }
    }

    swap(nums, lt -1, left);
    quickSort(nums, left, lt - 2);
    quickSort(nums, gt + 1, right);
}

插入排序

    public void insertSort(int[] nums){
        for(int i = 1; i < nums.length; i++){
            int j = i;
            int tmp = nums[j];
            while(j > 0 && tmp < nums[j - 1]){
                nums[j] = nums[j - 1];
                j--;
            }
            if(j != i){
                nums[j] = tmp;
            }
        }
    }

希尔排序

参考

希尔排序是将待排序的数组元素 按下标的一定增量分组 ，分成多个子序列，然后对各个子序列进行直接插入排序算法排序；然后依次缩减增量再进行排序，直到增量为1时，进行最后一次直接插入排序，排序结束。

选择排序

O(n^2)复杂度， 规模越小越好

    public void selectSort(int[] nums){
        int n = nums.length;
        for(int i = 0; i < n - 1; i++){
            int minIndex = i;
            for(int j = i + 1; j < n; j++){
                if(nums[j] < nums[minIndex]){
                    minIndex = j;
                }
            }
            if(i != minIndex){
                swap(nums, minIndex, i);
            }
            
        }
    }

堆排序

    public void heapSort(int[] nums){
        int len = nums.length;
        buildMaxHeap(nums, len);
        for(int i = len - 1; i >= 1 ; --i){
            swap(nums, i, 0);
            len--;
            maxHeapify(nums, 0, len);
        }
    }

    public void buildMaxHeap(int[] nums, int len){
        //最后一个叶子元素位置nums.length - 1, 则他的父元素位置 (nums.length - 1 - 1)/2
        for(int i = (len -2)/2; i >= 0; --i){
            maxHeapify(nums, i, len);
        }
    }

    public void maxHeapify(int[] nums, int i, int len){
        //第一个元素存在0位置
        int left = (i<<1)+1, right = left + 1;
        int largest = i;
        if(left < len && nums[left] > nums[largest]){
            largest = left;
        }
        if(right < len && nums[right] > nums[largest]){
            largest = right;
        }
        if(largest != i){
            swap(nums, i, largest);
            maxHeapify(nums, largest, len);
        }
    }

    public void swap(int[] nums, int x, int y){
        int temp = nums[x];
        nums[x] = nums[y];
        nums[y] = temp;
    }

归并排序

在合并有序链表时用了很多。二路归并排序。