目录
排序
外部排序
依赖硬盘（外部存储器）进行排序，对数据集合要求较高，只能在特定场合下使用
内部排序
一次性把所有待排序的数据放入内存中进行的排序，基于元素之间比较的排序
稳定性：两个相等的数据，经过排序后，排序算法保证不会打乱两个数据的相对位置，直接插入排序，冒泡排序，归并排序具有稳定性
冒泡排序
从数组第一个元素开始，两两比较，如果后一个元素比前一个元素大，将两个元素交换，直到数组有序
/**
* 冒泡排序
* @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);
}
6720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
