常见排序集合（冒泡排序，选择排序，直接插入排序，二分插入排序，快速排序，希尔排序，归并排序）

一下是一些常见的排序算法：

交换元素（后面算法都有用到）：

// 交换元素
private static void swap(int[] a, int i, int j) {
int temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}

冒泡排序（有优化）：
// 冒泡排序(优化①，②，③，④)
private static void bubbleSort(int[] a) {
boolean flag = false;// ①表示整个序列是无序的
for (int i = 0; i < a.length - 1; i++) {
flag = true; // ②假设：此时序列是有序的
for (int j = 0; j < a.length - i - 1; j++) {
if (a[j] > a[j + 1]) {
swap(a, j, j + 1);
flag = false;// ③只要出现了交换位置，则上面假设不成立
}
}
// ④上面假设成立（即序列有序），直接返回，不需要再循环冒泡了
if (flag) {
return;
}
}
}

选择排序：
// 选择排序
private static void selectSort(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
for (int j = i + 1; j < a.length; j++) {
if (a[i] > a[j]) {
swap(a, i, j);
}
}
}
}直接插入排序：
// 直接插入排序
private static void inserteSort(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
int temp = a[i + 1];
int j = i;
while (a[j] > temp) {
a[j + 1] = a[j];
j--;
if (j < 0) {
break;
}
}
a[j + 1] = temp;
}
}二分插入排序：
// 二分插入排序
private static void binaryInsertSort(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
int low = 0;
int high = i;
int temp = a[i + 1];
int mid;
// 在low和high之间的区域内进行二分法，以确定新元素的插入位置
while (low <= high) {
mid = (low + high) / 2;
if (a[mid] > temp) {// 若带插入的数小于中间元素a[mid]，则目标落在左半区
high = mid - 1;
} else {// r若带插入的数大于等于中间元素a[mid]，则目标落于右半区
low = mid + 1;
}
}
// 搜索的最后一个小区间的high位置（即是查找目标，因此新元素的插入位置（即high+1）
// 把原来从high到i范围内的元素依次后移一个位置
for (int j = i; j > high; j--) {
a[j + 1] = a[j];
}
a[high + 1] = temp;
}
}

希尔排序：
// 希尔排序
private static void shellSort(int[] a) {
// 进行分组，初始步长设为数组长度的的一半（即n/2），然后依次减半，直到最后取1
for (int gap = (a.length + 1) / 2; gap > 0;) {
// 组内排序
for (int i = 0; i < a.length - gap; i++) {// 定位到每一个元素
for (int j = i; j < a.length - gap; j += gap) {
if (a[j] > a[j + gap]) {
swap(a, j, j + gap);
}
}
}
// for循环修正
if (gap > 1) {
gap = (gap + 1) / 2;
} else if (gap == 1) {
break;
}
}
}

快速排序（优化）：
// 快速排序
private static void quickSort(int[] a, int l, int r) {
if (l < r) {
int p = partition(a, l, r);
quickSort(a, l, p - 1);
quickSort(a, p + 1, r);
}
}

private static int partition(int[] a, int l, int r) {
// 优化随机取枢轴
int rand = (int) (Math.random() * (r - l));
swap(a, l, l + rand);
int i = l;// 第一个元素为枢轴
int j = r + 1;
int x = a[i];
while (true) {
while ((a[++i] < x) && i < r) {
}
;// 定位指针i，找到比x大的元素
while ((a[--j] > x)) {
}
; // 定位指针j
if (i >= j) {
break;
}
swap(a, i, j);
}
swap(a, l, j);// 枢轴a[l]要换到中间位置
return j;
}

归并排序：
// 归并排序
private static void mergeSort(int[] a, int l, int r) {
if (l < r) {//至少两个元素
int mid = (r + l)/2;
//把序列拆分成两个子序列[left,mid]和[mid+1,right]
//同时还要对分解后的子序列分别进行递归“归并排序”
mergeSort(a, l, mid);
mergeSort(a, mid + 1, r);
//把两个已经排好序的数组进行归并
int[] b = new int[a.length];
merge(a, b, l, mid, r);
copyArray(a, b, l, r);
}
}

private static void copyArray(int[] a, int[] b, int l, int r) {
for(int i=l;i<=r;i++){
a[i]=b[i];
}
}

//把两个已经排好的子序列（a[letf,mid]he a[mid+1,right]）合并成一个b[left,right]
private static void merge(int[] a, int[] b, int left, int mid, int right) {
int r=left;
int p=mid+1;
int k=left;
while(r<=mid&&p<=right){
if(a[r]<=a[p]){
b[k++]=a[r++];
}else{
b[k++]=a[p++];
}
}
//此时，肯定有一个子序列中的元素全部移动到b[]数组中，因此，需要把未移完的子序列当中的所有剩余的元素直接拷到数组b[]中即可
if(r>mid){//左子序已经完成，因此剩下的是有序列，对拷有序列中的剩余元素即可
for(int i=p;i<=right;i++){
b[k++]=a[i];
}
}else{//对拷左子序中的剩余元素
for(int i=r;i<=mid;i++){
b[k++]=a[i];
}
}
}