冒泡排序
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个，小的数往上冒。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
public static void bubbleSort(int[] numbers)
{
int temp = 0;
int size = numbers.length;
for(int i = 0 ; i < size-1; i ++)
{
//一趟比较之后，最大的元素就到了最右边（最下面）
for(int j = 0 ;j < size-1-i ; j++)
{
//小数往上冒，大数下沉
if(numbers[j] > numbers[j+1])
{
temp = numbers[j];
numbers[j] = numbers[j+1];
numbers[j+1] = temp;
}
}
}
}
快速排序
public static void quickSort(int[] arr, int low, int high) {
int i, j, temp;
if (low > high) {
return;
}
i = low;//左边哨兵的索引
j = high;//右边哨兵的索引
temp = arr[low];//以最左边为基准位
while (i < j) {
//先看右边，依次往左递减
//先从右往左找一个小于 基准位的数
//当右边的哨兵位置所在的数>基准位的数时
//继续从右往左找（同时 j 索引-1）
//找到后会跳出while循环
while (temp <= arr[j] && i < j) {
j--;
}
//再看左边，依次往右递增,步骤和上面类似
while (temp >= arr[i] && i < j) {
i++;
}
//如果满足条件则交换
if (i < j) {
// 左右哨兵 交换数据（互相持有对方的数据）
arr[i] = arr[i]^arr[j];
arr[j] = arr[i]^arr[j];
arr[i] = arr[i]^arr[j];
}
}
//这时 跳出了 “while (i<j) {}” 循环,说明 i=j 左右在同一位置
//最后将基准为与i和j相等位置的数字交换
arr[low] = arr[i];//或 arr[low] = arr[j];
arr[i] = temp;//或 arr[j] = temp;
//递归调用左半数组
quickSort(arr, low, j - 1);
//递归调用右半数组
quickSort(arr, j + 1, high);
}
直接选择排序
- 在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
- 然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环直到只剩两个数做最后一次排序。
public static void selectSort(int[] numbers)
{
for(int i = 0 ; i < numbers.length -1 ; i++)
{
int k = i;
//选择出应该在第i个位置的数
for(int j = numbers.length -1 ; j > i ; j--)
{
if(numbers[j] < numbers[k]) k = j;
}
//交换两个数
numbers[i] = numbers[i]^numbers[k];
numbers[k] = numbers[i]^numbers[k];
numbers[i] = numbers[i]^numbers[k];
}
}
直接插入排序
- 选出最左边两个元素，排序，得到一个排序好的子集
- 选出左边的第三个元素，插入到排序好的子集当中（从右到左遍历，找到合适的插入位置）
- 循环执行第二部，直到最后一个元素。
public static void insertSort(int[] numbers)
{
int temp,j;
for(int i = 0 ; i < numbers.length ; i++)
{
temp = numbers[i];
//假如temp比前面的值小，则将前面的值后移
for(j = i ; j > 0 && temp < numbers[j-1] ; j --)
{
numbers[j] = numbers[j-1];
}
numbers[j] = temp;
}
}
希尔排序（直接插入改良版）
插入排序当数组基本有序时，比较高效。但是对于较大规模且无序的数据，插入排序效率就低了。可以采用希尔排序。
可以看出，他是按下标相隔距离为4分的组，也就是说把下标相差4的分到一组，比如这个例子中a[0]与a[4]是一组、a[1]与a[5]是一组…，这里的差值（距离）被称为增量。
每个分组进行插入排序后，各个分组就变成了有序的了（整体不一定有序）。
然后缩小增量为上个增量的一半:2，继续划分分组，此时，每个分组元素个数多了，但是，数组变的部分有序了，插入排序效率同样比高。
同理对每个分组进行排序（插入排序），使其每个分组各自有序。
最后设置增量为上一个增量的一半：1，则整个数组被分为一组，此时，整个数组已经接近有序了，插入排序效率高。
对以上数组再进行插入排序后，希尔排序就全部完成了。
有一点需要特别补充，对各个组进行插入排序的时候，并不是先对一个组进行排序完，再对另一个组排序。而是每个组并发执行的，每次插入一个元素进行排序。
public static void shellSort(int [] arr){
int N = arr.length;
//进行分组，最开始的时候，增量为数组的一半，即分成N/2组
for(int gap=N/2;gap>0;gap/=2){
/**
* 对每组进行插入排序
* 对各个组进行插入排序的时候，
* 并不是先对一个组进行排序完，再对另一个组排序
* 而是每个组并发，每次插入一个元素进行排序
*/
for(int i = gap; i<N; i++){
//将arr[i]插入到分组的正确位置上
int insert = arr[i];
int idx;
for(idx = i-gap; idx >=0 && insert<arr[idx]; idx-=gap){
arr[idx+gap] = arr[idx];
}
arr[idx+gap] = insert;
}
}
}
归并排序
归并（Merge）排序法是将两个有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
合并方法：
设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为n-i +1、n-m。
1、j=m+1；k=i；i=i; //置两个子表的起始下标及辅助数组的起始下标
2、若i>m 或j>n，转⑷ //其中一个子表已合并完，比较选取结束
3、//选取r[i]和r[j]较小的存入辅助数组rf
如果r[i]<r[j]，rf[k]=r[i]； i++； k++； 转⑵
否则，rf[k]=r[j]； j++； k++； 转⑵
4、//将尚未处理完的子表中元素存入rf
如果i<=m，将r[i…m]存入rf[k…n] //前一子表非空
如果j<=n , 将r[j…n] 存入rf[k…n] //后一子表非空
5、合并结束。
代码实现
public static int[] mergeSort(int[] nums, int low, int high) {
int mid = (low + high) / 2;
if (low < high) {
// 左边
mergeSort(nums, low, mid);
// 右边
mergeSort(nums, mid + 1, high);
// 左右归并
{
int[] temp = new int[high - low + 1];
int i = low;// 左指针
int j = mid + 1;// 右指针
int k = 0;
// 把较小的数先移到新数组中
while (i <= mid && j <= high) {
if (nums[i] < nums[j]) {
temp[k++] = nums[i++];
} else {
temp[k++] = nums[j++];
}
}
// 把左边剩余的数移入数组
while (i <= mid) {
temp[k++] = nums[i++];
}
// 把右边边剩余的数移入数组
while (j <= high) {
temp[k++] = nums[j++];
}
// 把新数组中的数覆盖nums数组
for (int k2 = 0; k2 < temp.length; k2++) {
nums[k2 + low] = temp[k2];
}
}
}
return nums;
}
堆排序（直接选择改良版）
堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。
详细介绍可以参考下面这篇文章
https://www.cnblogs.com/chengxiao/p/6129630.html
堆排序是一种选择排序，概括如下：
- 构建初始堆（大顶堆或小顶堆）
- 交换堆顶元素和末尾元素（选择出了最大或最小元素）
- 剔除末尾元素，回到第一步重建堆的操作，如此循环直到结束。
其中构建初始堆经推导复杂度为O(n)，在交换并重建堆的过程中，需交换n-1次，而重建堆的过程中，根据完全二叉树的性质，[log2(n-1),log2(n-2)…1]逐步递减，近似为nlogn。所以堆排序时间复杂度一般认为就是O(nlogn)级。
代码实现：
public static void hepSort(int []arr){
//1.构建大顶堆
for(int i=arr.length/2-1;i>=0;i--){
//从第一个非叶子结点从下至上，从右至左调整结构
adjustHeap(arr,i,arr.length);
}
//2.调整堆结构+交换堆顶元素与末尾元素
for(int j=arr.length-1;j>0;j--){
//将堆顶元素与末尾元素进行交换
int temp=arr[0];
arr[0] = arr[j];
arr[j] = temp;
//重新对堆进行调整
adjustHeap(arr,0,j);
}
}
/**
* 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
* @param arr
* @param i
* @param length
*/
private static void adjustHeap(int []arr,int i,int length){
int temp = arr[i];//先取出当前元素i
for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
k++;
}
if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
arr[i] = arr[k];
i = k;
}else{
break;
}
}
arr[i] = temp;//将temp值放到最终的位置
}
基数排序
基数排序法是属于稳定性的排序，其时间复杂度为O (nlog®m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。
1.先按照个位数的数值，遍历数组，把它们分配至0到9的桶中。
2.将桶中的值重新串联起来
3.按照十位数的数值，遍历2串联起来的数组，把它们分配到0到9的桶中。
4.将桶中的值重新串联起来
5.如果待排序数组中有百位，千位数值，则重复3，4步操作，直至最高位排序完。
https://www.runoob.com/w3cnote/radix-sort.html
总结
希尔排序是选择排序的改良版，堆排序是快速排序的改良版。
这四种排序都属于不稳定排序。
扫一扫
276
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
