汇总

1. 冒泡排序

每轮循环确定最值；

public void bubbleSort(int[] nums)
{
int temp;
boolean isSort = false;
//优化，发现排序好就退出for (int i = 0; i < nums.length-1; i++)
{
for (int j = 0; j < nums.length-1-i; j++)
{
//每次排序后能确定较大值if(nums[j] > nums[j+1]){isSort = true;temp = nums[j];nums[j] = nums[j+1];nums[j+1] = temp;}}        if(!isSort){
return;} else
{isSort = false;}}
}

2. 选择排序

每次选出最值，再交换到边上；

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

3. 插入排序

对循环的每个数找到属于自己的位置插入；

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

4. 快速排序

选一个基本值，小于它的放一边，大于它的放另一边；

public void quickSortDfs(int[] nums, int left, int right)
{
if(left > right)
{
return;}int l = left;int r = right;int baseNum = nums[left];
while(l < r){
//必须右边先走while(nums[r] >= baseNum && l < r){r--;}        while(nums[l] <= baseNum && l < r){l++;}int temp = nums[l];nums[l] = nums[r];nums[r] = temp;}nums[left] = nums[l];nums[l] = baseNum;quickSortDfs(nums, left, r-1);quickSortDfs(nums, l+1, right);
}

5. 归并排序

分治算法；

//归
public void mergeSortDfs(int[] nums, int l, int r)
{
if(l >= r){
return;}
int m = (l+r)/2;mergeSortDfs(nums, l, m);mergeSortDfs(nums, m+1, r);merge(nums, l, m, r);
}//并private void merge(int[] nums, int left, int mid, int right)
{
int[] temp = new int[right-left+1];
int l = left;
int m = mid+1;
int i = 0;
while(l <= mid && m <= right){
if(nums[l] < nums[m]){temp[i++] = nums[l++];} else {temp[i++] = nums[m++];}}    while(l <= mid){temp[i++] = nums[l++];}    while(m <= right){temp[i++] = nums[m++];}System.arraycopy(temp, 0, nums, left, temp.length);
}

6. 希尔排序

引入步长减少数字交换次数提高效率；

6.1 希尔-冒泡排序（慢）

public void shellBubbleSort(int[] nums)
{
for (int step = nums.length/2; step > 0 ; step /= 2)
{
for (int i = step; i < nums.length; i++)
{
for (int j = i-step; j >= 0; j -= step)
{
if(nums[j] > nums[j+step])
{
int temp = nums[j];nums[j] = nums[j+step];nums[j+step] = temp;}}}}
}

6.2 希尔-插入排序（快）

public void shellInsertSort(int[] nums)
{
for (int step = nums.length/2; step > 0; step /= 2)
{
for (int i = step; i < nums.length; i++)
{
int j = i;
int insertNum = nums[i];
while(j-step >= 0 && nums[j-step] > insertNum){nums[j] = nums[j-step];j-=step;}nums[j] = insertNum;}}
}

7. 堆排序

大顶堆实现升序，每次将最大值移到堆的最后一个位置上；在此我向大家推荐一个架构学习交流圈。交流学习伪鑫：1253431195（里面有大量的面试题及答案）里面会分享一些资深架构师录制的视频录像：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源，目前受益良多

public void heapSort2(int[] nums)
{
for(int i = nums.length/2-1; i >= 0; i--)
{sift(nums, i, nums.length);}
for (int i = nums.length-1; i > 0; i--)
{
int temp = nums[0];nums[0] = nums[i];nums[i] = temp;sift(nums, 0, i);}
}
private void sift(int[] nums, int parent, int len)
{
int value = nums[parent];
for (int child = 2*parent +1; child < len; child = child*2 +1)
{
if(child+1 < len && nums[child+1] > nums[child]){child++;}
if(nums[child] > value){nums[parent] = nums[child];parent = child;} else {
break;}}nums[parent] = value;
}

8. 计数排序

按顺序统计每个数出现次数；

public void countSort(int[] nums)
{
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for(int num : nums)
{max = Math.max(max, num);min = Math.min(min, num);}
int[] countMap = new int[max-min+1];
for(int num : nums)
{countMap[num-min]++;}
int i = 0;
int j = 0;
while(i < nums.length && j < countMap.length)
{
if(countMap[j] > 0)
{nums[i] = j+min;i++;countMap[j]--;}
else
{j++;}}
}

9. 桶排序

类似计数排序，不同点在于统计的是某个区间（桶）里的数；

public void bucketSort(int[] nums)
{
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for(int num : nums)
{max = Math.max(max, num);min = Math.min(min, num);}    int bucketCount = (max-min)/nums.length+1;List<List<Integer>> bucketList = new ArrayList<>();
for (int i = 0; i < bucketCount; i++)
{bucketList.add(new ArrayList<>());}
for(int num : nums)
{
int index = (num-min)/nums.length;bucketList.get(index).add(num);}
for(List<Integer> bucket : bucketList){Collections.sort(bucket);}
int j = 0;
for(List<Integer> bucket : bucketList)
{
for(int num : bucket){nums[j] = num;j++;}}
}

10. 基数排序

按个、十、百位依次归类排序；

public  void radixSort(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);}
for (int i = 0; i < nums.length; i++)
{nums[i] -= min;}max -= min;
int maxLen = (max+"").length();
int[][] bucket = new int[nums.length][10];
int[] bucketCount = new int[10];
for (int i = 0, n = 1; i < maxLen; i++, n*=10)
{
for (int num : nums)
{
int digitVal = num / n % 10;bucket[bucketCount[digitVal]][digitVal] = num;bucketCount[digitVal]++;}
int index = 0;
for (int j = 0; j < bucketCount.length; j++)
{
if(bucketCount[j] > 0)
{
for (int k = 0; k < bucketCount[j]; k++)
{nums[index] = bucket[k][j];index++;}}bucketCount[j] = 0;}}    for (int i = 0; i < nums.length; i++)
{nums[i] += min;}
}

11. 使用集合或 API

11.1 优先队列

public void priorityQueueSort(int[] nums)
{PriorityQueue<Integer> queue = new PriorityQueue<>();
for(int num : nums)
{
queue.offer(num);}
for (int i = 0; i < nums.length; i++)
{nums[i] = queue.poll();}
}

11.2 Java API

public void arraysApiSort(int[] nums){Arrays.sort(nums);
}

阿里面试面试题：链接：https://pan.baidu.com/s/1ryi6EMUEjZvlaRGEnipryw
提取码：tn3g

算法 | Java 常见排序算法（纯代码）相关推荐

Java常见排序算法之插入排序
一.概述本节由小千给大家分享Java常见排序算法之插入排序,之前我们说过排序是算法中的一部分.所以我们学习排序也是算法的入门,为了能让大家感受到排序是算法的一部分,我举个例子证明一下:比如麻将游戏, ...
Java常见排序算法
Java常见排序算法转载于:https://www.cnblogs.com/hfultrastrong/p/7829889.html
Java常见排序算法之直接选择排序
在学习算法的过程中,我们难免会接触很多和排序相关的算法.总而言之,对于任何编程人员来说,基本的排序算法是必须要掌握的. 从今天开始,我们将要进行基本的排序算法的讲解.Are you ready?Let ...
Java常见排序算法之堆排序
在学习算法的过程中,我们难免会接触很多和排序相关的算法.总而言之,对于任何编程人员来说,基本的排序算法是必须要掌握的. 从今天开始,我们将要进行基本的排序算法的讲解.Are you ready?Let ...
Java常见排序算法之Shell排序
在学习算法的过程中,我们难免会接触很多和排序相关的算法.总而言之,对于任何编程人员来说,基本的排序算法是必须要掌握的. 从今天开始,我们将要进行基本的排序算法的讲解.Are you ready?Let ...
java常见的排序算法_常见排序算法及Java实现
先上个总图↓: ①.直接插入排序插入排序(Insertion Sort)的算法描述是一种简单直观的排序算法.它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并 ...
java常见排序算法有哪些_Java中常用的6种排序算法详细分解
排序算法很多地方都会用到,近期又重新看了一遍算法,并自己简单地实现了一遍,特此记录下来,为以后复习留点材料. 废话不多说,下面逐一看看经典的排序算法: 1. 选择排序选择排序的基本思想是遍历数组的过 ...
【排序算法】常见排序算法总结
一.排序算法概述排序,即将一组数据按照递增或递减的规则进行排列.根据不同的规则,排序算法的分类也不尽相同,常见分类标准有:内部排序和外部排序.内部排序是数据记录在内存中进行排序,而外部排序是因排序的 ...
python常见的排序算法_常见排序算法之python实现
1. 冒泡排序时间复杂度为O(n^2), 稳定的排序算法思路:一开始比较的区间是[0,n-1],依次比较相邻两数,哪个数大哪个数就放在后面,这样一次遍历数组后,最大的数会在数组的最后一个位置,然后 ...

算法 | Java 常见排序算法（纯代码）

汇总

1. 冒泡排序

1. 冒泡排序

2. 选择排序

3. 插入排序

4. 快速排序

5. 归并排序

6. 希尔排序

6.1 希尔-冒泡排序（慢）

6.2 希尔-插入排序（快）

7. 堆排序

8. 计数排序

9. 桶排序

10. 基数排序

11. 使用集合或 API

11.1 优先队列

11.2 Java API

算法 | Java 常见排序算法（纯代码）相关推荐

最新文章

热门文章