荷兰国旗快速排序及堆排序

荷兰国旗问题：

    荷兰国旗是由红、白、蓝三色组成,现在有若干红、白、蓝三种颜色的球随机排列成一条直线、如何把这些球按照红、白、蓝顺序排好。

    假设-1、0、1分别代表颜色红、白、蓝。时间复杂度:O(n)、空间复杂度O(1)

代码实现:

     public static int[] partition(int[] arr, int L, int R, int p) {
int less = L - 1;
int more = R + 1;
while (L < more) {
if (arr[L] < p) {
swap(arr, ++less, L++);
} else if (arr[L] > p) {
swap(arr, --more, L);
} else {
L++;
}
}
return new int[] { less + 1, more - 1 };
}
public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;

}

快速排序:

    通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的数据都要小，再按此方法对这两部分分别进行快速排序

    时间复杂度O(NLogN),空间复杂度O(logN)最好时间复杂度O(NlogN)最坏时间复杂度O(N^2),不稳定，但论文级别的可以:0 -1 stable sort

代码实现：

     public static void quickSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
quickSort(arr, 0, arr.length - 1);
}
public static void quickSort(int[] arr, int L, int R) {

if (L < R) {

                        //随机选择一个数进行划分

swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
int[] p = partition(arr, L, R);
quickSort(arr, L, p[0] - 1);
quickSort(arr, p[1] + 1, R);
}
}
public static int[] partition(int[] arr, int L, int R) {
int less = L - 1;
int more = R;
while (L < more) {
if (arr[L] < arr[R]) {
swap(arr, ++less, L++);
} else if (arr[L] > arr[R]) {
swap(arr, --more, L);
} else {
L++;
}
}
swap(arr, more, R);
return new int[] { less + 1, more };
}
public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}     

堆排序:

    堆排序是指利用堆积树这种数据结构所设计的一种排序算法.堆分为大根堆和小根堆,是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，利用最大值一定在堆顶这特性可以进行排序。一个i位置的左右孩子节点为：2*i+1与2*i+2,父节点为(i-1)/2.

     时间复杂度O(N*logN)，额外空间复杂度O(1)，实现不能做到稳定性.

代码实现:

    public static void heapSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int i = 0; i < arr.length; i++) {
heapInsert(arr, i);
}
int size = arr.length;
swap(arr, 0, --size);
//不断减大根堆从而排好序
while (size > 0) {
heapify(arr, 0, size);
swap(arr, 0, --size);
}
}
public static void heapInsert(int[] arr, int index) {
//建立一个大根堆
while (arr[index] > arr[(index - 1) / 2]) {
swap(arr, index, (index - 1) / 2);
index = (index - 1) / 2;
}

}

              //减堆操作

public static void heapify(int[] arr, int index, int size) {
int left = index * 2 + 1;
while (left < size) {
//获取最大节点的位置
int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
largest = arr[largest] > arr[index] ? largest : index;
if (largest == index) {
break;
}
//某个节点孩子比父节点大,那个孩子的位置是largest
swap(arr, largest, index);
//把子节点的位置给父节点以便下一次while循环
index = largest;
left = index * 2 + 1;
}
}


public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}