排序算法java 简书_几大排序算法的Java实现（原创）

几大排序算法的Java实现

更新中...

注：

该类中附有随机生成[min, max)范围不重复整数的方法，如果各位看官对此方法有什么更好的建议，欢迎提出交流。

各个算法的思路都写在该类的注释中了，同时也方便各位进行本地环境验证。

目前已完成的排序算法有：冒泡排序、选择排序、插入排序。

暂时只提供这些排序算法的基本版，对算法的改进暂时不做考虑。

如果想看的更直观些，欢迎访问一个可视化的排序网站

import static org.junit.Assert.*;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import org.junit.Test;

public class SortTest {

/**

* 用来存储给定范围内所有的整数

*/

private static List numList = new ArrayList<>();

/**

* 返回随机生成的[min, max)之间的整数数组

* @param min 最小值

* @param max 最大值(不包含)

* @return

*/

public static Integer[] generateRandomNum(int min, int max) {

return generateRandomNum(min, max, (max - min));

}

/**

* 返回随机生成的[min, max)之间的整数数组，个数为num个

* @param min

* @param max

* @param num 要生成的随机数个数

* @return

*/

public static Integer[] generateRandomNum(int min, int max, int num) {

long start = System.currentTimeMillis();

List result = new ArrayList<>();

for (int i = min; i < max; i++) {

numList.add(i);

}

for (int i = 0; i < num; i++) {

result.add(generateOneNum(min, max));

}

long end = System.currentTimeMillis();

System.out.println("生成的随机数组范围是：[" + min + ", " + max + "), 个数： " + num + ", 耗时： " + (end - start) / 1000.0 + "s.\n待排序数组为： " + result);

return result.toArray(new Integer[]{});

}

// 读取numList中的任意元素

private static int generateOneNum(int min, int max) {

return (int) numList.remove((int) (Math.random() * numList.size()));

}

/**

* 冒泡排序算法, 时间复杂度是O(n^2)

* @throws Exception

*/

@Test

public void testBubbleSort() throws Exception {

// Integer nums[] = { 67, 1, 69, 43, 7, 56, 34, 111, 87, 62, 89, 90, 31, 99, 100 };

Integer[] nums = generateRandomNum(1, 100, 10);

// 第一层for循环控制排序趟数。Reason: 1个数字->0趟排序，2个数字->1趟排序,3个数字->2趟排序

for (int i = 0; i < nums.length - 1; i++) {

// 第二层for循环控制本趟排序的比较过程

for (int j = 0; j < nums.length - 1 - i; j++) {

// 进行两两比较，如果后面的比前面小，则交换位置，则每进行一趟排序，最后一个数字都是该趟排序中最大的数字

if (nums[j] > nums[j + 1]) {

int temp = nums[j];

nums[j] = nums[j + 1];

nums[j + 1] = temp;

}

}

System.out.println("第" + (i + 1) + "趟排序结果为：" + Arrays.toString(nums));

}

}

/**

* 选择排序

* @throws Exception

*/

@Test

public void testSelectionSort() throws Exception {

Integer[] nums = generateRandomNum(1, 100, 10);

for (int i = 0; i < nums.length - 1; i++) {// 仍旧是控制排序的趟数

int minIndex = i;

// 该层for循环就是为了找到最小的数字并和未排序的所有数字中的首位进行交换

for (int j = i + 1; j < nums.length; j++) {

if (nums[j] < nums[minIndex]) {

minIndex = j;

}

}

if (minIndex != i) {

// 交换该趟排序中最小的数和未排序的数中首位数字

int tmp = nums[minIndex];

nums[minIndex] = nums[i];

nums[i] = tmp;

}

System.out.println("第" + (i + 1) + "趟排序结果为： " + Arrays.toString(nums));

}

}

/**

* 插入排序: 到要插入的数，跟已经排好序的数做比对，如果该数小于之前的数，则之前的数向后移动一位，如果出现

* 大于某个数，则在该位置插入数

* @throws Exception

*/

@Test

public void testInsertSort() throws Exception {

Integer[] nums = generateRandomNum(1, 100, 10);

for (int i = 1; i < nums.length; i++) {// 第一层for循环解决趟数

int j = i;

int target = nums[i];// 获取要插入的那个数

// 因为当插入的数比原本已排好序列中的数大时停止比较，所以采用while

while (j > 0 && target < nums[j - 1]) {

nums[j] = nums[j - 1];// j位置放j-1处的值，相当于该值后移一位

j--;

}

// 结束while循环时target > nums[j - 1]

nums[j] = target;

System.out.println("第" + (i + 1) + "趟排序结果为： " + Arrays.toString(nums));

}

}

/**

* 快速排序

* @throws Exception

*/

@Test

public void testQuickSort() throws Exception {

Integer[] nums = generateRandomNum(1, 100, 10);

}

/**

* 关于位运算： 1 ^ 正奇数 = 正奇数 - 1

* @throws Exception

*/

@Test

public void testName() throws Exception {

for (int i = 0; i < 101; i++) {

System.out.println(1 ^ (2*i + 1));

}

}

}

快排实现:思路请参照《算导读书笔记》

void quicksort(int[] n, int left, int right) {

if (left < right) {

int pivotIndex = partition(n, left, right);

quicksort(n, left, pivotIndex - 1);

quicksort(n, pivotIndex + 1, right);

}

}

private int partition(int[] n, int left, int right) {

int pivot = n[right];

int i = left - 1;

for (int j = left; j < right ; j++) {

if (n[j] <= pivot) {

i ++;

swap(n, i, j);

}

}

swap(n,i + 1, right);

return i + 1;

}

private void swap(int[] n, int i, int j) {

// swap方法1

int a = n[i];

int b = n[j];

a = a ^ b;

b = a ^ b;

a = a ^ b;

n[i] = a;

n[j] = b;

// swap方法2

// int tmp = n[i];

// n[i] = n[j];

// n[j] = tmp;

}