插入排序
思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的子序列的合适位置，直到全部插入排序完为止。
关键问题：在前面已经排好序的序列中找到合适的插入位置。
方法：
直接插入排序
二分插入排序
希尔排序
package 排序;
public class 插入排序 {
// 直接插入排序 时间复杂度O(n^2) 空间复杂度O(1)
public static void insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
// 待插入元素
int temp = arr[i];
int j;
for (j = i - 1; j >= 0 && arr[j] > temp; j--) {
// 将大于temp的往后移一位 交换两个元素的位置
arr[j + 1] = arr[j];
}
arr[j + 1] = temp;// for循环结束j--，所有arr[j+1]等于之前的arr[j]
}
}
// 二分插入排序
public static void twoInsertSort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
int temp = arr[i];
int low = 0;
int high = i - 1;// 插入到temp前面的排序数组里面
int mid;
while (low <= high) {
mid = (low + high) / 2;
if(temp > arr[mid])
low = mid + 1;
else
high = mid - 1;
}
//上面定位的low就是要插入的点
//将low后面的元素全部往后移一个位置
for (int j = i - 1; j >= low; j--) {
arr[j+1] = arr[j];
}
if(low != i)
arr[low] = temp;
}
}
// 希尔排序 时间复杂度O(nlog2n) 空间复杂度O(1)
public static void shellSort(int[] arr) {
int d = arr.length/2;
while(d >= 1){
//类似于直接插入排序，只需要把排序增量1改为d
for (int i = d; i < arr.length; i++) {
//待插入元素
int temp = arr[i];
int j;
for (j = i - d; j >= 0 && arr[j] > temp; j = j-d) {
//将大于temp的往后移d位
arr[j+d] = arr[j];
}
arr[j+d] = temp;
}
d /= 2;
}
}
public static void main(String[] args) {
int[] a = { 2, 1, 4, 8, 6 };
// insertSort(a);
// for (int i : a) {
// System.out.print(i);
// }
// twoInsertSort(a);
// for (int i : a) {
// System.out.print(i);
// }
shellSort(a);
for (int i : a) {
System.out.print(i);
}
}
}
选择排序
思想：每趟从待排序的记录序列中选择关键字最小的记录放置到已排序表的最前位置，直到全部排完。
关键问题：在剩余的待排序记录序列中找到最小关键码记录。
方法：
简单选择排序
二元选择排序
堆排序
package 排序;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
public class 选择排序 {
// 简单选择排序 时间复杂度O(n2) 空间复杂度O(1)
public static void selectSort(int[] a) {
int min;
for (int i = 0; i < a.length; i++) {
min = i;
for (int j = i + 1; j < a.length; j++) {// 找到最小值的下标
if (a[j] < a[i])
min = j;
}
swap(a, i, min);
}
}
// 二元选择排序
public static void twoSelectSort(int[] a) {
int min, max;
for (int i = 0; i < a.length / 2; i++) {
min = i;
max = i; // 分别记录最大值和最小值的位置
for (int j = i + 1; j < a.length - i; j++) {
if (a[j] > a[max]) {
max = j;
continue;
}
if (a[j] < a[min])
min = j;
}
swap(a, i, min);// 最小值放到前面
if (max == i)
// 如果当前i就是max，第一次排序后max要调整为min（a[i]新的位置是a[min]）
max = min;
swap(a, a.length - 1 - i, max);// 最大值放到后面
}
}
// 堆排序 时间复杂度：O(nlogn ) 空间复杂度：O（1）
public static void heapSort(int[] a) {
for (int i = 0; i < a.length; i++) {
createMaxHeap(a, a.length - 1 - i);
swap(a, 0, a.length - 1 - i);
}
}
private static void createMaxHeap(int[] a, int lastIndex) {
// 从最后一个节点 的父节点开始
// 从(lastIndex - 1) / 2开始，因为数组是从0开始
for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
// 保存正在判断的节点
int k = i;
// 如果当前节点 的子节点存在
while (2 * k + 1 <= lastIndex) {
// biggerIndex总是记录较大节点的值，先赋值给当前节点的左子节点的索引
int biggerIndex = 2 * k + 1;
// 如果当前节点的右子节点存在
if (biggerIndex + 1 <= lastIndex) {
if (a[biggerIndex + 1] > a[biggerIndex])
// 若右子节点值比左子节点值大，则biggerIndex记录的是右子节点的索引
biggerIndex++;
}
// 如果k节点小于较大子节点的值
if (a[k] < a[biggerIndex]) {
// 交换两者的值
swap(a, k, biggerIndex);
// 交换之后调整使交换的子树同样满足最大堆
// 将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
k = biggerIndex;
} else {
break;
}
}
}
}
private static void swap(int[] a, int i, int min) {
if (i == min)
return;
// int temp = a[i];
// a[i] = a[min];
// a[min] = temp;
a[i] = a[i] + a[min];
a[min] = a[i] - a[min];
a[i] = a[i] - a[min];
}
public static void main(String[] args) {
int[] a = { 2, 1, 4, 8, 6 };
// selectSort(a);
// twoSelectSort(a);
heapSort(a);
for (int i : a) {
System.out.print(i);
}
System.out.println();
Queue<Integer> q = new PriorityQueue<Integer>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;// 大顶堆
// return o1-o2;小顶堆
}
});
q.add(58);
q.add(12);
q.add(98);
System.out.println(q.poll());
}
}
交换排序
方法：
冒泡排序
快速排序
package 排序;
public class 交换排序 {
// 冒泡排序 时间复杂度O(n2) 空间复杂度O(1)
public static void bubbleSort(int[] a) {
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length - i - 1; j++) {
// 每遍历一次把最大值沉下去
if (a[j] > a[j + 1])
swap(a, j, j + 1);
}
}
}
// 改进的冒泡排序
public static void bubbleSort2(int[] a) {
int low = 0;
int high = a.length - 1;// 设置的变量的初始值
int i;
while (low < high) {
for (i = low; i < high; i++) {// 正向冒泡，找到最大值
if (a[i] > a[i + 1])
swap(a, i, i + 1);
}
--high;// 修改high，前进一位
for (i = high; i > low; i--) {// 反向冒泡，找到最小值
if (a[i] < a[i - 1])
swap(a, i, i - 1);
}
++low;// 修改low，后移一位
}
}
private static void swap(int[] a, int i, int min) {
if (i == min)
return;
// int temp = a[i];
// a[i] = a[min];
// a[min] = temp;
a[i] = a[i] + a[min];
a[min] = a[i] - a[min];
a[i] = a[i] - a[min];
}
// 快速排序 时间复杂度：O（nlog2n）空间复杂度：O（nlog2n）
public static void quickSort(int[] a,int low,int high){
int i = low,j = high,temp = a[i];//初始化，temp存储基准元素
while(i < j){
while(i < j && temp <= a[j])
j--;
a[i] = a[j];
while(i < j && temp >= a[i])
i++;
a[j] = a[i];
}
a[i] = temp;//找得基准的所在位置
if(low < i -1)
quickSort(a, low, i-1);//对左侧进行快排
if(high > i + 1)
quickSort(a, i+1, high);//对右侧进行快排
}
public static void quickSort(int[] a) {
quickSort(a, 0, a.length - 1);
}
public static void main(String[] args) {
int[] a = { 2, 1, 4, 8, 6 };
//bubbleSort2(a);
quickSort(a);
for (int i : a) {
System.out.print(i);
}
}
}
归并排序
归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
package 排序;
public class 归并排序 {
// 归并排序 时间复杂度：O（nlog2n） 空间复杂度：O（n）
public static void mergeSort(int[] a) {
mergeSort(a, 0, a.length - 1);
}
private static void mergeSort(int[] a, int i, int j) {
int mid = (i + j) / 2;
if (i < j) {
// 左边
mergeSort(a, i, mid);
// 右边
mergeSort(a, mid + 1, j);
// 左右归并
merge(a, i, mid, j);
}
}
private static void merge(int[] a, int i, int mid, int j) {
int[] temp = new int[j - i + 1];
int l = i;//左指针
int r = mid + 1;//右指针
int k = 0;
//把较小的数先移到新数组中
while(l <= mid && r <= j){
if(a[l] < a[r])
temp[k++] = a[l++];
else
temp[k++] = a[r++];
}
//把左边剩余的数加入数组
while(l <= mid)
temp[k++] = a[l++];
//把左边剩余的数加入数组
while(r <= j)
temp[k++] = a[r++];
//把新数组中的数覆盖a数组
for (int k2 = 0; k2 < temp.length; k2++) {
a[i + k2] = temp[k2];
}
}
public static void main(String[] args) {
int[] a = { 2, 1, 4, 8, 6 };
mergeSort(a);
for (int i : a) {
System.out.print(i);
}
}
}
桶排序/基数排序
将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。
package 排序;
import java.util.ArrayList;
import java.util.List;
public class 基数排序 {
//桶排序
public static void radixSort(int[] a){
//找到最大数，确定要排序几次
int max = 0;
for (int i = 0; i < a.length; i++) {
if(a[i] > max)
max = a[i];
}
//判断位数
int times = 0;
while(max > 0){
max /= 10;
times++;
}
//建立10个队列 存放0-9的尾数
List<ArrayList> queue = new ArrayList<>();
for (int i = 0; i < 10; i++) {
ArrayList queue1 = new ArrayList();
queue.add(queue1);
}
//进行times次分配和收集
for (int i = 0; i < times; i++) {
//分配
for (int j = 0; j < a.length; j++) {
int x = a[j] % (int)Math.pow(10, i + 1) / (int)Math.pow(10, i);
//ArrayList queue2 = new ArrayList();
ArrayList queue2 = queue.get(x);
queue2.add(a[j]);
//queue.set(x, queue2);//set：将原来index位置上的object的替换掉
}
//收集
int count = 0;
for (int j = 0; j < 10; j++) {
while(queue.get(j).size() > 0){
ArrayList<Integer> queue3 = queue.get(j);
a[count] = queue3.get(0);
queue3.remove(0);
count++;
}
}
}
}
public static void main(String[] args) {
int[] a = { 2, 1, 4, 8, 6 };
radixSort(a);
for (int i : a) {
System.out.print(i);
}
}
}
参考：https://blog.youkuaiyun.com/huaxun66/article/details/77847998
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
