排序算法：
1、冒泡排序：
for(int i = 0; i < n; i++) { // 每次循环 找到一个最小值
for(int j = i+1; j < n; j++) { // 寻找最小值
if(arr[j] < arr[i]) {
// 交换 i 和 j 对应的值
}
}
}
2、插入排序：
for(int i = 1; i < n; i++) { // 将当前值与前面排好序的值比较，直到找到一个比 i 对应的值小的数
for(int j = i; j > 0; j--) {
if( arr[j] > arr[j - 1] ) {
// 交换 j 和 j - 1 对应的值
} else {
break;
}
}
}
3、希尔排序：
for(int step = n / 2; step > 0; step /= 2) {
for(int i = step; i < n; i++) { // 每个步长，进行 插入排序
for(int j = i; j >= step && arr[j] < arr[j - step]; j -=step) {
// 交换 j 和 j - step 对应的值
}
}
}
4、快速排序：
public void quickSort(int[] arr, int start, int end) {
int temp = arr[start];
int i = start;
int j = end;
while(i < j) {
while(i < j && arr[j] >= temp) { // 寻找比 temp 小的值
j--;
}
while(i < j && arr[i] <= temp) { // 寻找比 temp 大的值
i++;
}
if( i < j ) { // 如果一次遍历没有结束，则交换值，并继续
// 交换 i 和 j 对应的值
}
}
// 当一次遍历结束，交换 start 和 i 对应的值
arr[start] = arr[i];
arr[i] = temp;
quickSort(arr, start, i - 1);
quickSort(arr, i + 1, end);
}
5、堆排序：数组的索引对应着堆中的广序遍历的索引
1）首先构建大顶堆：以 n / 2 - 1 （最后一个非叶子节点）开始
public void buildHeap(int[] arr) {
for(int i = arr.length / 2 - 1; i >= 0; i--) {
adjustHeap();
}
}
// 保证以index为根节点的树，父节点比左右节点都大
public void adjustHeap(int[] arr, int index, int length) {
int temp = arr[index]; // 当前需要调整的节点值
int k = index * 2 + 1; // 左子节点
while( k < length) {
if( k + 1 < length && arr[k] < arr[k+1]) {
k++; // 右子节点
}
if( arr[k] > temp) {
arr[index] = arr[k]; // 子节点大于父节点， 将子节点的值赋值给父节点
index = k; // 将 index 值设置为 子节点, 以当前子节点作为父节点
k = k * 2 + 1; // 左子节点
} else {
break;
}
}
arr[index] = temp;
}
2）堆排序
public void heapSort(int[] arr) {
buildHeap(arr); // 构建完后的的堆的最大值在第0个，而且父节点肯定比左右子节点都大
for(int i = arr.length - 1; i > 0; i--) {
// 交换第 0 个 和 第 i 个值，交换完后，第0个变成小值，需要调整堆，将根节点下面所有的父节点依次向上提，将小值放到最后
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
adjustHeap(arr, 0, i);
}
}