/**
* 1、冒泡排序
* <p>
* 原理:<p>循环n-1次,每次循环找到当次循环最大/最小元素</p>
* 实现:<p>外层控制循环次数(n-1),内层对相邻元素进行比较交换</p>
* 复杂度:{[@code](https://my.oschina.net/codeo) O(n^2)}
*/
private static void bubbleSort(int[] arr) {
//外层控制循环次数
for (int m = 0; m < arr.length - 1; m++) {
//内层比较交换
for (int n = 0; n < arr.length - 1 - m; n++) {
if (arr[n] > arr[n + 1]) {
int tmp = arr[n];
arr[n] = arr[n + 1];
arr[n + 1] = tmp;
}
}
}
}
/**
* 2、选择排序
* <p>
* 原理:<p>循环n次,内部循环每次找到当前循环元素范围内最大/最小下标,如发生改变,则交换数值</p>
* 实现:<p>外层控制循环次数(n-1),内层对相邻元素进行比较、记录下标、交换数值</p>
* 优缺点:对比冒泡排序,少了每次对比后的交互,只在每次外层循环后交互,优于冒泡
* 复杂度:{[@code](https://my.oschina.net/codeo) O(n^2)}
*/
public static void selectSort(int[] arr) {
//外层控制次数
for (int i = 0; i < arr.length; i++) {
int min_index = i;
//内层控制元素范围并实现对比、记录、交换
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min_index]) {
min_index = j;
}
}
//如果最大/小index发生改变,则交换
if (i != min_index) {
int temp = arr[i];
arr[i] = arr[min_index];
arr[min_index] = temp;
}
}
}
/**
* 3、插入排序
* <p>
* 原理:<p>依次将原数组每个元素与该元素之前的元素对比,根据排序规则插入到合适位置</p>
* 实现:<p>外层循环控制对哪个下标的元素进行处理,内部循环将次元素与其之前的元素进行对比,找到正确的位置</p>
* 优缺点:在数组元素随机排列的情况下,插入排序优于冒泡和选择
* 复杂度:{[@code](https://my.oschina.net/codeo) O(n^2)}
*/
private static void insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
//将当前元素与其之前的元素进行对比、交换
for (int j = i; j > 0; j--) {
if (arr[j] < arr[j - 1]) {
//交换
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
} else {
break;
}
}
}
}
/**
* 4、希尔排序
* <p>
* 原理:
* <p>
* 希尔排序也是一种插入排序,它将数组以增量进行增量组,然后分别进行插入排序,不断缩小增量,直至增量为1,数组即排序完成,建议增量为{n/2,(n/2)/2...1},称为希尔增量
* </p>
* 实现:<p>最外层循环控制增量,中层负责对当前增量下的元素进行循环处理,内层使用插入排序进行排序</p>
* 优缺点:在数组元素随机排列的情况下,插入排序优于冒泡和选择
* 复杂度:在{n/2,(n/2)/2...1}增量序列下为{[@code](https://my.oschina.net/codeo) O(n^2)|,经过优化后可以达到{[@code](https://my.oschina.net/codeo) O(n^2/3)}
*/
public static void shellSort(int[] arr) {
//外层控制增量
for (int add = arr.length / 2; add > 0; add /= 2) {
//从增量大小处开始对每组进行排序操作,因为在增量处刚好每一组都出现了一个元素
for (int i = add; i < arr.length; i++) {
//插入排序操作,与该组该元素之前元素进行对比、交换
for (int j = i; j > 0; j -= add) {
//判断的时候注意j-add>=0,而不是>0,这样才能确保第0个元素也能被排序进来
if (j - add >= 0 && arr[j] < arr[j - add]) {
//交换
int temp = arr[j];
arr[j] = arr[j - add];
arr[j - add] = temp;
} else {
break;
}
}
}
}
}
/**
* 5、归并排序
* <p>
* 原理:<p>将原数组一直二分下去,直到不能再分,对分离的每一个部分,重新组合起来,组合的时候对相邻部分按照顺序依次排序(借助临时数组重组后拷贝)</p>
* 实现:<p>使用递归实现,在对相邻节点进行合并的时候,借助临时数组进行存储和拷贝</p>
* 优缺点:利用完全二叉树,最好,最坏,平均时间复杂度均为O(nlogn)
* 复杂度:{@code O(nlogn)}
*/
public static void mergeSort(int[] arr) {
//临时数组,避免递归中频繁开辟空间
int[] temp = new int[arr.length];
doMergeSort(arr, 0, arr.length - 1, temp);
}
/**
* @param arr 排序数组
* @param left 最左边index
* @param right 最右边index
* @param temp 临时数组
*/
private static void doMergeSort(int[] arr, int left, int right, int[] temp) {
//当元素不能再分时停止
if (left < right) {
int mid = (left + right) / 2;
doMergeSort(arr, left, mid, temp);
doMergeSort(arr, mid + 1, right, temp);
int left_start_index = left;
int rigth_start_index = mid + 1;
int temp_index = 0;
//先对比在两边数组都有数据的时候
while (left_start_index <= mid && rigth_start_index <= right) {
if (arr[left_start_index] < arr[rigth_start_index]) {
temp[temp_index++] = arr[left_start_index++];
} else {
temp[temp_index++] = arr[rigth_start_index++];
}
}
//考虑左还遗留元素
while (left_start_index <= mid) {
temp[temp_index++] = arr[left_start_index++];
}
//考虑右还遗留元素
while (rigth_start_index <= right) {
temp[temp_index++] = arr[rigth_start_index++];
}
//将临时数组元素拷贝进原数组
int copy_index = 0;
int arr_index = left;
while (copy_index < right - left + 1) {
arr[arr_index++] = temp[copy_index++];
}
}
}
/**
* 6、快速排序-三数取中法
* <p>
* 原理:<p>首先对原数组的首中(枢纽)尾三个元素进行排序交换,然后将中值移动到紧邻尾元素的位置,对中间剩余的非首中尾元素分别从前(记下标为i)找到大于枢纽,尾(记下标为j)找到
* 小于枢纽的值,如果配对成功则交换,当i>=j时,停止匹配,再将枢纽值与i(只可i不可j)值交换,再将该数组以i(此时为枢纽值)拆分为两个数组,递归进行此操作,直至排序完成
* </p>
* 实现:<p>先取得前、中、尾三数,再排序并把中移到紧邻尾的位置,将剩余元素以枢纽值划分配对交换,还原枢纽值,递归</p>
* 复杂度:{@code O(nlogn)}
*/
private static void quickSort(int[] arr) {
doQuickSort(arr, 0, arr.length - 1);
}
/**
* @param arr 排序数组
* @param left 左元素下标
* @param right 右元素下标
*/
private static void doQuickSort(int[] arr, int left, int right) {
if (left < right) {
//取得首、中、尾并调整顺序
int mid = (left + right) / 2;
//左两数
if (arr[left] > arr[mid]) {
int temp = arr[left];
arr[left] = arr[mid];
arr[mid] = temp;
}
//右两数
if (arr[mid] > arr[right]) {
int temp = arr[mid];
arr[mid] = arr[right];
arr[right] = temp;
}
//左两数
if (arr[left] > arr[mid]) {
int temp = arr[left];
arr[left] = arr[mid];
arr[mid] = temp;
}
//将中值放到紧邻尾元素处
int temp = arr[right - 1];
arr[right - 1] = arr[mid];
arr[mid] = temp;
//真正的排序操作,如果left与right之间元素个数大于2个时才需要做拆分排序,其他情况在上面构建枢纽的时候就已经排序好了
if (right - left > 2) {
int flag = arr[right - 1];
int left_index = left + 1;
int right_index = right - 2;
while (left_index <= right_index) {
//大于枢纽值
if (arr[left_index] > flag) {
if (arr[right_index] < flag) {
int temp1 = arr[left_index];
arr[left_index] = arr[right_index];
arr[right_index] = temp1;
left_index++;
right_index--;
} else {
right_index--;
}
} else {
left_index++;
}
}
//把枢纽值和left_index处值交换
int temp2 = arr[left_index];
arr[left_index] = flag;
arr[right - 1] = temp2;
//将两边的数组继递归处理
doQuickSort(arr, left, left_index - 1);
doQuickSort(arr, left_index + 1, right);
}
}
}
/**
* 7、堆排序
* <p>
* 原理:<p>将数组构建为大顶堆或小顶堆,然后依次将顶元素存于数组,直至排序完成</p>
* 实现:<p>构建大/小顶堆,交换元素</p>
* 复杂度:{@code O(nlogn)}
*/
public static void heapSort(int[] arr) {
//构建大顶堆
for (int i = arr.length / 2 - 1; i >= 0; i--) {
build(arr, i, arr.length);
}
//交换元素
for (int j = arr.length - 1; j > 0; j--) {
//交换
int temp = arr[0];
arr[0] = arr[j];
arr[j] = temp;
build(arr, 0, j);
}
}
/**
* 调整大顶堆(仅是调整过程,建立在大顶堆已构建的基础上)
*
* @param arr 数组
* @param i 第一个非叶子节点下标
*/
public static void build(int[] arr, int i, int length) {
int temp = arr[i];
for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
if (k + 1 < length && arr[k] < arr[k + 1]) {
k++;
}
if (arr[k] > temp) {
arr[i] = arr[k];
i = k;
} else {
break;
}
}
arr[i] = temp;
}