版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u013132035/article/details/82657461
快速排序：时间复杂度O（nlogn），不稳定的排序算法
原理：快速排序是一种交换排序，它的基本思想是：通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）
//快速排序
public class QuickSort{
public static void quickSort(int num[]){
if(num == null || num.length < 2){//如果数组为null或者长度小于2直接返回,无需进行快排
return ;
}
quickSort(num, 0, num.length-1);
}
//使用递归进行快排
private static void quickSort(int num[], int low, int high){
int pivot;
if(low < high){
pivot = partition(num, low, high);
quickSort(num, low, pivot-1);
quickSort(num, pivot+1, high);
}
}
//分治
private static int partition(int num[], int low, int high){
int pivotKey = num[low];
while(low < high){
while(low < high && num[high] >= pivotKey){
high--;
}
swap(num, low, high);
while(low < high && num[low] <= pivotKey){
low++;
}
swap(num, low, high);
}
return low;
}
//交换顺序
private static void swap(int num[], int i, int j){
int tmp = num[i];
num[i] = num[j];
nnum[j] = tmp;
}
}堆排序：时间复杂度O（nlogn），不稳定的排序算法
原理：堆排序是一种选择排序，堆排序的基本思想就是，将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值，）然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次小值。如此反复执行，就能得到一个有序序列了。
//堆排序
public class HeapSort{
public static void heapSort(int num[]){
if(num == null || num.length < 2){//如果num为null或者长度小于2，无需进行堆排
return;
}
for(int i = 0; i < num.lengh; i++){
heapInsert(num, i);//调整为大顶堆,从下往上调
}
int size = num.length;
swap(num, 0, --size);
while(size > 0){
heapify(num, 0, size);//调整为大顶堆,从上往下调
swap(num, 0, --size);
}
}
//从下往上调整为大顶堆
private static void heapInsert(int num[], int i){
while(num[i] > num[(i-1)/2]){
swap(num, i, (i-1)/2);
i = (i-1)/2;
}
}
//从上往下调整为大顶堆
private static void heapify(int num[], int i, int size){
int left = 2 * i + 1;
while(left + 1 < size){
int large = left + 1 < size && num[left] > num[left+1] ? left : left+1;
large = left + 1 < size && num[large] > num[i] ? large : i;
if(large == i){
break;
}
swap(num, i, large);
i = large;
left = 2 * i + 1;
}
}
//数组元素交换
private static void swap(int num[], int i, int j){
int tmp = num[i];
num[i] = num[j];
num[j] = tmp;
}
}冒泡排序：时间复杂度O（n^2），稳定的排序算法
原理：冒泡排序是一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。
//冒泡排序
public class BubbleSort{
public static void bubbleSort(int num[]){
if(num == null || num.length < 2){//数组为null或者长度小于2,无需排序直接输出
return;
}
for(int i = 0; i < num.length-1; i++){
for(int j = 0; j < num.length - i - 1; j++){
if(num[j] > num[j+1]){
int tmp = num[j];
num[j] = num[j+1];
num[j+1] = tmp;
}
}
}
}
}简单选择排序：时间复杂度O（n^2），稳定的排序算法。
原理：简单选择排序是选择排序的一种，简单选择排序就是通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i（1<=i<=n）个记录交换之。
//简单选择排序
public class SimpleSort{
public static void simpleSort(int num[]){
if(num == null || num.length < 2){//如果num为null或者长度小于2直接返回
return;
}
for(int i = 0; i < num.length-1; i++){
int min = i;
for(int j = i + 1; j < num.length; j++){ //每一轮从第i个元素开始找出最小的元素
if(num[j] < num[min]){
min = j;
}
}
swap(num, i, min);//找出从第i个元素后的最小元素与第i个元素进行交换
}
}
//交换数组元素的位置
public static void swap(int num[], int i, int j){
int tmp = num[i];
num[i] = num[j];
num[j] = tmp;
}
}直接插入排序：时间复杂度O（n^2），稳定的排序算法。
原理：直接插入排序是插入排序的一种，它的基本思想就是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。
//直接插入排序
public class StraightInsertSort{
public static void straightInsertSort(int num[]){
if(num == null || num.length < 2){
return ;
}
for(int i = 1; i < num.length; i++){
int ins = num[i];
int j = i;
for(j = i; j > 0 && num[j-1] > ins; j--){
num[j] = num[j-1];
}
num[i] = ins;
}
}
}归并排序：时间复杂度O(nlogn)，稳定的排序算法
扫描二维码关注公众号，回复：
3308237 查看本文章
原理：二路归并排序是归并排序中较为经典的一种，它是利用归并的思想实现的排序算法。二路归并排序假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，……，如此重复，直至得到一个长度为n的有序序列为止，这种排序方法称为2路归并排序。
//归并排序
public class MergeSort{
public static void mergeSort(int num[]){
if(num == null || num.length < 2){
return;
}
mergeSort(num, 0, num.length-1);
}
//利用递归进行归并排序
private static void mergeSort(int num[], int low, int high){
if(low < high){
int mid = (low+high)/2
mergeSort(num, low, mid);
mergeSort(num, mid+1, high);
merge(num, low, mid, high);
}
}
//归并
private static void merge(int num[], int low, int mid, int high){
int tmp[] = new int[high-low+1];//开辟临时数组用来存储排好序的元素
int i = low; //定义左指针,指向数组左边部分
int j = mid + 1; //定义右指针,指向数组右边部分
int k = 0;
while(i <= mid && j <= high){
if(num[i] < num[j]){
tmp[k++] = num[i++];
}else{
tmp[k++] = num[j++];
}
}
while(i <= mid){ //左边部分有剩余，直接放到tmp数组末尾
tmp[k++] = num[i++];
}
while(j <= high){ //右边部分有剩余，直接放到tmp数组末尾
tmp[k++] = num[j++];
}
for(int x = 0; x < tmp.length; x++){//对原数组进行覆盖
num[x+low] = tmp[x]; //注意角标问题
}
}
}希尔排序：时间复杂度O（nlogn），不稳定的排序算法
原理：希尔排序是直接插入排序的改进版本，与直接插入排序不同的是它会优先比较距离较远的元素，希尔排序又叫缩小增量排序。
//希尔排序
public class ShellSort{
public static void shellSort(int num[]){
if(num == null || num.length < 2){
return;
}
int len = num.length;
int add = len;
while(true){
add = add / 3 + 1;
for(int i = 0; i < add; i++){
for(int j = i + add; j < len; j = j + add){
int current = num[j];
int k;
for(int k = j - add; k >= 0 && num[k] > current; k = k - add){
num[k+add] = num[k];
}
num[k+add] = current;
}
}
if(add == 1){
break;
}
}
}
}