1.直接插入排序
在插入第i个记录的时，R1,R2...已经排好序，这时将关键字R依次与R1...比较，从而找到应该插入的位置，插入位置以及其后的记录依次往后移动。
时间复杂度O(n^2) 空间复杂度O(1)
2.冒泡排序
首先将第一个记录的关键字和第二个记录的关键字进行比较，若为逆序，则交换这两个记录的值，然后比较第二个和第三个记录的关键字，以此类推，知道第n-1个记录和第n个记录比较过为止。上述为第一趟冒泡排序，其结果是关键字最大的记录被交换到第n个记录的位置，然后进行第二趟冒泡排序，对前n-1个记录进行同样的操作，其结果关键字次大的记录被交换到第n-1个记录的位置，最多进行n-1趟，所有的记录有序排列。
时间复杂度O(n^2) 空间复杂度O(1)
package algorithm;
/**
* @time 2019年5月19日下午12:20:59
* @author lll
* @describe 排序
*/
public class BubbleSort {
/**
* @time 2019年5月19日下午1:05:07
* @author lll
* @describe 冒泡排序
*/
public static int[] bubble(int[] intArr) {
for (int i = 0; i < intArr.length; i++) {
// 找出本次中最小的值
for (int j = i; j < intArr.length; j++) {
if (intArr[j] < intArr[i]) {
// 比较交换值
int k = intArr[i];
intArr[i] = intArr[j];
intArr[j] = k;
}
}
}
return intArr;
}
public static void main(String[] args) {
int[] x = {3, 8, 9, 7, 2, 5, 5};
// 调用冒泡排序测试
int[] y = bubble(x);
System.out.print("冒泡排序结果：");
for (int z : y) {
System.out.print(z);
}
}
}
3.简单选择排序
通过n-i在关键字之间比较，从n-i-1个记录中选出关键字最小的记录，并和第i个记录进行交换，当i等于n时所有的记录有序排列
时间复杂度O(n^2) 空间复杂度O(1)
package algorithm;
/**
* @time 2019年5月19日下午12:20:59
* @author lll
* @describe 排序
*/
public class SimpleSelectSort {
/**
* @time 2019年5月19日下午1:11:59
* @author lll
* @describe 简单选择排序 简单选择排序的不稳定性：对于相同值的数排序后不会改变其key对应的位置的算法为稳定的，反之为不稳定的，简单选择排序是会交换位置的，所以是不稳定的算法
*/
public static int[] simpleSelect(int[] intArr) {
for (int i = 0; i < intArr.length; i++) {
int p = i;
/*
* 寻找i前面的最小值,定位给p
*/
for (int j = i + 1; j < intArr.length; j++) {
if (intArr[p] > intArr[j]) {
p = j;
}
}
/*
* 最小值与i交换值
*/
int tmp = intArr[i];
intArr[i] = intArr[p];
intArr[p] = tmp;
}
return intArr;
}
public static void main(String[] args) {
int[] x = {3, 8, 9, 7, 2, 5, 5};
// 调用简单选择排序测试
int[] m = simpleSelect(x);
System.out.println(" ");
System.out.print("简单选择排序结果：");
for (int n : m) {
System.out.print(n);
}
}
}
4.希尔排序
先将真个带排序记录分割成若干个子序列，然后分别进行直接插入排序，带真个序列的记录基本有序时，在对全体记录进行插入排序。
时间复杂度O(n^1.3) 空间复杂度O(1)
package algorithm;
/**
* @time 2019年6月4日下午4:48:35
* @author lll
* @describe TODO
*/
public class ShellSort {
/**
* @time 2019年5月19日下午1:11:59
* @author lll
* @describe 希尔排序是高级版直接查找排序，所以也是不稳定排序
*/
public static int[] shell(int[] intArr) {
int i = intArr.length;
// 第一次循环将以此将增量缩写，直至为1
for (i = i / 2; i >= 1; i = i / 2) {
// 第二次循环
for (int j = 0; j < i; j++) {
// 第二、三次循环查找每个增量对应的分组数据
for (int m = j + i; m < intArr.length; m = m + i) {
int n;
int temp = intArr[m];
// 第四次循环对分组数据进行直接查找排序
for (n = m - i; n >= 0 && intArr[n] > temp; n = n - i) {
intArr[n + i] = intArr[n];
}
intArr[n + i] = temp;
}
}
}
return intArr;
}
public static void main(String[] args) {
int[] x = {3, 8, 9, 7, 2, 5, 5};
// 调用希尔排序测试
int[] m = shell(x);
System.out.println(" ");
System.out.print("希尔排序结果：");
for (int n : m) {
System.out.print(n);
}
}
}
5.快速排序
用一组数组存储记录，附设两个指针i和j，他们的初值分别为指向第一个记录和最后一个记录，设枢纽记录的关键字为pivokey，则首先从j所指向位置起向前搜素，找到第一个关键字小于pivokey的记录与枢纽记录交换，然后从i所指向位置起向后搜索，找到第一个大于关键字pivokey的记录与枢纽记录相互交换，重复这个步骤知道i等于j
时间复杂度O(nlogn)~O(n^2) 空间复杂度O(logn)
package algorithm;
public class QuickSort {
public static void quick(int[] intArr, int low, int high) {
int i = low, j = high;
int x = intArr[low];;
while (i < j) {
while (i < j && intArr[j] >= x) {
j--;
}
while (i < j && intArr[i] <= x) {
i++;
}
if (i < j) {
int temp = intArr[i];
intArr[i] = intArr[j];
intArr[j] = temp;
}
}
intArr[low] = intArr[i];
intArr[i] = x;
quick(intArr, low, j - 1);
quick(intArr, j + 1, high);
// return intArr;
}
public static void main(String[] args) {
int[] x = {3, 8, 9, 7, 2, 5, 5};
// 调用堆排序测试
quick(x, 0, x.length - 1);
System.out.println(" ");
System.out.print("快速排序结果：");
for (int n : x) {
System.out.print(n);
}
}
}
6.堆排序
对一组待排序记录的关键字，首先安装堆的定义排成一个序列，从而可以输出堆顶最大关键字，然后将剩余的关键字再调整新堆，以便得到次打的堆顶。如此反复，指导排成有序序列。
时间复杂度O(nlogn)
7.归并排序
把n个记录的无序文件看成是由n个长度为1的有序文件组成的文件，然后两两进行归并，得到n/2个长度为2或1的有序文件，再两两归并，如此反复，直到最后形成n个记录的有序文件。
时间复杂度为O(nlogn)
8.基数排序
按照组成关键字的各个数位的值进行排序，他是分配排序的一种，在在该排序中把关键字K_i看成一个元组。然后一次对各元组低位到高位进行比较，直到最后排序所有的最高位，得到有序序列。
时间复杂度O(d(n+rd))
