private void shellSor2(int[] nums) { int gap = nums.length >> 1; while (gap > 0) { for (int i = 0; i < gap; i++) {// 对每个子序列进行排序 for (int j = i+gap; j < nums.length; j+=gap) {// 插入排序的部分 int temp = j; while (temp > i && nums[temp] < nums[temp-gap]) { swap(nums, temp, temp-gap); temp -= gap; } } } gap >>= 1; } }

private void mergeSort(int[] nums, int left, int right) {// 需要左右边界确定排序范围 if (left >= right) return; int mid = (left+right) / 2; mergeSort(nums, left, mid); // 先对左右子数组进行排序 mergeSort(nums, mid+1, right); int[] temp = new int[right-left+1]; // 临时数组存放合并结果 int i=left,j=mid+1; int cur = 0; while (i<=mid&&j<=right) {// 开始合并数组 if (nums[i]<=nums[j]) temp[cur] = nums[i++]; else temp[cur] = nums[j++]; cur++; } while (i<=mid) temp[cur++] = nums[i++]; while (j<=right) temp[cur++] = nums[j++]; for (int k = 0; k < temp.length; k++) {// 合并数组完成，拷贝到原来的数组中 nums[left+k] = temp[k]; } }

private void quickSort(int[] nums, int left, int right) { if (left >= right) return; int lo = left+1; // 小于分界点元素的最右侧的指针 int hi = right; // 大于分界点元素的最左侧的指针 while (lo<=hi) { if (nums[lo]>nums[left]) { // 交换元素确保左侧指针指向元素小于分界点元素 swap(nums, lo, hi); hi--; } else { lo++; } } lo--; // 回到小于分界点元素数组的最右侧 swap(nums, left, lo); // 将分界点元素移到左侧数组最右侧 quickSort2(nums, left, lo-1); quickSort2(nums, lo+1, right); }

private void quickSort(int[] nums, int left, int right) { if (left>=right) return; int cur = left + 1; // 从左侧第二个元素开始 int lo = left; // 分界点为第一个元素 while (cur <= right) { if (nums[cur] <= nums[left]) {// 交换位置保证lo的左侧都是小于num[left] swap(nums, lo+1, cur); lo ++; } cur++; } swap(nums, left, lo); // 把分界点元素移动到新的分界位置 quickSort(nums, left, lo-1); quickSort(nums, lo+1, right); }

private void heapSort(int[] nums) { heapify(nums); // 新建一个最大堆 for (int i = nums.length - 1; i >= 1; i--) { swap(nums, 0, i); // 弹出最大堆的堆顶放在最后 rebuildHeap(nums, 0,i-1); // 重建最大堆 } }private void heapify(int[] nums) { for (int i = 1; i < nums.length; i++) { int par = (i-1)>>1; // 找到父节点 int child = i; // 定义子节点 while (child>0&&nums[par]> 1; } } }private void rebuildHeap(int[] nums, int par, int last) { int left = 2*par+1; // 左子节点 int right = 2*par+2; // 右子节点 int maxIndex = left; if (right<=last && nums[right]>nums[left]) {// 找到最大子节点 maxIndex = right; }if (left<=last && nums[par] < nums[maxIndex]) {// 和最大子节点比较 swap(nums, par, maxIndex); // 互换到最大子节点 rebuildHeap(nums, maxIndex, last); // 重建最大子节点代表的子树 } }

private int[] bstSort(int[] nums) { TreeNode root = new TreeNode(nums[0]); // 构建根节点 for (int i = 1; i < nums.length; i++) {// 将所有的元素插入到二叉搜索树中 buildTree(root, nums[i]); } inorderTraversal(root, nums, new int[1]); // 中序遍历获取二叉树中的所有节点 return nums; }private void inorderTraversal(TreeNode node, int[] nums, int[] pos) { if (node == null) return; inorderTraversal(node.left, nums, pos); nums[pos[0]++] = node.val; inorderTraversal(node.right, nums, pos); }private void buildTree(TreeNode node, int num) { if (node == null) return; if (num >= node.val) {// 插入到右子树中 if (node.right == null) { node.right = new TreeNode(num); } else { buildTree(node.right, num); } } else {// 插入到左子树中 if (node.left == null) { node.left = new TreeNode(num); } else { buildTree(node.left, num); } } }static class TreeNode {// 树节点的数据结构 int val; TreeNode left; TreeNode right; public TreeNode(int val) { this.val = val; } }

private void countSort(int[] nums) { int min = Integer.MAX_VALUE; int max = Integer.MIN_VALUE; for (int num : nums) {// 找到最大最小值 min = Math.min(min, num); max = Math.max(max, num); } int[] count = new int[max-min+1]; // 建立新数组 for (int num : nums) {// 统计每个元素出现频率 count[num-min]++; } int cur = 0; for (int i = 0; i < count.length; i++) {// 根据出现频率把计数数组中的元素放回到旧数组中 while (count[i]>0) { nums[cur++] = i+min; count[i]--; } } }

private void bucketSort(int[] nums) { int INTERVAL = 100; // 定义桶的大小 int min = Integer.MAX_VALUE; int max = Integer.MIN_VALUE; for (int num : nums) {// 找到数组元素的范围 min = Math.min(min, num); max = Math.max(max, num); } int count = (max - min + 1); // 计算出桶的数量 int bucketSize = (count % INTERVAL == 0) ?( count / INTERVAL) : (count / INTERVAL+1); List[] buckets = new List[bucketSize]; for (int num : nums) {// 把所有元素放入对应的桶里面 int quotient = (num-min) / INTERVAL; if (buckets[quotient] == null) buckets[quotient] = new ArrayList<>(); buckets[quotient].add(num); } int cur = 0; for (List bucket : buckets) { if (bucket != null) { bucket.sort(null); // 对每个桶进行排序 for (Integer integer : bucket) {// 还原桶里面的元素到原数组 nums[cur++] = integer; } } } }

private void radixSort(int[] nums) { int max = -1; int min = 1; for (int num : nums) {// 计算最大最小值 max = Math.max(max, num); min = Math.min(min, num); } max = Math.max(max, -min); // 求得绝对值最大的值 int digits = 0; while (max > 0) {// 计算绝对值最大的值的位数 max /= 10; digits++; } List[] buckets = new List[19]; // 建一个包含所有位数的数组 for (int i = 0; i < buckets.length; i++) { buckets[i] = new ArrayList<>(); } int pos; int cur; for (int i = 0, mod = 1; i < digits; i++, mod*=10) { // 对十进制每一位进行基数排序 for (int num : nums) {// 扫描数组将值放入对应的桶 pos = (num / mod) % 10; buckets[pos+9].add(num); } cur = 0; for (List bucket : buckets) { // 将桶内元素放回到数组里面 if (bucket!=null) { for (Integer integer : bucket) { nums[cur++] = integer; } bucket.clear(); // 将桶清空 } } } }

超详细十大经典排序算法总结（java代码）
十大经典排序算法
十大经典排序算法（动图演示）
Sorting algorithm
Timsort
Data Structure - Sorting Techniques
This is the fastest sorting algorithm ever
TimSort
Timsort: The Fastest sorting algorithm for real-world problems

推荐阅读

• 

  椰子油的生活小妙用 椰子油有什么用途和功效
• 

  庆东锅炉故障代码是什么如何解决
• 

  教学教务管理人员是干什么的
• 

  联想yoga2
• 

  如何选择抗体稀释液？ 抗体稀释液
• 

  下载导航地图，导航地图下载
• 

  流媒体后视镜可以当行车记录仪吗 行车记录仪有必要买流媒体吗
• 

  炒苔菜用不用焯水，苔菜用不用焯水再炒
• 

  昆明工业职业技术学院怎么样
• 

  （152）感赏女儿|（152）感赏女儿 2020-12-4
• 

  桃子核发霉外面是好的还能吃吗
• 

  离散傅立叶分析,origin怎么进行傅立叶分析
• 

  次密接触者的一般接触者需要隔离吗
• 

  海带炖土豆的做法 海带炖土豆的做法窍门
• 

  大概的近义词 大概的近义词是什么 标准答案
• 

  合金筷子是塑料还是金属 合金筷子是什么材质
• 

  真我与假我
• 

  钢材包括哪些 钢材怎么分类
• 

  heos,黑色素瘤
• 

  【家事】节如流水

• 三十年后的广场舞大爷
• 一百二十三夜，请嫁给我
• 迷失的世界（二十七）
• 二十年后的家乡
• 研学让生活更美好
• 《十二夜》观后感
• 第四十三篇接纳孩子的感受
• 亲子日记第十二天
• 让眼泪滑落，成为骄傲(三十九)
• 《卓有成效的管理者》第二十二堂课（创造英雄）