1、冒泡排序

  • 比较相邻的元素。如果第一个比第二个大,就交换它们两个;
  • 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数;
  • 针对所有的元素重复以上的步骤,除了最后一个;
  • 重复步骤1~3,直到排序完成。
public class BubbleSort {
public static void main(String[] args) {
int[] arr = new int[]{5, 7, 2, 9, 4, 1, 0, 5, 7};
System.out.println(Arrays.toString(arr));
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}

//冒泡排序
/**
* 5,7,2,9,4,1,0,5,7 共需要比较length-1轮
* 5,7,2,9,4,1,0,5,7
* 5,2,7,9,4,1,0,5,7
* 5,2,7,4,1,0,5,7,9
* 2,5
*/
public static void bubbleSort(int[] arr) {
//控制共比较多少轮
for (int i = 0; i < arr.length - 1; i++) {
//控制比较的次数
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}

2、插入排序

  • 从第一个元素开始,该元素可以认为已经被排序;
  • 取出下一个元素,在已经排序的元素序列中从后向前扫描;
  • 如果该元素(已排序)大于新元素,将该元素移到下一位置;
  • 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;
  • 将新元素插入到该位置后;
  • 重复步骤2~5。
public class InsertSort {
public static void main(String[] args) {
int[] arr = new int[]{5, 3, 2, 8, 5, 9, 1, 0};
insertSort(arr);
System.out.println(Arrays.toString(arr));
}

//插入排序
public static void insertSort(int[] arr) {
//遍历所有的数字
for (int i = 1; i < arr.length; i++) {
//如果当前数字比前一个数字小
if (arr[i] < arr[i - 1]) {
//把当前遍历数字存起来
int temp = arr[i];
int j;
//遍历当前数字前面所有的数字
for (j = i - 1; j >= 0 && temp < arr[j]; j--) {
//把前一个数字赋给后一个数字
arr[j + 1] = arr[j];
}
//把临时变量(外层for循环的当前元素)赋给不满足条件的后一个元素
arr[j + 1] = temp;
}
}
}
}

3、希尔排序

import java.util.Arrays;

public class ShellSort {

public static void main(String[] args) {
int[] arr = new int[]{3, 5, 2, 7, 8, 1, 2, 0, 4, 7, 4, 3, 8};
System.out.println(Arrays.toString(arr));
shellSort(arr);
System.out.println(Arrays.toString(arr));
}

public static void shellSort(int[] arr) {
// 遍历所有的步长
for (int d = arr.length / 2; d > 0; d /= 2) {
// 遍历所有有元素
for (int i = d; i < arr.length; i++) {
// 遍历本组中所有的元素
for (int j = i - d; j >= 0; j -= d) {
// 如果当前元素大于加上步长后的那个元素
if (arr[j] > arr[j + d]) {
int temp = arr[j];
arr[j] = arr[j + d];
arr[j + d] = temp;
}
}
}

}
}

}

4、快速排序

  • 从数列中挑出一个元素,称为 “基准”(pivot);
  • 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;
  • 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
public class QuickSort {
public static void main(String[] args) {
int[] arr = new int[]{3, 4, 6, 7, 2, 7, 2, 8, 0, 9, 1};
quickSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}

public static void quickSort(int[] arr, int start, int end) {
if (start < end) {
//把数组中的第0个数字做为标准数
int stard = arr[start];
//记录需要排序的下标
int low = start;
int high = end;
//循环找比标准数大的数和比标准数小的数
while (low < high) {
//右边的数字比标准数大
while (low < high && stard <= arr[high]) {
high--;
}
//使用右边的数字替换左边的数
arr[low] = arr[high];
//如果左边的数字比标准数小
while (low < high && arr[low] <= stard) {
low++;
}
arr[high] = arr[low];
}
//把标准数赋给低所在的位置的元素
arr[low] = stard;
//处理所有的小的数字
quickSort(arr, start, low);
//处理所有的大的数字
quickSort(arr, low + 1, end);
}
}
}

5、归并排序

归并”的含义是将两个或两个以上的有序序列组合成一个新的有序表。假设初始序列含有n个记录,则可以看成是n个有序的子序列,每个子序列的长度为1,然后两两归并,得到(表示不小于x的最小整数)个长度为2(或者是1)的有序子序列,再两两归并。如此重复,直到得到一个长度为n的有序序列为止。这种排序方法称为2-路归并排序。

排序算法总结——Java实现_排序算法

import java.util.Arrays;

public class MergeSort {

public static void main(String[] args) {
int[] arr = new int[]{1, 3, 5, 2, 4, 6, 8, 10};
System.out.println(Arrays.toString(arr));
mergeSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}

//归并排序
public static void mergeSort(int[] arr, int low, int high) {
int middle = (high + low) / 2;
if (low < high) {
//处理左边
mergeSort(arr, low, middle);
//处理右边
mergeSort(arr, middle + 1, high);
//归并
merge(arr, low, middle, high);
}
}

public static void merge(int[] arr, int low, int middle, int high) {
//用于存储归并后的临时数组
int[] temp = new int[high - low + 1];
//记录第一个数组中需要遍历的下标
int i = low;
//记录第二个数组中需要遍历的下标
int j = middle + 1;
//用于记录在临时数组中存放的下标
int index = 0;
//遍历两个数组取出小的数字,放入临时数组中
while (i <= middle && j <= high) {
//第一个数组的数据更小
if (arr[i] <= arr[j]) {
//把小的数据放入临时数组中
temp[index] = arr[i];
//让下标向后移一位;
i++;
} else {
temp[index] = arr[j];
j++;
}
index++;
}
//处理多余的数据
while (j <= high) {
temp[index] = arr[j];
j++;
index++;
}
while (i <= middle) {
temp[index] = arr[i];
i++;
index++;
}
//把临时数组中的数据重新存入原数组
for (int k = 0; k < temp.length; k++) {
arr[k + low] = temp[k];
}
}

}

6、选择排序

import java.util.Arrays;

public class SelectSort {

public static void main(String[] args) {
int[] arr = new int[]{3, 4, 5, 7, 1, 2, 0, 3, 6, 8};
selectSort(arr);
System.out.println(Arrays.toString(arr));
}

//选择排序
public static void selectSort(int[] arr) {
//遍历所有的数
for (int i = 0; i < arr.length; i++) {
int minIndex = i;
//把当前遍历的数和后面所有的数依次进行比较,并记录下最小的数的下标
for (int j = i + 1; j < arr.length; j++) {
//如果后面比较的数比记录的最小的数小。
if (arr[minIndex] > arr[j]) {
//记录下最小的那个数的下标
minIndex = j;
}
}
//如果最小的数和当前遍历数的下标不一致,说明下标为minIndex的数比当前遍历的数更小。
if (i != minIndex) {
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}

}

7、基数排序

import java.util.Arrays;

public class RadixSort {

public static void main(String[] args) {
int[] arr = new int[]{23, 6, 189, 45, 9, 287, 56, 1, 798, 34, 65, 652, 5};
radixSort(arr);
System.out.println(Arrays.toString(arr));
}

public static void radixSort(int[] arr) {
//存最数组中最大的数字
int max = Integer.MIN_VALUE;
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
//计算最大数字是几位数
int maxLength = (max + "").length();
//用于临时存储数据的数组
int[][] temp = new int[10][arr.length];
//用于记录在temp中相应的数组中存放的数字的数量
int[] counts = new int[10];
//根据最大长度的数决定比较的次数
for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
//把每一个数字分别计算余数
for (int j = 0; j < arr.length; j++) {
//计算余数
int ys = arr[j] / n % 10;
//把当前遍历的数据放入指定的数组中
temp[ys][counts[ys]] = arr[j];
//记录数量
counts[ys]++;
}
//记录取的元素需要放的位置
int index = 0;
//把数字取出来
for (int k = 0; k < counts.length; k++) {
//记录数量的数组中当前余数记录的数量不为0
if (counts[k] != 0) {
//循环取出元素
for (int l = 0; l < counts[k]; l++) {
//取出元素
arr[index] = temp[k][l];
//记录下一个位置
index++;
}
//把数量置为0
counts[k] = 0;
}
}
}
}

}

8、堆排序

import java.util.Arrays;

public class HeapSort {

public static void heapSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int i = 0; i < arr.length; i++) {
heapInsert(arr, i);
}
int size = arr.length;
swap(arr, 0, --size);
while (size > 0) {
heapify(arr, 0, size);
swap(arr, 0, --size);
}
}

public static void heapInsert(int[] arr, int index) {
while (arr[index] > arr[(index - 1) / 2]) {
swap(arr, index, (index - 1) / 2);
index = (index - 1) / 2;
}
}

public static void heapify(int[] arr, int index, int size) {
int left = index * 2 + 1;
while (left < size) {
int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
largest = arr[largest] > arr[index] ? largest : index;
if (largest == index) {
break;
}
swap(arr, largest, index);
index = largest;
left = index * 2 + 1;
}
}

public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}