Java 中的几个排序算法实现
一、冒泡排序、插入排序、希尔排序、快速排序与归并排序
效率概要：
冒泡排序是蛮力法，使用两层嵌套循环，基本效率为 O(n^2)
插入排序是减治法，第一趟排序，最多比较一次，第二趟排序，最多比较两次，以此类推，最后一趟最多比较N-1次，因此有1+2+3+…+N-1 = N*(N-1)/2。然而，因为在每一趟排序发现插入点之前，平均只有全体数据项的一半真的进行了比较，所以除以2最后是N*(N-1)/4。
对于随机顺序的数据，插入排序也需要O（N²）的时间级。当数据基本有序，插入排序几乎只需要O(N)的时间，这对把一个基本有序的文件进行排序是一个简单而有效的方法。
对于逆序排列的数据，每次比较和移动都会执行，所以插入排序不比冒泡排序快。
快速排序是分治法，治的时间效率为 O(n), 分的时间效率为 O(log(n))，总效率为 O(nlog(n))
冒泡排序
public class Demo {
private int[] arr = {9, 8, 2, 4, 6};
@Test
public void test() {
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
private void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[i]) {
int p = arr[i];
arr[i] = arr[j];
arr[j] = p;
}
}
}
}
}
一次循环确立一个值 O(n)，需要 n 次循环，总共是 O(n^2)
插入排序（推进法、减治法）
public class Demo {
@Test
public void test() {
int[] arr = {9, 8, 2, 4, 6};
insert_sort(arr);
System.out.println(Arrays.toString(arr));
}
private void insert_sort(int[] arr) {
for (int i = 0; i <= arr.length - 1; i++) {
int key = arr[i];
int j = i - 1;
for (; j >= 0 && arr[j] > key; j--) {
arr[j+1] = arr[j]; // 大的数往右推
}
arr[j + 1] = key;
}
}
}
这个算法从数组的第二个元素开始循环，将选中的元素与之前的元素一一比较，如果选中的元素小于之前的元素，则将之前的元素后移，最后再将选中的元素放在合适的位置。在这个算法执行的过程中，总是保持着索引i之前的数组是升序排列的。
总共比较了 (1+2+3+…+N-1) / 2 次，所以效率是 N*(N-1)/4。平均效率为 O(n^2)
总数 少于 47，使用插入排序。
快速排序
public class Demo {
@Test
public void test() {
int[] nums = {9, 8, 2, 4, 6};
quickSort(nums, 0, 4);
System.out.println(Arrays.toString(nums));
}
private void quickSort(int[] arr, int low, int high) {
if (low < high) {
int mid = getMiddle(arr, low, high);
quickSort(arr, low, mid - 1);
quickSort(arr, mid + 1, high);
}
}
private int getMiddle(int[] arr, int low, int high) {
int pivot = arr[low];
while (low < high) {
while (low < high && arr[high] >= pivot) high--;
arr[low] = arr[high];
while (low < high && arr[low] < pivot) low++;
arr[high] = arr[low];
}
arr[low] = pivot;
return low;
}
}
分治法：一次确立一个数处于中间位置 O(n)，这个中间数的两边分别再次确立同样的中间数，依次推进直到所有数都确立完毕 O(logn)，总共是 O(nlog(n))
归并排序
public class Demo {
@Test
public void test() {
int[] arr = {9, 8, 2, 4, 6, 4};
merge_sort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}
private void merge_sort(int[] arr, int left, int right) {
if (left < right) {
int center = (left + right) / 2;
merge_sort(arr, left, center);
merge_sort(arr, center + 1, right);
merge(arr, left, center, right);
}
}
private static void merge(int[] a, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int i = low, j = mid + 1, k = 0;
while (i <= mid && j <= high) { // 把两个数组中较小的数先移到新数组中
if (a[i] < a[j]) {
temp[k++] = a[i++];
} else {
temp[k++] = a[j++];
}
}
while (i <= mid) { // 把左边剩余的数移入数组
temp[k++] = a[i++];
}
while (j <= high) { // 把右边边剩余的数移入数组
temp[k++] = a[j++];
}
for (int k2 = 0; k2 < temp.length; k2++) { // 把原数组替换为新数组
a[k2 + low] = temp[k2];
}
}
}
二、常见问题
概述：
1. 折半查找（二分法）
运用了减治法
public class Test {
private static int[] arr = new int[]{29, 12, 78, 23, 18, 24, 78, 23, 43};
@org.junit.Test
public void binarySearch() {
Arrays.sort(arr);
System.out.println(find(arr, 3));
}
private int find(int[] arr, int key) {
return find(arr, key, 0, arr.length -1);
}
private int find(int[] arr, int key, int low, int high) {
if (low <= high) {
int mid = (low + high) >>> 1;
int midVal = arr[mid];
if (midVal == key) {
return mid;
} else if (key < midVal) {
return find(arr, key, low, mid - 1);
} else {
return find(arr, key, mid + 1, high);
}
} else {
return -(low + 1);
}
}
}
2. 求数组最大值位置
运用了分治法
public class Test {
private static int[] arr = new int[]{29, 12, 38, 23, 98, 24, 28, 23, 43};
@org.junit.Test
public void test() {
int maxInt = max(0, arr.length - 1);
System.out.println(maxInt);
}
private int max(int low, int high) {
if (low < high) {
int mid = (low + high) >>> 1;
int m1 = max(low, mid);
int m2 = max(mid + 1, high);
return arr[m1] > arr[m2] ? m1 : m2;
} else {
return low;
}
}
}
待日后总结：https://my.oschina.net/lemos/blog/1932171
