排序算法及其效率比较

排序算法及其效率比较

package org.iword;

import java.util.Arrays;

public class Main {
public static void main(String[] args)
{
int[] bubble = getIntArray(20, 50);
int[] select = Arrays.copyOf(bubble, bubble.length);
int[] quick = Arrays.copyOf(bubble, bubble.length);

System.out.println("--------------------冒泡排序法--------------------");
System.out.println("排序前：");
forEach(bubble);
System.out.println("\n排序后：");
long bubbleStart = System.nanoTime();
Sort.bubbleSort(bubble);
long bubbleEnd = System.nanoTime();
forEach(bubble);
System.out.println("\n排序耗时：" + (bubbleEnd - bubbleStart));
System.out.println(check(bubble));

System.out.println("\n--------------------选择排序法--------------------");
System.out.println("排序前：");
forEach(select);
System.out.println("\n排序后：");
long selectStart = System.nanoTime();
Sort.selectSort(select);
long selectEnd = System.nanoTime();
forEach(select);
System.out.println("\n排序耗时：" + (selectEnd - selectStart));
System.out.println(check(select));

System.out.println("\n--------------------快速排序法--------------------");
System.out.println("排序前：");
forEach(quick);
System.out.println("\n排序后：");
long quickStart = System.nanoTime();
Sort.quickSort(quick);
long quickEnd = System.nanoTime();
forEach(quick);
System.out.println("\n排序耗时：" + (quickEnd - quickStart));
System.out.println(check(quick));
}

// 输出数组
private static void forEach(int[] numbers)
{
for (int number : numbers) {
System.out.printf("%d ", number);
}
}

// 获取长度为 length 且元素值小于 max 的整型数组
private static int[] getIntArray(int length, int max)
{
int[] numbers = new int[length];
for (int i = 0; i < length; i++) {
numbers[i] = (int) (max * Math.random());
}

return numbers;
}

// 检测 numbers 中是否有未排序的元素
private static String check(int[] numbers)
{
if (numbers.length < 2) {
return "未检测";
}

for (int i = 0; i < numbers.length - 1; i++) {
if (numbers[i] > numbers[i + 1]) {
return String.format("无序元素索引：%d, %d", i, (i + 1));
}
}

return "已排好序";
}
}

// 以下为三种排序法实现代码
package org.iword;

public class Sort {
// 选择排序法
public static void selectSort(int[] numbers)
{
int min;
for (int i = 0; i < numbers.length - 1; i++) {
min = i;
for (int j = i + 1; j < numbers.length; j++) {
if (numbers[j] < numbers[min]) {
min = j;
}
}
swap(numbers, i, min);
}
}

// 快速排序法
public static void quickSort(int[] numbers)
{
quickSort(numbers, 0, numbers.length - 1);
}

// 快速排序法
private static void quickSort(int[] numbers, int left, int right)
{
if (left < right) {
int i = left;
int j = right;
int mark = numbers[left];
while (i < j) {
// 从右向左查找
while (numbers[j] >= mark && j > i) {
j--;
}
if (j != i) {
numbers[i] = numbers[j];
i++;
}
// 从左向右查找
while (numbers[i] < mark && i < j) {
i++;
}
if (i != j) {
numbers[j] = numbers[i];
j--;
}
}
numbers[i] = mark;
quickSort(numbers, left, i - 1);
quickSort(numbers, i + 1, right);
}
}

// 冒泡排序法
public static void bubbleSort(int[] numbers)
{
boolean isLoop = true;
for (int i = numbers.length - 1; isLoop && i > 0; i--) {
isLoop = false; // 假定数组已排好序，此时不需要继续循环
for (int j = 0; j < i; j++) {
// 检测无序元素
if (numbers[j] > numbers[j + 1]) {
swap(numbers, j, j + 1); // 交换值
isLoop = true; // 继续循环
}
}
}
}

// 交换数组 arr 下标为 i 和 j 两个元素的值
private static void swap(int[] arr, int i, int j)
{
if (arr[i] != arr[j]) {
arr[i] += arr[j];
arr[j] = arr[i] - arr[j];
arr[i] -= arr[j];
}
}
}