【数据结构】排序算法

鸽鸽程序猿

已于 2024-07-30 21:06:42 修改

阅读量3.7k

点赞数 303

分类专栏：数据结构文章标签：排序算法数据结构 java

于 2024-07-29 10:17:06 首次发布

本文链接：https://blog.csdn.net/yj20040627/article/details/140643539

版权

数据结构专栏收录该内容

11 篇文章 9 订阅

订阅专栏

排序

排序的概念：

假设含有n个记录的序列为{R1,R2,R3,···,Rn}，其相应的关键字分别为{K1,K2,K3,···Kn}，需确定1,2,3,···,n的一种排列P1,P2,···,Pn，使其相应的关键字满足Kp1 <= Kp2 <= Kp3 <= ···· <= Kpn非递减（或非递增）关系，即使得序列成为一个按关键字有序的序列{Rp1,Rp2,····,Rpn}。

排序稳定性：

假设Ki = Kj( 1 <= i <= n, 1 <= j <= n, i != j)，且在排序前的序列中Ri领先于Rj，则称所用的排序方法时稳定的；反之，若可能使得排序后的序列中Rj领先于Ri，则称所用的排序算法是不稳定的。

也就是说如果两元素相同排序前啥位置排序后还是啥位置该排序就稳定，反之不稳定。

内排序：

内排序是在排序的整个过程中，将排序所有记录全部放置在内存中。

外排序：

外排序是由于排序的记录个数太多，不能同时放在内存中。外排序是由于排序的记录个数太多，不能同时放置在内存中，整个排序过程需要在内外存之间多次交换数据才能进行。

常见排序如下图：

以下排序都是实现从小到大。

冒泡排序

原理：两两比较相邻记录的关键字，如果反序就交换直到没有反序记录为止。

实现思路：

外循环实现比较趟数。
内循环实现从末尾找到最小值向前排。

如此每一趟都可以将一个最小值排在前面。

代码已优化点：

使用了一个falg标记，如果该趟没有交换证明数组已经有序，直接结束。
使用j > i作为第二层循环的结束条件而不是j > 0减少了循环次数。

时间复杂度：O(N^2) 。
空间复杂度：O(1)。
稳定性：稳定。

public void bubbleSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            boolean flag = false;
            for (int j = array.length - 1; j > i; j--) {
                if(array[j] < array[j - 1]){
                	//交换
                    int tmp = array[j - 1];
                    array[j - 1] = array[j];
                    array[j] = tmp;
                    
                    flag = true;
                }
            }
            if(!flag){
                break;
            }
        }
    }

选择排序

原理：就是通过n - i 次关键字之间的比较，从n - i + 1 个记录中选出关键字最小的记录，并和第 i （1 <= i <= n）个记录交换。

实现思路：

外循环控制每次最小值放入的位置。
内循环找到当前的最小值下标。
出内循环将最小值与当前应放入位置交换。
每一次都可以挑选一个最小值出来。与冒泡排序有相似之处，但是冒泡相邻比较交换，选择排序是每次交换最小值。

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

	// 选择排序
    public void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if(array[j] < array[minIndex]){
                    minIndex = j;
                }
            }
            int tmp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = tmp;
        }
    }

实现思路2：

我们选择时可以将最小值下标和最大值下标一同记录下来。
已升序为例，将最小值放在前面，最大值放在后面，但是我们要注意如果最大值是左边要换的元素，那在前面换了后要将最大值下标更换为交换后的下标。

//选择排序
    private void selectSort2(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        while(left < right){
            int minIndex = left;
            int maxIndex = left;
            
            for(int j = left + 1;j <= right; j++){
                if(nums[j] < nums[minIndex]){
                    minIndex = j;
                }
                if(nums[j] > nums[maxIndex]){
                    maxIndex = j;
                }
            } 
            swap(nums,minIndex,left);
            //排除最大值在走边被换走了
            if(maxIndex == left){
                maxIndex = minIndex;
            }
            swap(nums,maxIndex,right);
            left++;
            right--;
        }
    }

直接插入排序

原理：直接插入排序的基本操作就是将一个记录插入到已经排好序的有序表中，从而得到一个新的，记录增1的有序表。

实现思路：

外部使用循环控制当前填入前方有序数组的值tmp。
内部循环从当前前一个下标开始往回遍历，遇到比tmp大的值就往后覆盖，否则就出循环（因为前面已经是有序的了）。
最后一定要将 j+1 下标置为tmp（因为出第二层循环时要么为-1要么当前j下标值小于等于tmp）。

时间复杂度：O(N^2)。
空间复杂度：O(1)。
稳定性：稳定。

//直接插入排序
public void insertSort(int[] array){
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                if(array[j] > tmp){
                    array[j+1] = array[j];
                }else{
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

希尔排序

原理：将大量记录数的记录进行分组。分割成若干个子序列，此时每个子序列待排序的记录个数就比较少了，然后在这些子序列中分别进行直接插入排序，当整个序列基本有序时，再对全体记录进行一次直接插入排序。

实现思路：

在希尔排序中循环调用修改后的直接插入排序。
gap代表增量，相当于 i 下标与 i + gap * n下标的值为一组。
对每组进行直接插入排序。

时间复杂度：O(n^1.3 )至 O( n^1.5)之间。
空间复杂度：O(1)。
稳定性：不稳定。

        // 希尔排序
    public void shellSort(int[] array){
            int gap = array.length;
            while(gap > 1){
                gap /= 2;
                shell(array,gap);
            }
    }

    private void shell(int[] array, int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i - gap;
            for (; j >= 0; j -= gap) {
                if(array[j] > tmp){
                    array[j+gap] = array[j];
                }else{
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }

堆排序

原理：将待排序的序列构造成一个大根堆。此时，整个序列的最大值就是堆顶元素。将它移走（其实就是将堆顶元素与堆尾元素交换，此时末尾元素就是最大值），然后将剩余的n - 1个序列重新构造成一个大根堆，这样就可以得到n个元素中的次大值。如此反复操作，便能得到一个有序序列。

实现思路：

根据排序需求（升序实现大根堆，降序实现小根堆），实现堆。
每次将堆顶元素放末尾，将剩余元素再变为堆。

实现堆的描述

时间复杂度：O(N*logN)。
空间复杂度：O(1)。
稳定性：不稳定。

// 堆排序
    public static void heapSort(int[] array) {
        createHeap(array);
        int end = array.length-1;
        while (end > 0) {
            swap(array,0,end);
            siftDown(array,0,end);
            end--;
        }
    }
    //实现大根堆
    private static void createHeap(int[] array) {
        for (int parent = (array.length-1-1)/2; parent >= 0; parent--) {
            siftDown(array,parent,array.length);
        }

    }
    private static void siftDown(int[] array, int parent, int length) {
        int child = 2 * parent + 1;
        while (child < length) {
            if(child + 1 < length && array[child] < array[child+1]) {
                child++;
            }
            if(array[child] > array[parent]) {
                swap(array, parent, child);
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }
    //交换函数
    private static void swap(int[] array, int x, int y) {
        int tmp = array[x];
        array[x] = array[y];
        array[y] = tmp;
    }

归并排序

原理：假设初始序列含有n个记录，则可以看成n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2向上取整个长度为2或1的有序子序列；再两两归并，如此重复，直至得到一个长度为n的有序序列为止，这种排序称为2路归并排序。

实现思路：

分解逻辑：将递归结束条件变为左下标大于右下标达到每个子序列只有1个元素。
合并逻辑：因为两个子序列本身是有序的了，只要将两个序列从左到右的最小值依次放入临时数组，最后有一个数组剩余元素直接放入即可。（注意临时数组返回给目标数组时开头不是0下标开始）

时间复杂度：O(N*logN)。
空间复杂度：O(N)。
稳定性：稳定。

	//归并排序
     public void mergeSort(int[] nums) {
        mergeSortSplit(nums,0,nums.length - 1);
     }
     private void mergeSortSplit(int[] nums, int left, int right) {
        if(left >= right){
            return;
        }
        //分解
        int mid = (left + right) / 2;
        mergeSortSplit(nums,left,mid);
        mergeSortSplit(nums,mid+1,right);
        //合并
        merge(nums,left,mid,right);
     }
     private void merge(int[] nums, int left, int mid, int right) {
        int[] tmp = new int[right - left + 1];
        int tmpIndex = 0;
        int leftIndex = left;
        int rightIndex = mid + 1;
        while(leftIndex <= mid && rightIndex <= right){
            if(nums[leftIndex] < nums[rightIndex]){
                tmp[tmpIndex++] = nums[leftIndex++];
            }else {
                tmp[tmpIndex++] = nums[rightIndex++];
            }
        }

归并排序非递归实现

实现思路：

我们使用1个gap来代表每个待合并子序列的长度。
在通过gap计算出左右边界和中间值，要限制右边界和中间值不要越界。
再合并即可。

	//归并排序非递归实现
      private void mergeSortNor(int[] nums) {
        int gap = 1;
        while(gap < nums.length) {
            for(int i = 0; i < nums.length; i = i + gap * 2) {
                int left = i;
                int mid = left + gap - 1;
                int right = mid + gap;
                if(mid >= nums.length) {
                    mid = nums.length - 1;
                }
                if(right >= nums.length) {
                    right = nums.length - 1;
                }
                merge(nums,left,mid,right);
            }
            gap *= 2;
        }
      }

快速排序

原理：通过一趟排序将待排序记录分割成独立的两个部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录进行排序，以达到整个序列有序的目的。

还有一种解释：

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，
左子序列中所有元素均小于基准值，
右子序列中所有元素均大于基准值，
然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

按基准划分左右的3种方法

Hoare法：选定序列第一个为基准，从后边往前找到比基准小的停下来，从前边找到比基准大的停下来，交换直到左右相遇，相遇下标的值与基准交换。
代码实现如下：返回基准下标。

 private int partition(int[] nums, int left, int right){
        int tmp = nums[left];
        int start = left;
        while(left < right){
            while(left < right && nums[left] <= tmp){
                left++;
            }
            while(left < right && nums[right] >= tmp){
                right--;
            }
            swap(nums,left,right);
        }
        //先找左边就要判断该值是不是比基准大，先从右边找就不用。
        if(left > 0 && nums[left] >= nums[start]){
            swap(nums,left - 1,start);
            return left - 1;
        }
        swap(nums,left,start);
        return left;
    }

挖坑法：选定序列第一个为基准，先将基准值记录下来，再先从后面找到比基准小的，将其放入基准位置，再先从前面找到比基准大的，将其放入先前后面找到的比基准小的位置，在从后找放入前面比基准大的位置，循环往复直到左右相遇，将先前记录下来的基准位置放入相遇位置。
代码实现如下：

private int partitionDig(int[] nums,int left, int right){
        int tmp = nums[left];
        while(left < right){
            while(left < right && nums[right] >= tmp){
                right--;
            }
            nums[left] = nums[right];
            while(left < right && nums[left] <= tmp){
                left++;
            }
            nums[right] = nums[left];
        }
        nums[left] = tmp;
        return left;
    }

前后指针：选定序列第一个为基准，初始prev指针指向序列开头，cur指向prev下一个位置，
然后判断cur指针指向的数据是否小于基准，
若小于并且prev后一位不是cur则prev后移一位，并将cur与prev内容交换，然后cur后移一位，
若大于，则只要cur后移一位。

private int partitionTwoPoint(int[] nums, int left, int right){
        int prev = left; 
        int cur = prev + 1;
        while(cur <= right){
            if(nums[cur] < nums[left] && nums[++prev] != nums[cur]){
                swap(nums,cur,prev);
            }
            cur++;
        }
        swap(nums,prev,left);
        return prev;
    }

快排实现

时间复杂度：O(N*logN)至O(n^2)。
空间复杂度：O(logN)至O(N)。
稳定性：不稳定。

	//快速排序
	public static void quickSort(int[] array) {
        quick(array,0,array.length-1);
    }

    private static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }
        int pivot = partition(array,start,end);
        quick(array,start,pivot-1);
        quick(array,pivot+1,end);
    }
    private int partitionDig(int[] nums,int left, int right){
        int tmp = nums[left];
        while(left < right){
            while(left < right && nums[right] >= tmp){
                right--;
            }
            nums[left] = nums[right];
            while(left < right && nums[left] <= tmp){
                left++;
            }
            nums[right] = nums[left];
        }
        nums[left] = tmp;
        return left;
    }

快排优化

三数取中法优化：在选基准时我们不是都固定选的第一个为基准吗，而现在我们就是选择头尾和中间三个位置的中间数来放入第一位作为基准。如此可以保证每次都可以有两个分支不是单分支往下"递归"。
以挖坑法代码举例：

	private int partitionDig(int[] nums,int left, int right){
		swap(nums,middle(nums,left,right),left);
        int tmp = nums[left];
        while(left < right){
            while(left < right && nums[right] >= tmp){
                right--;
            }
            nums[left] = nums[right];
            while(left < right && nums[left] <= tmp){
                left++;
            }
            nums[right] = nums[left];
        }
        nums[left] = tmp;
        return left;
    }
    //返回中间值的下标
    private int middle(int[] nums, int left, int right){
    	int mid = (left + right) / 2;
    	if(nums[left] < nums[right]){
    		if(nums[mid] < nums[left]) return left;
    		if(nums[mid] > nums[right]) return right;
    		return mid;
    	} else{
    		if(nums[mid] < nums[right]) return right;
    		if(nums[mid] > nums[left]) return left;
    		return mid;
    	}
    }

递归到小的子区间时，使用直接插入排序，因为直接插入排序的特点就是越有序越快。

    private static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }
        if(end - statrt >= 10){
        	insertSortRange(array,start,end);
        	return;
        }
        int pivot = partition(array,start,end);
        quick(array,start,pivot-1);
        quick(array,pivot+1,end);
    }
    public void insertSortRange(int[] array, int start, int end){
        for (int i = start + 1; i <= end; i++) {
            int tmp = array[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                if(array[j] > tmp){
                    array[j+1] = array[j];
                }else{
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

快排非递归实现

实现思路：

先求得基准下标。
将子序列左右边界依次入栈，注意当子序列只有一个元素时不入。
再出栈两个元素拿到子序列的边界在调用基准划分方法，再进行第二步。

	//快排非递归实现
    private void quickNor(int[] nums, int left, int right) {
        Stack<Integer> stack = new Stack<>();
        int pivot = partitionDig(nums,left,right);
        if(pivot > left + 1){
            stack.push(left);
            stack.push(pivot - 1);
        }
        if(pivot < right - 1){
            stack.push(pivot + 1);
            stack.push(right);
        }
        while(!stack.isEmpty()){
            right = stack.pop();
            left = stack.pop();
            
            pivot = partitionDig(nums,left,right);
            if(pivot > left + 1){
                stack.push(left);
                stack.push(pivot - 1);
            }
            if(pivot < right - 1){
                stack.push(pivot + 1);
                stack.push(right);
            }
        }
    }

总结

对上面7种基于比较的排序算法进行总结：
稳定的排序只有3种：冒泡排序，直接插入排序，归并排序。
时间复杂度由大到小就是目录的顺序。

该图不是我总结的

基于非比较的排序

计数排序

原理：统计相同元素出现次数，根据统计的结果将序列回收到原来的序列中。

实现原理：

先求的待排序数组的最大值和最小值，计数数组的长度就是二者差值加1。
将遇到待排序数组元素对应的计数数组下标元素（即待排序数组元素减去最小值作为计数数组下标）加1。
最后遍历计数数组返回下标加最小值存储到待排序数组中，直到计数数组元素全为0。

时间复杂度：O( Max(N，范围) )。
空间复杂度：O(范围)。
稳定性：稳定。
范围就是指计数数组长度。

	//计数排序
    private void countSort(int[] nums){
        int max = nums[0];
        int min = nums[0];
        //求得计数数组长度
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] > max) {
                max = nums[i];
            }
            if(nums[i] < min) {
                min = nums[i];
            }
        }
        //计数数组存储
        int[] countNums = new int[max - min + 1];
        for(int i = 0; i < nums.length; i++) {
            countNums[nums[i] - min]++;
        }
        int numsIndex = 0;
        //排序
        for(int i = 0; i < countNums.length; i++) {
            while(countNums[i] > 0) {
                nums[numsIndex++] = i + min;
                countNums[i]--;
            }
        }
    }