目录
排序
外部排序
依赖硬盘(外部存储器)进行排序,对数据集合要求较高,只能在特定场合下使用
内部排序
一次性把所有待排序的数据放入内存中进行的排序,基于元素之间比较的排序
稳定性:两个相等的数据,经过排序后,排序算法保证不会打乱两个数据的相对位置,直接插入排序,冒泡排序,归并排序具有稳定性
冒泡排序
从数组第一个元素开始,两两比较,如果后一个元素比前一个元素大,将两个元素交换,直到数组有序
/**
* 冒泡排序
* @param arr
*/
public static void bubbleSort(int[] arr){
for (int i = 0; i < arr.length-1; i++) {
boolean isSwapped = false;
for (int j = 0; j < arr.length-1-i ; j++) {
if (arr[j] > arr[j+1]){
swap(arr,j,j+1);
isSwapped = true;
}
}
if (!isSwapped){
//此时没有需要交换的元素,直接跳出循环
break;
}
}
}
堆排序
先把待排序的数组构造成一个大根堆,数组的最大值就是堆顶,然后把堆顶的数和末尾的数交换,此时,末尾的数为最大值,剩余待排序数组个数为n-1,最后把剩余的n-1个数再构造成大根堆,再将顶端数与n-1位置的数交换,直到数组有序
/**
* 堆排序
* @param arr
*/
public static void heapSort(int[] arr){
//把arr变成最大堆,从最后一个非叶子节点进行下沉操作
//从最后一个非叶子节点开始进行siftDown操作
for (int i = (arr.length - 1 - 1) / 2; i >= 0; i--) {
siftDown(arr,i,arr.length);
}
for (int i = arr.length - 1; i > 0; i--) {
// arr[0] 堆顶元素,就是当前堆的最大值
swap(arr,0,i);
siftDown(arr,0,i);
}
}
/**
* 元素下沉操作
* @param arr
* @param i
* @param length
*/
private static void siftDown(int[] arr, int i, int length) {
while (2 * i + 1 < length) {
int j = (i << 1) + 1;
if (j + 1 < length && arr[j + 1] > arr[j]) {
j = j + 1;
}
// j就是左右子树的最大值
if (arr[i] > arr[j]) {
break;
}else {
swap(arr,i,j);
i = j;
}
}
}
选择排序
将集合分为两个区间,每次从无序区间选择一个最大值/最小值,存放在无序区间的最后(或最前),直到全部待排序的数据元素排序完成
/**
* 选择排序
* @param arr
*/
public static void selectionSort(int[] arr){
for (int i = 0; i < arr.length-1; i++) {
int min = i;
//从剩下的元素中选择最小值
for (int j = i+1; j < arr.length; j++) {
if (arr[j] < arr[min]){
min = j;
}
}
swap(arr,min,i);
}
}
双向选择排序
将集合分为两个区间,每次从无序区间选出最小 和最大的元素,存放在无序区间的最前和最后,直到全部待排序的数据元素排完 。
/**
* 双向选择排序
* @param arr
*/
public static void selectionSortOP(int[] arr){
//low指向数组的第一个元素
int low = 0;
//high指向数组最后一个元素
int high = arr.length-1;
while (low <= high){
int min = low;
int max = high;
for (int i = low + 1; i <= high; i++) {
if (arr[i] < arr[min]){
//如果有比arr[min]更小的元素,就让min指向arr[i]的元素
min = i;
}
if (arr[i] > arr[max]){
//如果有比arr[max]更大的元素,就让max指向arr[i]的元素
max = i;
}
}
//此时min指向整个无序数组中最小元素,把arr[min]和low交换,让min指向有序列表的第一个元素
swap(arr,min,low);
//当max和low都指向第一个元素时,需要把max和min的位置交换然后再把max和high互换
if (max == low){
max = min;
}
swap(arr,max,high);
low++;
high++;
}
}
直接插入排序-----稳定
将集合分为两个区间,每次从待排序区间中把第一个元素插入到已排序区间的合适位置,直到整个数组有序
/**
* 直接插入排序
* @param arr
*/
public static void insertionSort(int[] arr){
//从第二个元素开始
for (int i = 1; i < arr.length; i++) {
//j指向待排序区间的第一个元素
// for (int j = i; j > 0 ; j--) {
// if (arr[j] >= arr[j-1]){
// //arr[j-1]指向排序区间的最后一个元素,此时说明数组已经有序,跳出循环
// break;
// }else {
// swap(arr,j,j-1);
// }
// }
for (int j = i; j > 0 && arr[j]<arr[j-1] ; j++) {
swap(arr,j,j-1);
}
}
}
折半插入排序
将集合分为两个区间,用二分法找到需要插入的位置
/**
* 折半插入排序
* @param arr
*/
public static void insertionSortBS(int[] arr) {
// 有序区间[0..i)
// 无序区间[i...n]
for (int i = 1; i < arr.length; i++) {
//先暂存一下val
int val = arr[i];
int left = 0;
//right指向无序区间的第一个元素
int right = i;
while (left < right){
//当left和right相遇的时候就意味着找到了要插入的位置
int mid = (left + right) >> 1;
if (val < arr[mid]){
right = mid;
}else {
//val = arr[mid]时为了保证稳定性把这种情况加到else中
left = mid + 1;
}
}
for (int j = i; j > left ; j--) {
arr[j] = arr[j-1];
}
//在left位置将元素插入
arr[left] = val;
}
}
希尔排序
希尔排序法又称缩小增量法。先选定一个整数gap,把所有距离为gap的元素分在同一组并对同一组组内的元素进行排序。然后gap/2,重复上述分组和排序的工作。当gap=1时, 对整个集合的元素进行一次直接插入排序,得到一个有顺序的集合
/**
* 希尔排序
* @param arr
*/
public static void shellSort(int[] arr) {
int gap = arr.length >> 1;
while (gap > 1){
insertionSortByGap(arr,gap);
gap = gap >> 1;
}
//当gap=1
insertionSort(arr);
}
private static void insertionSortByGap(int[] arr, int gap) {
for (int i = gap; i < arr.length ; i++) {
for (int j = i; j - gap >= 0 && arr[j] < arr[j-gap]; j -= gap) {
swap(arr,j,j-gap);
}
}
}
归并排序-----稳定
该算法是采用分治法,将原数组不断拆分,直到每一个子数组只剩下一个元素时拆分结束,然后将相邻的两个数组合并成一个有序的数组,直到整个数组有序
public static void mergeSort(int[] arr){
mergeSortInternal(arr,0,arr.length-1);
}
/**
* 在arr[l...r]进行归并排序,整个arr经过函数后就是一个已经有序的数组
* @param arr
* @param l
* @param r
*/
private static void mergeSortInternal(int[] arr, int l, int r) {
//当数组元素小于15个时,使用直接插入排序更快
if ( (r - l) <= 15){
insertionSort(arr,l,r);
return;
}
int mid = l + ((r - l) >> 1);
// 将原数组拆分为左右两个小区间,分别递归进行归并排序
// 走完这个函数之后 arr[l..mid]已经有序
mergeSortInternal(arr,l,mid);
// 走完这个函数之后 arr[mid+1..r]已经有序
mergeSortInternal(arr,mid+1,r);
//当左右两个子区间还有先后顺序不同时才merge
if (arr[mid] > arr[mid+1]){
merge(arr,l,mid,r);
}
}
/**
* 在arr[l..r]使用插入排序
* @param arr
* @param l
* @param r
*/
private static void insertionSort(int[] arr, int l, int r) {
for (int i = l+1; i <= r ; i++) {
for (int j = i; j > l && arr[j] < arr[j-1] ; j--) {
swap(arr,j,j-1);
}
}
}
/**
* 合并两个子数组arr[l..mid] 和 arr[mid + 1...r]为一个大的有序数组arr[l...r]
* @param arr
* @param l
* @param mid
* @param r
*/
//
private static void merge(int[] arr, int l, int mid, int r) {
// 先创建一个新的临时数组aux
int[] aux = new int[r - l + 1];
// 将arr元素值拷贝到aux上
for (int i = 0; i < aux.length; i++) {
aux[i] = arr[i + l];
}
// i就是左侧小数组的开始索引
int i = l;
// j就是右侧小数组的开始索引
int j = mid + 1;
// k表示当前正在合并的原数组的索引下标
for (int k = l; k <= r; k++) {
if (i > mid) {
// 左侧区间已经被处理完毕,只需要将右侧区间的值拷贝原数组即可
arr[k] = aux[j - l];
j ++;
}else if (j > r) {
// 右侧区间已经被处理完毕,只需要将左侧区间的值拷贝到原数组即可
arr[k] = aux[i - l];
i ++;
}else if (aux[i - l] <= aux[j - l]) {
// 此时左侧区间的元素值较小,相等元素放在左区间,保证稳定性
arr[k] = aux[i - l];
i ++;
}else {
// 右侧区间的元素值较小
arr[k] = aux[j - l];
j ++;
}
}
}
快速排序
1. 从待排序区间选择一个数,作为基准值v;
2. 遍历整个待排序区间,将< v 的元素放到v的左边,将>= v的元素放到v的右边;
3. 采用分治思想,对左右两个小区间按照同样的方式处理,直到小区间的长度 == 1,代表已经有序,或者小区间 的长度 == 0,代表没有数据。
public static void quickSort(int[] arr){
quickSortInternal(arr,0,arr.length-1);
}
private static void quickSortInternal(int[] arr, int l, int r) {
if (r - l <= 15) {
insertionSort(arr,l,r);
return;
}
//以p为分区间的值
int p = partition(arr,l,r);
quickSortInternal(arr,l,p-1);
quickSortInternal(arr,p+1,r);
}
/**
* 在arr[l..r]上的分区函数,返回分区点的索引
* @param arr
* @param l
* @param r
* @return
*/
private static int partition(int[] arr, int l, int r) {
//随机在当前数组中选一个数
int randomIndex = random.nextInt(l,r);
swap(arr,l,randomIndex);
int v = arr[l];;
// [l + 1..j] < v
// arr[j + 1..i) >= v
//j表示< v的区间里最后一个元素,j+1表示 >= v区间的第一个元素
int j = l;
// i表示当前正在扫描的元素
for (int i = l+1; i <= r ; i++) {
if (arr[i] < v){
swap(arr,j+1,i);
j++;
}
}
//将基准值v和最后一个 < v的元素交换,基准值就落在了最终位置
//v左边全是小于v的元素,右边是大于等于v的元素
swap(arr,j,l);
return j;
}
- 在接近有序的数组上,由于左右两个区间严重不平衡,时间复杂度会退化为O(n^2),此时可以在数组中随机选择一个值作为基准值
- 当有大量重复元素时,也会退化
二路快排
把数组中相等的元素平均分到左右两个区间
i从前往后走,遇到第一个比v大的数停止,j从后往前走,遇到第一个比v小的数停止,然后把arr[i]和arr[j]交换,保证相等元素平均分到两个区间。当i >= j时,此时结束
/**
* 二路排序
* @param arr
*/
public static void quickSort2(int[] arr){
quickSortInternal2(arr,0, arr.length-1);
}
private static void quickSortInternal2(int[] arr, int l, int r) {
if (r-l <= 15){
insertionSort(arr,l,r);
return;
}
int p = partition2(arr,l,r);
quickSortInternal2(arr,l,p-1);
quickSortInternal2(arr,p+1,r);
}
private static int partition2(int[] arr, int l, int r) {
int randomIndex = random.nextInt(l,r);
swap(arr,l,randomIndex);
int v = arr[l];
// arr[l + 1..i) <= v
//i从前往后走
int i = l + 1;
// arr(j ..r] >= v
//j从后往前走
int j = r;
while (true){
//i从前往后走,遇到第一个比v大的数停止
while (i <= j && arr[i] < v){
i++;
}
//j从后往前走,遇到第一个比v小的数停止
while (i <= j && arr[j] > v){
j--;
}
if (i >= j){
break;
}
//i和j交换,保证相等元素平均分到两个区间
swap(arr,i,j);
j--;
i++;
}
//j指向<= v中最后一个元素,和l交换
swap(arr,l,j);
return j;
}
三路快排
把数组中相等的数据放在一个区间中,此时相等的数据不再进行处理,把<v的元素放在左区间,>v的元素放在左区间,i是正在扫描的元素,lt是<v区间的最后一个元素,gt是>v区间的第一个元素
/**
* 三路快排
* @param arr
*/
public static void quickSort3(int[] arr){
quickSortInternal3(arr,0, arr.length-1);
}
private static void quickSortInternal3(int[] arr, int l, int r) {
if (r-l <= 15){
insertionSort(arr,l,r);
return;
}
int randomIndex = random.nextInt(l,r);
swap(arr,l,randomIndex);
int v = arr[l];
//i是正在扫描的元素
int i = l+1;
//lt指向<v的最后一个元素
int lt = l;
//gt指向>v的第一个元素
int gt = r + 1;
while (i < gt){
if (arr[i] < v){
//此时lt+1是相等区间的第一个元素
swap(arr,i,lt+1);
i++;
lt++;
}else if (arr[i] > v){
//此时gt-1是等待扫描的最后一个元素,i不用++,交换过去的gt-1是没有扫描过的
swap(arr,i,gt-1);{
gt--;
}
}else {
i++;
}
}
// lt落在最后一个 < v的索引处
swap(arr,lt,l);
//交换之后此时lt就是等于v的第一个元素
quickSortInternal3(arr,l,lt-1);
quickSortInternal3(arr,gt,r);
}