排序算法
选择排序
直接选择排序
图解过程:
示例代码:
public class SelectSort {
public static void main(String[] args) {
int[] data = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
selectSort(data);
System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
}
public static void selectSort(int[] data) {
System.out.println("开始排序");
int arrayLength = data.length;
for (int i = 0; i < arrayLength - 1; i++) {
// i节点依次与后面的节点进行比较
for (int j = i + 1; j < arrayLength; j++) {
// 后面的任意节点小于i节点则交换位置
if (data[i] - data[j] > 0) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
System.out.println(java.util.Arrays.toString(data));
}
}
// 改进
public static void selectSort1(int[] data) {
System.out.println("开始排序");
int arrayLength = data.length;
for (int i = 0; i < arrayLength - 1; i++) {
// 记录i及后面中最小节点的索引
int minIndex = i;
// 依次找到i及后面中最小节点的索引
for (int j = i + 1; j < arrayLength; j++) {
if (data[minIndex] - data[j] > 0) {
minIndex = j;
}
}
// 最小节点的索引不是i时,交换节点i和最小节点
if(minIndex != i){
int temp = data[i];
data[i] = data[minIndex];
data[minIndex] = temp;
}
System.out.println(java.util.Arrays.toString(data));
}
}
}
堆排序
图解过程:
示例代码:
public class HeapSort {
public static void main(String[] args) {
int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
heapSort(data);
System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
}
public static void heapSort(int[] data) {
System.out.println("开始排序");
int arrayLength = data.length;
// 循环建堆
for (int i = 0; i < arrayLength - 1; i++) {
// 建堆
buildMaxdHeap(data, arrayLength - 1 - i);
// 交换堆顶和最后一个元素
swap(data, 0, arrayLength - 1 - i);
System.out.println(java.util.Arrays.toString(data));
}
}
// 对data数组从0到lastIndex建大顶堆
private static void buildMaxdHeap(int[] data, int lastIndex) {
// 从lastIndex处节点(最后一个节点)的父节点开始
for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
// k保存当前正在判断的节点
int k = i;
// 如果当前k节点的子节点存在
while (k * 2 + 1 <= lastIndex) {
// k节点的左子节点的索引
int biggerIndex = 2 * k + 1;
// 如果biggerIndex小于lastIndex,即biggerIndex +1
// 代表k节点的右子节点存在
if (biggerIndex < lastIndex) {
// 如果右子节点的值较大
if (data[biggerIndex] - data[biggerIndex + 1] < 0) {
// biggerIndex总是记录较大子节点的索引
biggerIndex++;
}
}
// 如果k节点的值小于其较大子节点的值
if (data[k] - data[biggerIndex] < 0) {
// 交换它们
swap(data, k, biggerIndex);
// 将biggerIndex赋给k,开始while循环的下一次循环
// 重新保证k节点的值大于其左、右节点的值
k = biggerIndex;
} else {
break;
}
}
}
}
// 交换data数组中i、j两个索引处的元素
private static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
交换排序
冒泡排序
图解过程:
示例代码:
public class BubbleSort {
public static void main(String[] args) {
int[] data = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
bubbleSort(data);
System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
}
public static void bubbleSort(int[] data) {
System.out.println("开始排序");
int arrayLength = data.length;
for (int i = 0; i < arrayLength - 1; i++) {
// 依次比较前面arrayLength-1-i个相邻元素
for (int j = 0; j < arrayLength - 1 - i; j++) {
// 将相邻元素中较大的元素前移(最后i元素最大)
if (data[j] > data[j + 1]) {
int temp = data[j + 1];
data[j + 1] = data[j];
data[j] = temp;
}
}
System.out.println(java.util.Arrays.toString(data));
}
}
// 优化
public static void bubbleSort1(int[] data) {
System.out.println("开始排序");
int arrayLength = data.length;
for (int i = 0; i < arrayLength - 1; i++) {
boolean flag = false;
for (int j = 0; j < arrayLength - 1 - i; j++) {
if (data[j] > data[j + 1]) {
int temp = data[j + 1];
data[j + 1] = data[j];
data[j] = temp;
flag = true; // 若没有执行,则表示前arrayLength-1-i个元素已经有序
}
}
System.out.println(java.util.Arrays.toString(data));
// 已经排序完成,结束排序
if (!flag)
break;
}
}
}
快速排序
图解过程:
示例代码:
public class QuickSort {
public static void main(String[] args) {
int[] data = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
quickSort(data);
System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
}
public static void quickSort(int[] data){
subSort(data,0,data.length - 1);
}
private static void subSort(int[] data, int start, int end) {
if (start < end) {
int base = data[start]; // 保存第一个元素
int low = start;
int high = end + 1;
while (true) {
// 找到左边第一个大于第一个元素的元素索引low
while (low < end && data[++low] - base <= 0)
;
// 找到右边第一个小于第一个元素的元素索引high
while (high > start && data[--high] - base >= 0)
;
if (low < high) {
swap(data, low, high); // 交换两个索引对应的元素
} else {
break;
}
}
swap(data, start, high); // 交换该元素和最后一个比该元素小的元素
subSort(data, start, high - 1); // 递归调用小于该元素部分
subSort(data, high + 1, end); // 递归调用大于该元素部分
}
}
private static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
插入排序
直接插入排序
图解过程:
示例代码:
public class InsertSort {
public static void main(String[] args) {
int[] data = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
insertSort(data);
System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
}
public static void insertSort(int[] data) {
System.out.println("开始排序");
int arrayLength = data.length;
for (int i = 1; i < arrayLength; i++) {
int temp = data[i]; // 保存当前操作的元素
// 该元素小于前面的元素
if (data[i] - data[i - 1] < 0) {
int j = i - 1;
// 将该元素前面小于该元素的元素前移
for (; j >= 0 && data[j] - temp > 0; j--) {
data[j + 1] = data[j];
}
data[j + 1] = temp; // 将该元素插入到最后一个大于该元素的元素前面
}
System.out.println(java.util.Arrays.toString(data));
}
}
}
折半插入排序
图解过程:
示例代码:
public class BinaryInsertSort {
public static void main(String[] args) {
int[] data = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
binaryInsertSort(data);
System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
}
public static void binaryInsertSort(int[] data) {
System.out.println("开始排序");
int arrayLength = data.length;
for (int i = 1; i < arrayLength; i++) {
int temp = data[i]; // 保存当前操作的元素
int low = 0; // 操作区间的第一个元素
// 操作区间依次变大,为当前元素前面的所有元素,且前面的元素已经排好序
int high = i - 1; // 操作区间的最后一个元素
while (low <= high) {
int mid = (low + high) / 2; // 操作区间的中间元素
// 该元素大于中间元素则该元素位于右边区间,否则位于左边区间
if (temp > data[mid]) {
low = mid + 1;
} else {
high = mid - 1;
}
}
// 将该元素前面小于该元素的元素前移
for (int j = i; j > low; j--) {
data[j] = data[j - 1];
}
data[low] = temp; // 将该元素插入到最后一个大于该元素的元素前面
System.out.println(java.util.Arrays.toString(data));
}
}
}
希尔排序
图解过程:
示例代码:
public class ShellSort {
public static void main(String[] args) {
// int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
int[] data = { 84, 83, 88, 87, 61, 50, 70, 60, 80, 99 };
System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
shellSort(data);
System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
}
public static void shellSort(int[] data) {
System.out.println("开始排序");
int arrayLength = data.length;
int h = 1;
// 确定步长
while (h <= arrayLength / 3) {
h = h * 3 + 1;
}
while (h > 0) {
System.out.println("===h的值:" + h + "===");
// 步长为h之间的元素进行插入排序
for (int i = h; i < arrayLength; i++) {
int temp = data[i];
if (data[i] - data[i - h] < 0) {
int j = i - h;
for (; j >= 0 && data[j] - temp > 0; j -= h) {
data[j + h] = data[j];
}
data[j + h] = temp;
}
System.out.println(java.util.Arrays.toString(data));
}
h = (h - 1) / 3;
}
}
}
归并排序
图解过程:
示例代码:
public class MergeSort {
public static void main(String[] args) {
int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
mergeSort(data);
System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
}
public static void mergeSort(int[] data) {
// 归并排序
sort(data, 0, data.length - 1);
}
// 将索引从left到right范围的数组元素进行归并排序
private static void sort(int[] data, int left, int right) {
if(left < right){
// 找出中间索引
int center = (left + right) / 2;
sort(data,left,center); // 对左侧元素进行归并排序
sort(data,center+1,right); //右侧元素进行归并排序
// 合并
merge(data,left,center,right);
}
}
// 将两个数组进行归并,归并前两个数组已经有序,归并后依然有序
private static void merge(int[] data, int left, int center, int right) {
int[] tempArr = new int[data.length];
int mid = center + 1; // 右侧数组第一个元素
int third = left; // tempArr数组的第一个元素
int temp = left; //
// 两个数组分别向右遍历,将小的元素依次放入tempArr数组中(其中一个数组遍历结束则循环结束)
while (left <= center && mid <= right) {
if (data[left] - data[mid] <= 0) {
tempArr[third++] = data[left++];
} else {
tempArr[third++] = data[mid++];
}
}
// 将未遍历完的数组的剩余元素放入tempArr数组的尾部
while (mid <= right) {
tempArr[third++] = data[mid++];
}
while (left <= center) {
tempArr[third++] = data[left++];
}
// 将tempArr数组中left到right间的元素依次复制到data数组中
while (temp <= right) {
data[temp] = tempArr[temp++];
}
}
}
桶式排序
图解过程:
示例代码:
public class BucketSort {
public static void main(String[] args) {
int[] data = { 9, 5, -1, 8, 5, 7, 3, -3, 1, 3 };
System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
bucketSort(data, -3, 9 + 1);
System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
}
public static void bucketSort(int[] data, int min, int max) {
System.out.println("开始排序");
int arrayLength = data.length;
int[] temp = new int[arrayLength];
int[] buckets = new int[max - min]; // 存储max-min个桶
// 每个桶的元素个数
for (int i = 0; i < arrayLength; i++) {
buckets[data[i] - min]++;
}
System.out.println(Arrays.toString(buckets));
// 每个桶的元素位置
for (int i = 1; i < max - min; i++) {
buckets[i] = buckets[i] + buckets[i - 1];
}
System.out.println(Arrays.toString(buckets));
// 当data数组的元素复制到temp数组中进行缓存
System.arraycopy(data, 0, temp, 0, arrayLength);
// 依次将temp数组中的元素根据桶中元素位置存储到相应索引的data数组中
for (int k = arrayLength - 1; k >= 0; k--) {
data[--buckets[temp[k] - min]] = temp[k];
}
}
}
基数排序
图解过程:
示例代码:
public class RadixSort {
public static void main(String[] args) {
int[] data = { 1100, 192, 221, 12, 13 };
System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
radixSort(data, 10, 4);
System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
}
public static void radixSort(int[] data, int radix, int d) {
System.out.println("开始排序:");
int arrayLength = data.length;
int[] temp = new int[arrayLength];
int[] buckets = new int[radix];
for (int i = 0, rate = 1; i < d; i++) {
// 重置count数组,开始统计第二个关键字
Arrays.fill(buckets, 0);
// 当data数组的元素复制到temp数组中进行缓存
System.arraycopy(data, 0, temp, 0, arrayLength);
// 每个桶的元素个数
for (int j = 0; j < arrayLength; j++) {
int subKey = (temp[j] / rate) % radix; // 桶中元素为第j+1位上的数字
buckets[subKey]++;
}
// 每个桶的元素位置
for (int j = 1; j < radix; j++) {
buckets[j] = buckets[j] + buckets[j - 1];
}
// 依次将temp数组中的元素根据桶中元素位置存储到相应索引的data数组中
for (int m = arrayLength - 1; m >= 0; m--) {
int subKey = (temp[m] / rate) % radix;
data[--buckets[subKey]] = temp[m];
}
System.out.println("对" + rate + "位上子关键字排序:"
+ java.util.Arrays.toString(data));
rate *= radix; // 统计的下一位关键字
}
}
}