一、冒泡排序（Bubble Sort）
基础版
/**
* 遍历数组，依次比较相邻的元素并交换，每次都将最大元素（根据正序还是逆序决定）放到数组末尾
* @param arr 待排序数组
* @return
*/
public static int[] bubbleSort(int[] arr) {
int temp;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}
优化一
//冒泡排序：优化一
public static int[] bubbleSort1(int[] arr) {
int temp;
//记录数组是否有序
boolean isSorted;
for (int i = 0; i < arr.length - 1; i++) {
isSorted = true;
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
//记录本轮排序是否交换了元素，如果交换则置为false
isSorted = false;
}
}
//没有交换证明已经是有序的了，直接终止循环
if (isSorted) {
break;
}
}
return arr;
}
优化二
//冒泡排序：优化二
public static int[] bubbleSort2(int[] arr) {
int temp;
boolean isSorted;
//第一次循环边界
int sortBorder = arr.length - 1;
//记录每轮排序最后一次进行交换的位置
int lastSwapIndex = 0;
for (int i = 0; i < arr.length - 1; i++) {
isSorted = true;
for (int j = 0; j < sortBorder; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
isSorted = false;
lastSwapIndex = j;
}
}
sortBorder = lastSwapIndex;
if (isSorted) {
break;
}
}
return arr;
}
二、选择排序（Selection Sort）
/**
* 遍历数组，每次遍历都找到最小的元素，记录其下标，内层循环结束后再根据下标将其与数组头部元素交换
* 与冒泡排序不同的是，冒泡排序每次循环可能交换多次，而选择排序最多交换一次
* @param arr 待排序数组
* @return
*/
public static int[] selectionSort(int[] arr) {
int temp, minIndex;
for (int i = 0; i < arr.length - 1; i++) {
minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
return arr;
}
三、插入排序（Insertion Sort）
/**
* 用一个临时变量存储待插入的值，从后往前找，如果找到比这个值大的元素，则将其前面的元素依次后移，
* 结束后再将带插入的值放到该插入的位置，减去了许多不必要的交换操作
* @param arr
* @return
*/
public static int[] insertionSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int insertValue = arr[i];//待插入元素
int preIndex = i - 1;
while (preIndex >= 0 && insertValue < arr[preIndex]) {
arr[preIndex + 1] = arr[preIndex];
preIndex--;
}
arr[preIndex + 1] = insertValue;
}
return arr;
}
四、希尔排序（Shell Sort）
/**
* 希尔排序
* 插入排序的升级版，设定步长为数组长度的一半，每次都除以二，直到步长为1
* @param arr
* @return
*/
public static int[] shellSort(int[] arr) {
int len = arr.length;
for (int k = len / 2; k > 0; k /= 2) {
for (int i = k; i < len; i++) {
int temp = arr[i];
int j = i - k;
while (j >= 0 && temp < arr[j]) {
arr[j + k] = arr[j];
j -= k;
}
arr[j + k] = temp;
}
}
return arr;
}
五、归并排序（Merge Sort）
//归并排序
public static int[] mergeSort(int[] arr) {
return mergeSort(arr, 0, arr.length - 1, new int[arr.length]);
}
/**
* 归并排序通过递归将数组分解为只有两个元素，按照它们的大小放入到一个临时数组中，直到全部合并
*
* @param arr 待排序数组
* @param left 左索引
* @param right 右索引
* @param temp 临时数组，存储每次合并后的元素
* @return
*/
public static int[] mergeSort(int[] arr, int left, int right, int[] temp) {
if (left < right) {
int mid = (left + right) >> 1;
//向左分解
mergeSort(arr, left, mid, temp);
//向右分解
mergeSort(arr, mid + 1, right, temp);
//合并
merge(arr, left, mid, right, temp);
}
return arr;
}
//合并
public static int[] merge(int[] arr, int left, int mid, int right, int[] temp) {
int i = left, j = mid + 1, k = 0;
//按大小放入临时数组中
while (i <= mid && j <= right) {
if (arr[i] < arr[j]) {
temp[k] = arr[i];
k++;
i++;
} else {
temp[k] = arr[j];
k++;
j++;
}
}
//将剩余元素放到temp剩余位置
while (i <= mid) {
temp[k] = arr[i];
k++;
i++;
}
while (j <= right) {
temp[k] = arr[j];
k++;
j++;
}
//将排好序的temp数组元素赋值给原数组
k = 0;
int l = left;
while (l <= right) {
arr[l] = temp[k];
k++;
l++;
}
return arr;
}
六、快速排序（Quick Sort）
//快速排序
public static int[] quickSort(int[] arr) {
return quickSort(arr, 0, arr.length - 1);
}
public static int[] quickSort(int[] arr, int startIndex, int endIndex) {
if (startIndex < endIndex) {
//获取基准对应的下标
int pivotIndex = partition1(arr, startIndex, endIndex);
quickSort(arr, startIndex, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, endIndex);
}
return arr;
}
/**
* 方式一：双边循环交换
* 先从右边找到比基准元素小的值，再从左边找到比基准元素大的值，然后交换两者
* 直到左右指针相遇，再交换基准和相遇位置的值
*
* @param arr 待排序数组
* @param startIndex 起始索引
* @param endIndex 结束索引
* @return 返回基准索引
*/
public static int partition1(int[] arr, int startIndex, int endIndex) {
//取第一个元素作为基准，也可以取一个随机元素与第一个元素交换
int pivot = arr[startIndex];
int left = startIndex, right = endIndex;
int temp;
while (left != right) {
while (left < right && arr[right] > pivot) {
right--;
}
while (left < right && arr[left] <= pivot) {
left++;
}
//交换左右元素
if (left < right) {
temp = arr[right];
arr[right] = arr[left];
arr[left] = temp;
}
}
//交换重合位置元素和基准
arr[startIndex] = arr[left];
arr[left] = pivot;
return left;
}
//方式二：单边循环
public static int partition2(int[] arr, int startIndex, int endIndex) {
int pivot = arr[startIndex];
//定义一个mark，数组向右寻找比pivot小的元素，找到后mark+1，然后互相交换
int mark = startIndex;
for (int i = startIndex + 1; i <= endIndex; i++) {
if (arr[i] < pivot) {
mark++;
int temp = arr[i];
arr[i] = arr[mark];
arr[mark] = temp;
}
}
//交换mark位置的值和pivot
arr[startIndex] = arr[mark];
arr[mark] = pivot;
return mark;
}
七、堆排序（Heap Sort）
public static int[] heapSort(int[] arr) {
//以最后一个非叶子结点构建大顶堆
for (int i = arr.length / 2 - 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
//此时顶部元素是最大的，交换顶部元素和末端元素
for (int i = arr.length - 1; i > 0; i--) {
swap(arr, 0, i);
//末端元素已经是最大的了，无需考虑排序
adjustHeap(arr, 0, i);
}
return arr;
}
/**
* 形成大顶堆
*
* @param arr 数组元素
* @param i 当前结点位置
* @param len 结点个数
*/
public static void adjustHeap(int[] arr, int i, int len) {
//保存当前结点
int temp = arr[i];
//遍历当前结点的左子结点
for (int k = 2 * i + 1; k < len; k = 2 * k + 1) {
//如果右结点存在 且 右结点比左结点大，指向右结点
if (k + 1 < len && arr[k] < arr[k + 1]) {
k++;
}
//判断当前结点和左（右）结点哪个大
if (temp < arr[k]) {
//交换
swap(arr, k, i);
//交换后，下次遍历以该子结点作为根节点的子树就会受到影响，因此需要重新指定下次的根节点
i = k;
} else {
//不用交换，直接终止循环
break;
}
}
}
public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
八、计数排序（Counting Sort）
/**
* 计数排序:
* 将待排序数组的值（或者差值）作为新数组的下标，新数组的值是排序元素在此位置的个数
* 使用max-min+1作为数组长度可以减少空间浪费
*
* @param arr
* @return
*/
public static int[] countingSort(int[] arr){
int max = arr[0];
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if(max < arr[i]){
max = arr[i];
}
if(min > arr[i]){
min = arr[i];
}
}
int[] count = new int[max - min + 1];
//将待排序数组放到count中
for (int value : arr) {
count[value - min]++;
}
//将count放到arr中
int k = 0;
for (int i = 0; i < count.length; i++) {
while(count[i] > 0){
arr[k++] = i;
count[i]--;
}
}
return arr;
}
优化
//计数排序优化，变为稳定排序
public static int[] countingSort1(int[] arr){
int max = arr[0];
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if(max < arr[i]){
max = arr[i];
}
if(min > arr[i]){
min = arr[i];
}
}
int[] count = new int[max - min + 1];
//将待排序数组放到count中
for (int value : arr) {
count[value - min]++;
}
//当前的元素等于前面的元素加上当前
for (int i = 1; i < count.length; i++) {
count[i] += count[i-1];
}
//倒序遍历count
int[] storedArr = new int[arr.length];
for (int i = arr.length - 1; i >= 0; i--) {
storedArr[count[arr[i] - min]-1] = arr[i];
count[arr[i] - min]--;
}
return storedArr;
}
九、桶排序（Bucket Sort）
public class BucketSort {
/**
* 桶排序：
* 将数据分为n个区间，区间的跨度为 (max - min) / (n - 1)
*
* @param arr
* @return
*/
public static int[] bucketSort(int[] arr){
int max = arr[0];
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
if (min > arr[i]) {
min = arr[i];
}
}
int bucketNum = arr.length;//桶个数
int d = max - min;//差值
ArrayList<LinkedList<Integer>> bucketList = new ArrayList<>(bucketNum);//模拟5个桶
//初始化桶
for (int i = 0; i < bucketNum; i++) {
bucketList.add(new LinkedList<>());
}
//将待排序元素放到桶中
for (int i = 0; i < arr.length; i++) {
int num = (arr[i] - min) * d / (bucketNum - 1);//应该存入的桶号
bucketList.get(num).add(arr[i]);
}
//对每个桶的数据进行排序
for (int i = 0; i < bucketNum; i++) {
//JDK 底层采用了归并排序(1.7之前)或归并的优化版本
Collections.sort(bucketList.get(i));
}
//将桶的数据取出
int k = 0;
for (LinkedList<Integer> nums : bucketList) {
for (Integer num : nums) {
arr[k++] = num;
}
}
return arr;
}
}
十、基数排序（Radix Sort）
public class RadixSort {
/**
* 基数排序：
* 根据每个数的个位、十位、百位...的值（0~9）放入桶中（规则和计数排序相同），因此需要10个桶
*
* @param arr
* @return
*/
public static int[] radixSort(int[] arr){
//创建并初始化10个桶
ArrayList<LinkedList<Integer>> bucketList = new ArrayList<>(10);
for (int i = 0; i < 10; i++) {
bucketList.add(new LinkedList<>());
}
//找出数据中最大值
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
//获取最大值的位数
int maxRadix = (max + "").length();
//从个位开始
for (int i = 0; i < maxRadix; i++) {
//将待排序元素放入桶中
for (int j = 0; j < arr.length; j++) {
//获取数字对应位上的值
int radix = arr[j] / (int) Math.pow(10, i) % 10;
//放入对应的桶中
bucketList.get(radix).add(arr[j]);
}
//将桶中元素放回原数组
int k = 0;
for (int j = 0; j < 10; j++) {
for (Integer number : bucketList.get(j)) {
arr[k++] = number;
}
bucketList.get(j).clear();
}
}
return arr;
}
}
最后：测试
public static void main(String[] args) {
int[] arr = {3, 1, 9, 10, 4, 0, 6, 5, 2, 12, 8, 7, 11};
//[0, 3, 4, 5, 6, 7, 8, 10, 16, 22, 29, 33, 38]
System.out.println("冒泡排序："+ Arrays.toString(bubbleSort(arr)));
System.out.println("冒泡排序-优化1："+ Arrays.toString(bubbleSort1(arr)));
System.out.println("冒泡排序-优化2："+ Arrays.toString(bubbleSort2(arr)));
System.out.println("选择排序："+ Arrays.toString(selectionSort(arr)));
System.out.println("插入排序："+ Arrays.toString(insertionSort(arr)));
System.out.println("希尔排序："+ Arrays.toString(shellSort(arr)));
System.out.println("归并排序："+ Arrays.toString(mergeSort(arr)));
System.out.println("快速排序："+ Arrays.toString(quickSort(arr)));
System.out.println("堆排序："+ Arrays.toString(heapSort(arr)));
System.out.println("计数排序："+ Arrays.toString(countingSort(arr)));
System.out.println("计数排序-优化1："+ Arrays.toString(countingSort1(arr)));
System.out.println("桶排序："+ Arrays.toString(bucketSort(arr)));
System.out.println("基数排序："+ Arrays.toString(radixSort(arr)));
}
