代码使用java做代码示例：
1. 冒泡排序
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。 时间复杂度O(n*n)
public class Test {
/**
* 冒泡排序法
* for 循环加 for each 循环
*/
public static int[] bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[i] > array[j]) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
return array;
}
public static void main(String[] args) {
int[] array = new int[] {54, 45, 5, 2, 12};
System.out.println(Arrays.toString(bubbleSort(array)));
}
}
2. 计数排序
把数组元素作为数组的下标，然后用一个临时数组统计该元素出现的次数。数组的数据必须是整数，而且最大最小值相差的值不要过大。 时间复杂度：O(n+k)
/**
* 计数排序
*
* @param arr：要排序的数组
* @return
*/
public static int[] countSort(int[] arr) {
int n = arr.length;
// 先定义两个变量用来存放数组中的最大值和最小值
int min = arr[0];
int max = arr[0];
for (int i = 1; i < n; i++) {
if (max < arr[i]) {
max = arr[i];
}
if (arr[i] < min) {
min = arr[i];
}
}
// 定义一个长度为len的数组，这样做是为了防止数组中的最小值为1000，最大值为1010
// 这样创建一个大小为10的数组就行了，不用创建大小为1010的数组，浪费空间
int len = max - min + 1;
// 哪个数字出现了一次，就把它的数字作为下标存起来，假如1006出现了一次，就把temp[1006-1000]加一
int[] temp = new int[len];
for (int i = 0; i < n; i++) {
temp[arr[i] - min]++;
}
int k = 0;
// 对temp进行遍历，temp[i]的值就是i出现的次数，加入temp[5]=3，说明(5+1000)出现了3次
for (int i = 0; i < len; i++) {
for (int j = temp[i]; j > 0; j--) {
arr[k] = i + min;
k++;
}
}
return arr;
}
public static void main(String[] args) {
int[] arr = {54, 45, 5, 2, 12};
System.out.println(Arrays.toString(countSort(arr)));
}
3. 快速排序
快速排序的原理就是每次设置一个基准点,这个基准点可以是要排序的一趴数之间的任何数,然后将比基准点小的数放在基准点左边,比基准点大的数放在基准点右边 时间复杂度：O(nlogn)
public class Test {
/**
* 快速排序
*
* @param array
*/
public static int[] quickSort(int[] array) {
int len;
if (array == null || (len = array.length) == 0 || len == 1) {
return array;
}
return sort(array, 0, len - 1);
}
/**
* 快排核心算法，递归实现
*
* @param array
* @param left
* @param right
*/
public static int[] sort(int[] array, int left, int right) {
if (left > right) {
return array;
}
// base中存放基准数
int base = array[left];
int i = left, j = right;
while (i != j) {
// 顺序很重要，先从右边开始往左找，直到找到比base值小的数
while (array[j] >= base && i < j) {
j--;
}
// 再从左往右边找，直到找到比base值大的数
while (array[i] <= base && i < j) {
i++;
}
// 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
if (i < j) {
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
// 将基准数放到中间的位置（基准数归位）
array[left] = array[i];
array[i] = base;
// 递归，继续向基准的左右两边执行和上面同样的操作
// i的索引处为上面已确定好的基准值的位置，无需再处理
sort(array, left, i - 1);
return sort(array, i + 1, right);
}
public static void main(String[] args) {
int[] array = new int[] {54, 45, 5, 2, 12};
System.out.println(Arrays.toString(quickSort(array)));
}
}
4. 归并排序
将两个有序数列合并成一个有序数列，我们称之为“归并”，基本思想与过程：先递归的分解数列，再合并数列（分治思想的典型应用） 时间复杂度: O(nlog(n))
public class Test {
/**
*
* @param arr 原数组
* @param start 开始坐标
* @param end 结束坐标
* @return
*/
public static int[] sort(int[] arr, int start, int end) {
int mid = (start + end) / 2;
if (start < end) {
sort(arr, start, mid);
sort(arr, mid + 1, end);
// 左右归并
merge(arr, start, mid, end);
}
return arr;
}
public static void merge(int[] a, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int i = low;
int j = mid + 1;
int k = 0;
// 把较小的数先移到新数组中
while (i <= mid && j <= high) {
if (a[i] < a[j]) {
temp[k++] = a[i++];
} else {
temp[k++] = a[j++];
}
}
// 把左边剩余的数移入数组
while (i <= mid) {
temp[k++] = a[i++];
}
// 把右边边剩余的数移入数组
while (j <= high) {
temp[k++] = a[j++];
}
// 把新数组中的数覆盖nums数组
for (int x = 0; x < temp.length; x++) {
a[x + low] = temp[x];
}
}
public static void main(String[] args) {
int[] array = new int[] {54, 45, 5, 2, 12};
System.out.println(Arrays.toString(sort(array, 0, array.length - 1)));
}
5. 插入排序
它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。 时间复杂度: O(n*n)
public class Test {
/**
* 插入排序
*
* @param array
* @return
*/
public static int[] insertSort(int[] array) {
// 循环的次数，也监控着每一轮开始key的位置
for (int i = 0; i < array.length - 1; i++) {
int key = array[i + 1];
int j;
// 一边比较一边为key的插入腾空位
for (j = i; j >= 0 && key < array[j]; j--) {
array[j + 1] = array[j];
}
array[j + 1] = key;
}
return array;
}
public static void main(String[] args) {
int[] array = new int[] {54, 45, 5, 2, 12};
System.out.println(Arrays.toString(insertSort(array)));
}
7. 简单选择排序
把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。 时间复杂度O(n*n)
public class Test {
/**
* 简单选择排序
* @param arr
* @return
*/
public static int[] 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) {
swap(arr, i, min);
}
}
return arr;
}
/**
* 完成数组两元素间交换
*
* @param arr
* @param a
* @param b
*/
public static void swap(int[] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
public static void main(String[] args) {
int[] array = new int[] {54, 45, 5, 2, 12};
System.out.println(Arrays.toString(selectSort(array)));
}
8. 二分排序
针对数组有序的情况(千万不要先排序，在查找) 时间复杂度O(n^2)
public class Test {
/**
* 二分排序
*
* @param array
* @return
*/
public static int[] binarySort(int[] array) {
for (int i = 1; i < array.length; i++) {
int temp = array[i];
int low = 0, high = i - 1;
int mid = -1;
while (low <= high) {
mid = low + (high - low) / 2;
if (array[mid] > temp) {
high = mid - 1;
} else { // 元素相同时，也插入在后面的位置
low = mid + 1;
}
}
for (int j = i - 1; j >= low; j--) {
array[j + 1] = array[j];
}
array[low] = temp;
}
return array;
}
public static void main(String[] args) {
int[] array = new int[] {54, 45, 5, 2, 12};
System.out.println(Arrays.toString(binarySort(array)));
}
}
9. 希尔排序
希尔排序实际上是直接插入排序的升级版本，在直接插入排序的算法中，如果越到后面突然出现某个比较小的值 这个时候排序的步骤就越长，希尔排序就是为了解决这个问题，先大致的排一下，然后拍的过程中用的是直接插入排序算法 时间复杂度O(n^1.3)
public class Test {
/**
* 希尔排序
*
* @param arr
* @return
*/
public static int[] sort(int[] arr) {
// 首先计算步长
for (int d = arr.length / 2; d > 0; d = d / 2) {
// 开始直接排序算法
// 先来一轮直接排序
for (int i = d; i < arr.length; i++) {
// 然后开始交换
for (int j = i - d; j >= 0; j = j - d) {
if (arr[j] > arr[j + d]) {
int temp = arr[j];
arr[j] = arr[j + d];
arr[j + d] = temp;
}
}
}
}
return arr;
}
public static void main(String[] args) {
int[] array = new int[] {54, 45, 5, 2, 12};
System.out.println(Arrays.toString(sort(array)));
}
}
10. 堆排序
利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 时间复杂度O(nlogn)
public class Test {
/**
* 堆排序
*
* @param arr
* @return
*/
private static int[] heapSort(int[] arr) {
// 创建堆
for (int i = (arr.length - 1) / 2; i >= 0; i--) {
// 从第一个非叶子结点从下至上，从右至左调整结构
adjustHeap(arr, i, arr.length);
}
// 调整堆结构+交换堆顶元素与末尾元素
for (int i = arr.length - 1; i > 0; i--) {
// 将堆顶元素与末尾元素进行交换
int temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
// 重新对堆进行调整
adjustHeap(arr, 0, i);
}
return arr;
}
/**
* 调整堆
*
* @param arr 待排序列
* @param parent 父节点
* @param length 待排序列尾元素索引
*/
private static void adjustHeap(int[] arr, int parent, int length) {
// 将temp作为父节点
int temp = arr[parent];
// 左孩子
int lChild = 2 * parent + 1;
while (lChild < length) {
// 右孩子
int rChild = lChild + 1;
// 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
if (rChild < length && arr[lChild] < arr[rChild]) {
lChild++;
}
// 如果父结点的值已经大于孩子结点的值，则直接结束
if (temp >= arr[lChild]) {
break;
}
// 把孩子结点的值赋给父结点
arr[parent] = arr[lChild];
// 选取孩子结点的左孩子结点,继续向下筛选
parent = lChild;
lChild = 2 * lChild + 1;
}
arr[parent] = temp;
}
public static void main(String[] args) {
int[] array = new int[] {54, 45, 5, 2, 12};
System.out.println(Arrays.toString(heapSort(array)));
}
}
