• 七大基于比较的排序算法（JAVA）

    目录

    冒泡排序

    优化：

    堆排序

    插入排序

    希尔排序

    归并排序

    快速排序

    优化

    选择排序 

     排序算法的稳定性： 大小相同的元素在排序前后相对位置相同就称其为稳定的排序。

    注：一个本身就是稳定的排序 是可以实现为不稳定的排序的 ；但是相反 一个本身就不稳定的排序 是不可能实现为稳定的排序的。

    稳定的排序算法：插入排序 冒泡排序 归并排序

    冒泡排序

    时间复杂度： o(n^2)   如果加了优化  最好情况O(N)
    空间复杂度：O(1)
    稳定性： 稳定

    1.     public static void bubbleSort(int[] array){
    2.  
    3.         for (int i = 0; i < array.length-1; i++) {
    4.             for (int j = 0; j < array.length-1; j++) {
    5.                 if (array[j] > array[j+1]) {
    6.                     swap(array, j, j+1);
    7.                 }
    8.             }
    9.         }
    10.     }
    11.  
    12.     private static void swap(int[] array, int minIndex, int i) {
    13.         int tmp = array[i];
    14.         array[i] = array[minIndex];
    15.         array[minIndex] = tmp;
    16.     }

    优化：

    1.      public static void bubbleSort(int[] array) {
    2.         for (int i = 0; i < array.length-1; i++) {
    3.             boolean flg = false;
    4.             for (int j = 0; j < array.length-1-i; j++) {
    5.                 if(array[j] > array[j+1]) {
    6.                     swap(array,j,j+1);
    7.                     flg = true;
    8.                 }
    9.             }
    10.             if(!flg) {
    11.                 return;
    12.             }
    13.         }
    14.     }

    堆排序

    时间复杂度：O(n*logN)    N^1.3 -->
    空间复杂度：O(1)
    稳定性：不稳定
    数据量非常 大的时候 堆排 一定比希尔快

    堆排序的原理：

    1. 用一个大根堆的堆顶元素和最后一个元素交换
    2. 使数组长度减一
    3. 在重新将堆调整为大根堆

    1.     public static void heapSort(int[] array){
    2.  
    3.         createHeap(array);
    4.         for (int i = 0; i < array.length - 1; i++) {
    5.             swap(array, 0, array.length-1-i);
    6.             shiftDown(array, 0, array.length-1-i);
    7.         }
    8.     }
    9.  
    10.     private static void createHeap(int[] array) {
    11.         for (int i = (array.length-1-1)/2; i >= 0; i--) {
    12.             shiftDown(array, i, array.length);
    13.         }
    14.     }
    15.  
    16.     private static void shiftDown(int[] array, int i, int length) {//length个元素
    17.         int child = i * 2 + 1;
    18.         while (child < length) {
    19.             if (child + 1 < length && array[child] < array[child+1]) {
    20.                 child++;
    21.             }
    22.             if (array[child] > array[i]) {
    23.                 swap(array, child, i);
    24.                 i = child;
    25.             }else {
    26.                 break;
    27.             }
    28.             child = i * 2 + 1;
    29.         }
    30.     }
    31.     private static void swap(int[] array, int minIndex, int i) {
    32.         int tmp = array[i];
    33.         array[i] = array[minIndex];
    34.         array[minIndex] = tmp;
    35.     }

    插入排序

    时间复杂度：
            最好情况：数据完全有序的时候 O(N)
            最坏情况：数据完全逆序的时候 O(N^2)
    空间复杂度：O(1)
    稳定性：稳定


    插入排序的原理

    1. 从左边第一位开始挨个令其成为关键码
    2. 从左到右把待排序的记录按其关键码值的大小逐个插入到左边已经排好序的有序序列中
    3. 直到所有的记录插入完为止，得到一个新的有序序列
    1.     public static void insertSort(int[] array){
    2.  
    3.         for (int i = 1; i < array.length; i++) {
    4.             int tmp = array[i];
    5.             int j = i - 1;
    6.             for (; j >= 0 ; j--) {
    7.                 //如果此处改为array[j] >= tmp就会变成不稳定排序
    8.                 if (array[j] > tmp) {
    9.                     array[j+1] = array[j];
    10.                 }else{
    11.                     break;
    12.                 }
    13.             }
    14.             array[j+1] = tmp;
    15.         }
    16.     }

    希尔排序

    时间复杂度：
                 约等于：n^1.3 - n^1.5
    复杂度：O(1)
    稳定性：不稳定

    希尔排序其实就是对插入排序的一种优化

    基本原理：

    1. 先按照步长将数组分为若干组
    2. 对每组进行插入排序
    3. 减小步长重复以上步骤

    1.     public static void shellSort(int[] array){
    2.  
    3.         int gap = array.length;
    4.         while (gap > 1) {
    5.             gap = gap / 2;
    6.             shell(array, gap);
    7.         }
    8.     }
    9.  
    10.     private static void shell(int[] array, int gap) {
    11.         for (int i = gap; i < array.length; i++) {
    12.             int tmp = array[i];
    13.             int j = i-gap;
    14.             for (; j >= 0; j -= gap) {
    15.                 if (array[j] > tmp) {
    16.                     array[j+gap] = array[j];
    17.                 }else {
    18.                     break;
    19.                 }
    20.             }
    21.             array[j+gap] = tmp;
    22.         }
    23.     }

    归并排序

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

    归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

    可参考：http://t.csdnimg.cn/Yd62c

    1.     public void mergerSort(int[] nums, int left, int right) {//right:数组长度减一
    2.         if (left >= right) {
    3.             return;
    4.         }
    5.         int mid = (left + right) / 2;
    6.         mergerSort(nums, left, mid);
    7.         mergerSort(nums, mid + 1, right);
    8.         merger(nums, left, mid, right);
    9.     }
    10.  
    11.     private void merger(int[] nums, int left, int mid, int right) {
    12.         int[] tmp = new int[right-left+1];
    13.         int i = 0;
    14.         int l = left;
    15.         int r = mid + 1;
    16.         while (l <= mid && r <= right) {
    17.             if (nums[l] < nums[r]) {
    18.                 tmp[i++] = nums[l++];
    19.             }else {
    20.                 tmp[i++] = nums[r++];
    21.             }
    22.         }
    23.         while (l <= mid) {
    24.             tmp[i++] = nums[l++];
    25.         }
    26.         while (r <= right) {
    27.             tmp[i++] = nums[r++];
    28.         }
    29.         i = 0;
    30.         for (int j = 0; j < tmp.length; j++) {
    31.             nums[left++] = tmp[j];
    32.         }
    33.     }

    快速排序

    时间复杂度：
            最好情况:O(N*logN)   满二叉树/完全二叉树
            最坏情况:O(N^2) 单分支的树
    空间复杂度：
            最好情况:O(logN)   满二叉树/完全二叉树
            最坏情况:O(N)   单 分支的树
    稳定性：不稳定

    快速排序基本原理

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

    有Hoare法   挖坑版法  前后指针法
    这里只介绍Hoare法

    1.     public static void quickSort(int[] array){
    2.  
    3.         quick(array, 0, array.length-1);
    4.     }
    5.  
    6.     private static void quick(int[] array, int left, int right) {
    7.         if (left >= right) {
    8.             return;
    9.         }
    10.         int Index = findSwap(array, left, right);
    11.         quick(array, left, Index-1);
    12.         quick(array, Index+1, right);
    13.  
    14.     }
    15.     
    16.     private static int findSwap(int[] array, int left, int right) {
    17.         int key = array[left];
    18.         int keyIndex = left;
    19.         while (left < right) {
    20.             //必须right先走
    21.             //如果是left先走，两个相遇的地方一定比key大
    22.             while (left < right && array[right] >= key) {
    23.                 right--;
    24.             }
    25.             while (left < right && array[left] <= key) {
    26.                 left++;
    27.             }
    28.             swap(array, right, left);
    29.         }
    30.         if (left == right) {
    31.             swap(array, keyIndex, left);
    32.         }
    33.         return left;
    34.     }
    35.  
    36.     private static void swap(int[] array, int minIndex, int i) {
    37.         int tmp = array[i];
    38.         array[i] = array[minIndex];
    39.         array[minIndex] = tmp;
    40.     }

    优化

    利用三数取中法来避免单分支树的形成（尽量降低树的高度）

    1.     public int[] sortArray(int[] nums) {
    2.         //快速排序
    3.         quickSort(nums, 0, nums.length-1);
    4.         return nums;
    5.     }
    6.  
    7.     private void quickSort(int[] nums, int left, int right) {
    8.         if (left >= right) {
    9.             return;
    10.         }
    11.         //三数取中法
    12.         swap(nums, left, threeNumMid(nums, left, right));
    13.         //也可以在这里加一个判断当左右之间的数据个数小于一定值然后调用插入排序
    14.         //因为在排序过程中数组会趋近于有序所以插入排序的效率会很快
    15.         int pivot = quick(nums, left, right);
    16.         quickSort(nums, left, pivot-1);
    17.         quickSort(nums, pivot+1, right);
    18.     }
    19.  
    20.     private int threeNumMid(int[] nums, int left, int right) {
    21.         int mid = (left + right) / 2;
    22.         if (nums[left] > nums[right]) {
    23.             if (nums[mid] > nums[left]) {
    24.                 return left;
    25.             }else if (nums[mid] < nums[right]) {
    26.                 return right;
    27.             }else {
    28.                 return mid;
    29.             }
    30.         }else {
    31.             if (nums[mid] < nums[left]) {
    32.                 return left;
    33.             }else if (nums[mid] > nums[right]) {
    34.                 return right;
    35.             }else {
    36.                 return mid;
    37.             }
    38.         }
    39.     }
    40.  
    41.     private int quick(int[] nums, int left, int right) {
    42.         int index = left;
    43.         int key = nums[left];
    44.         while (left < right) {
    45.             while (left < right && nums[right] >= key) {
    46.                 right--;
    47.             }
    48.             while (left < right && nums[left] <= key) {
    49.                 left++;
    50.             }
    51.             swap(nums, right, left);
    52.         }
    53.         swap(nums, index, left);
    54.         return left;
    55.     }
    56.  
    57.     private void swap(int[] nums, int left, int right) {
    58.         int tmp = nums[left];
    59.         nums[left] = nums[right];
    60.         nums[right] = tmp;
    61.     }

    选择排序 

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

    选择排序基本原理：

    1. 从左至右每一次从待排序的数据元素中选出最小（或最大）的一个元素
    2. 将其放在待排序元素的起始位置，已有序元素的最后边
    3. 重复上述步骤直到全部待排序的数据元素排完 。
    1.     public static void selectSort(int[] array){
    2.  
    3.         for (int i = 0; i < array.length; i++) {
    4.             int minIndex = i;
    5.             for (int j = i+1; j < array.length; j++) {
    6.                 if (array[minIndex] > array[j]) {
    7.                     minIndex = j;
    8.                 }
    9.             }
    10.             swap(array, minIndex, i);
    11.         }
    12.     }
    13.  
    14.     private static void swap(int[] array, int minIndex, int i) {
    15.         int tmp = array[i];
    16.         array[i] = array[minIndex];
    17.         array[minIndex] = tmp;
    18.     }
  • 相关阅读:
    k8s中几个基本概念的理解，pod,service,deployment,ingress的使用场景
    PCB走线规则
    安装了 vue-cli，竟然提示 zsh: command not found: v
    SSRF
    自动化测试，5个技巧轻松搞定
    GPT引领前沿与应用突破之GPT4科研实践技术与AI绘图
    发布、部署，傻傻分不清楚？从概念到实际场景，再到工具应用，一篇文章让你彻底搞清楚
    php常用算法
    【精品】JavaScript中获取URL中参数值的方法汇总
    Unreal引擎性能分析及优化
  • 原文地址：https://blog.csdn.net/2302_76339343/article/details/133498231