1如何分析一个“排序算法”?
1.1排序算法的执行效率
1. 最好情况、最坏情况、平均情况时间复杂度
2. 时间复杂度的系数、常数 、低阶
3. 比较次数和交换(或移动)次数
1.2排序算法的内存消耗
1.3排序算法的稳定性
1.4冒泡排序和插入排序的时间复杂度都是 O(n2),都是原地排序算法,为什么插入排序要比冒泡排序更受欢迎呢?
冒泡排序中数据的交换操作:
if (a[j] > a[j+1]) { // 交换
int tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
flag = true;
}
插入排序中数据的移动操作:
if (a[j] > value) {
a[j+1] = a[j]; // 数据移动
} else {
break;
}
2快排、归并、堆排序
归并:稳定 空间复杂度O(n) 最差O(nlogn)
快排:不稳定 空间复杂度O(logn)~O(n) 最差O(n2)
堆排序:不稳定 空间复杂度O(1) 最差O(nlogn)
2.1快排
public static void quickSort(int[] arr, int start, int end) {
if (start >= end) {
return;
}
int pivotIndex = partition(arr, start, end);
quickSort(arr, start, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, end);
}
public static int partition(int[] arr, int start, int end) {
dealPivot(arr,start,end);
int pivot = arr[end];
int i = start;
for (int j = start; j <= end - 1; j++) {
if (arr[j] < pivot) {
swap(arr, i, j);
i = i + 1;
}
}
swap(arr, i, end);
return i;
}
public static void dealPivot(int[] arr, int left, int right) {
int mid = (left + right) / 2;
if (arr[left] > arr[mid]) {
swap(arr, left, mid);
}
if (arr[left] > arr[right]) {
swap(arr, left, right);
}
if (arr[right] < arr[mid]) {
swap(arr, right, mid);
}
swap(arr, right , mid);
}
2.2归并
private static void merge_sort_recursive(int[] arr, int[] result, int start, int end) {
if (start >= end) {
return;
}
int len = end - start, mid = (len >> 1) + start;
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;
merge_sort_recursive(arr, result, start1, end1);
merge_sort_recursive(arr, result, start2, end2);
int index = start;
while (start1 <= end1 && start2 <= end2)
result[index++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
while (start1 <= end1)
result[index++] = arr[start1++];
while (start2 <= end2)
result[index++] = arr[start2++];
for (index = start; index <= end; index++)
arr[index] = result[index];
}
public static void merge_sort(int[] arr) {
int len = arr.length;
int[] result = new int[len];
merge_sort_recursive(arr, result, 0, len - 1);
}
2.3findK
如何用快排思想在O(n)内查找第K大元素?
int findK(int[] arr, int k) {
return findKRecur(arr, 0, arr.length - 1, k - 1);
}
int findKRecur(int[] arr, int start, int end, int k) {
int pivot = QuickSort.partition(arr, start, end);
if (pivot == k) {
return arr[pivot];
} else if (pivot < k) {
return findKRecur(arr, pivot + 1, end, k);
} else {
return findKRecur(arr, start, pivot - 1, k);
}
}