本篇文章仅作为编程语言学习的参考案例, 帮助理解排序算法的实现逻辑, 如有意见或建议请留言.
import java.text.Collator;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Objects;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
@Description: 排序案例
@ProjectName: helloworld
-
@ClassName: OrderTest
*/
public class OrderSortTest {/**
- @description 每次冒泡过程都是从数列的第一个元素开始，然后依次和剩
余的元素进行比较，若小于相邻元素，则交换两者位置， - 同时将较大元素作为下一个比较的基准元素，继续将该元素与其相邻的元素
进行比较，直到数列的最后一个元素 - @param arr
*/
public static void maopaoSort(int[] arr) {
// 第一层for循环,用来控制冒泡的次数
for (int i = 1; i < arr.length; i++) {
// 第二层for循环,用来控制冒泡一层层到最后
for (int j = 0; j < arr.length - 1; j++) {
// 如果前一个数比后一个数大,两者调换 ,意味着泡泡向上走了一层
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
/**
- @description 第一点是加入了一个布尔值,判断第二层循环中的调换有没有
执行,如果没有进行两两调换,说明后面都已经排好序了, - 已经不需要再循环了,直接跳出循环,排序结束.第二点是第二层循环不再
循环 到arr.length - 1,因为外面的i循环递增一次, - 说明数组最后就多了一个排好序的大泡泡.第二层循环也就不需要到最末尾
一位了,可以提前结束循环 - @param arr
*/
public static void maopaoSortPlus(int[] arr) {
if (arr != null && arr.length > 1) {
for (int i = 0; i < arr.length - 1; i++) {
// 初始化一个布尔值
boolean flag = true;
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// 调换
int temp;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
// 改变flag
flag = false;
}
}
if (flag) {
break;
}
}
}
}
/**
- @description 一次插入排序的操作过程：将待插元素，依次与已排序好的
子数列元素从后到前进行比较，如果当前元素值比待插元素值大， - 则将移位到与其相邻的后一个位置，否则直接将待插元素插入当前元素相
邻的后一位置，因为说明已经找到插入点的最终位置 - @param arr
*/
public static void insertSort(int[] arr) {
if (arr.length >= 2) {
for (int i = 1; i < arr.length; i++) {
// 挖出一个要用来插入的值,同时位置上留下一个可以存新的值的坑
int x = arr[i];
int j = i - 1;
// 在前面有一个或连续多个值比x大的时候,一直循环往前面找,
// 将x插入到这串值前面
while (j >= 0 && arr[j] > x) {
// 当arr[j]比x大的时候,将j向后移一位,正好填到坑中
arr[j + 1] = arr[j];
j--;
}
// 将x插入到最前面
arr[j + 1] = x;
}
}
}
/**
- @description 选择待排数列的首部第一个元素为基准元素，设置两指针，
分别指向数列首尾部位置，假设两指针分别设为i和j。每次遍历的过程是这
样的，首先遍历指针j所指向的元素，直到j指向的元素值小于基准元素时，
停止遍历，将其与指针i所指向的元素进行交换，因为当前指针所指位置就是
用于插入较基准元素小的元素， 然后再将指针i加一。接着轮到指针i遍历,直
到i所指向的元素值大于基准元素时，停止遍历，将其与指针j所指向的元素
进行交换，之所以可以交换， 是因为指针j所指向的元素刚刚已经交换到前
半部分呢，故可以直接选择覆盖就行，这样就将大于基准元素的元素放于后
半部分。依此类推，直到指针i与指针相等或者大于时，停止外部循环。最后
直接将基准元素直接放置于指针i所指向的位置即可，完成分区操作。 - @param arr
- @param begin
- @param end
*/
public static void quickSort(int[] arr, int begin, int end) {
// 先定义两个参数接收排序起始值和结束值
int a = begin;
int b = end;
// 先判断a是否大于b
if (a >= b) {
// 没必要排序
return;
}
// 基准数,默认设置为第一个值
int x = arr[a];
// 循环
while (a < b) {
// 从后往前找,找到一个比基准数x小的值,赋给arr[a]
// 如果a和b的逻辑正确--a<b ,并且最后一个值arr[b]>x,就一直往下找,直到找到后面的值大于x
while (a < b && arr[b] >= x) {
b--;
}
// 跳出循环,两种情况,一是a和b的逻辑不对了,a>=b,这时候排序结束.二是在后面找到了比x小的值
if (a < b) {
// 将这时候找到的arr[b]放到最前面arr[a]
arr[a] = arr[b];
// 排序的起始位置后移一位
a++;
}
// 从前往后找,找到一个比基准数x大的值,放在最后面arr[b]
while (a < b && arr[a] <= x) {
a++;
}
if (a < b) {
arr[b] = arr[a];
// 排序的终止位置前移一位
b--;
}
}
// 跳出循环 a < b的逻辑不成立了,a==b重合了,此时将x赋值回去arr[a]
arr[a] = x;
// 调用递归函数,再细分再排序
quickSort(arr, begin, a - 1);
quickSort(arr, a + 1, end);
}
/**
- @description 选择排序也是一种简单直观的排序算法，实现原理比较直观
易懂：首先在未排序数列中找到最小元素， 然后将其与数列的首部元素进
行交换，然后，在剩余未排序元素中继续找出最小元素，将其与已排序数列
的末尾位置元素交换。 以此类推，直至所有元素圴排序完毕 - @param arr
*/
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int min = i; // 遍历的区间最小的值
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
// 找到当前遍历区间最小的值的索引
min = j;
}
}
if (min != i) {
// 发生了调换
int temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
}
}
/**
- @description 归并排序,简单的说把一串数,从中平等分为两份,再把两份再细
分,直到不能细分为止,这就是分而治之的分的步骤. 再从最小的单元,两两合
并,合并的规则是将其按从小到大的顺序放到一个临时数组中,再把这个临时
数组替换原数组相应位置,这就是治 - @param a
- @param s
- @param m
- @param e
*/
private static void merge(int[] a, int s, int m, int e) {
// 初始化一个从起始s到终止e的一个数组
int[] temp = new int[(e - s) + 1];
// 左起始指针
int l = s;
// 右起始指针
int r = m + 1;
int i = 0;
// 将s-e这段数据在逻辑上一分为二,l-m为一个左边的数组,r-e为一个右边的数组,两边都是有序的
// 从两边的第一个指针开始遍历,将其中小的那个值放在temp数组中
while (l <= m && r <= e) {
if (a[l] < a[r]) {
temp[i++] = a[l++];
} else {
temp[i++] = a[r++];
}
}
// 将两个数组剩余的数放到temp中
while (l <= m) {
temp[i++] = a[l++];
}
while (r <= e) {
temp[i++] = a[r++];
}
// 将temp数组覆盖原数组
for (int n = 0; n < temp.length; n++) {
a[s + n] = temp[n];
}
}
/**
- @description 归并排序
- @param a
- @param s
- @param e
*/
public static void mergeSort(int[] a, int s, int e) {
int m = (s + e) / 2;
if (s < e) {
mergeSort(a, s, m);
mergeSort(a, m + 1, e);
// 归并
merge(a, s, m, e);
}
}
/**
- 获取一个打乱的数组
- @param arr
*/
private static int[] getRandomArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] = new Random().nextInt(arr.length);
}
return arr;
}
/**
@description 测试
-
@param args
*/
public static void main(String[] args) {
int[] arr = new int[200000];
int[] a = getRandomArr(arr);
int[] b = a.clone();
int[] c = b.clone();
int[] d = b.clone();
int[] e = b.clone();
int[] f = b.clone();long s = System.currentTimeMillis();
quickSort(a, 0, a.length - 1);
System.out.println("快速排序耗时: " + (System.currentTimeMillis() - s) + " 毫秒");long s = System.currentTimeMillis();mergeSort(d, 0, d.length - 1);
System.out.println("归并排序耗时: " + (System.currentTimeMillis() - s) + " 毫秒");s = System.currentTimeMillis();selectSort(b);
System.out.println("选择排序耗时: " + (System.currentTimeMillis() - s) + " 毫秒");s = System.currentTimeMillis();
insertSort(c);
System.out.println("插入排序耗时: " + (System.currentTimeMillis() - s) + " 毫秒");s = System.currentTimeMillis();
maopaoSortPlus(e);
System.out.println("冒泡增强耗时: " + (System.currentTimeMillis() - s) + " 毫秒");s = System.currentTimeMillis();
maopaoSort(f);
System.out.println("冒泡排序耗时: " + (System.currentTimeMillis() - s) + " 毫秒");// 输出结果, 查看是否正确
/for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + ",");
}
System.out.println("");
for (int i = 0; i < a.length; i++) {
System.out.print(b[i] + ",");
}
System.out.println("");
for (int i = 0; i < a.length; i++) {
System.out.print(c[i] + ",");
}
System.out.println("");
for (int i = 0; i < a.length; i++) {
System.out.print(d[i] + ",");
}
System.out.println("");
for (int i = 0; i < a.length; i++) {
System.out.print(e[i] + ",");
}
System.out.println("");
for (int i = 0; i < a.length; i++) {
System.out.print(f[i] + ",");
}/
}
}
- @description 每次冒泡过程都是从数列的第一个元素开始，然后依次和剩
