算法基础2 快排-堆排-桶排

// 整理于左神的算法课
一。快排（荷兰国旗问题）（时间复杂度O(N*logN)，额外空间复杂度O(logN)）

给定一个数组arr，和一个数num，请把小于num的数放在数组的
左边，等于num的数放在数组的中间，大于num的数放在数组的右边。

要求额外空间复杂度O(1)，时间复杂度O(N)

快排的实现：

 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 tmp = arr[i];
	arr[i] = arr[j];
	arr[j] = tmp;
}

二。堆排序 (时间复杂度O(N*logN)，额外空间复杂度O(1))

详细：https://www.cnblogs.com/chengxiao/p/6129630.html

思路：

a.将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;

b.将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;

c.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序

注意：

1，堆结构的heapInsert与heapify

2，堆结构的增大和减少

3，如果只是建立堆的过程，时间复杂度为O(N)

4，优先级队列结构，就是堆结构

  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;
		}
		swap(arr, largest, index);
		index = largest;
		left = index * 2 + 1;
	}
}

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

三。桶排序

桶排序、计数排序、基数排序的介绍

1，非基于比较的排序，与被排序的样本的实际数据状况很有关系，所
以实际中并不经常使用

2，时间复杂度O(N)，额外空间复杂度O(N)

3，稳定的排序

 // only for 0~200 value
public static void bucketSort(int[] arr) {
	if (arr == null || arr.length < 2) {
		return;
	}
	int max = Integer.MIN_VALUE;
	for (int i = 0; i < arr.length; i++) {
		max = Math.max(max, arr[i]);
	}
	int[] bucket = new int[max + 1];
	for (int i = 0; i < arr.length; i++) {
		bucket[arr[i]]++;
	}
	int i = 0;
	for (int j = 0; j < bucket.length; j++) {
		while (bucket[j]-- > 0) {
			arr[i++] = j;
		}
	}
}

四。排序的稳定性

1.概念：

排完序之后相对序列不变

2.工程中应用的排序算法

基本数据类型(数据多) ：快排

其他（数据多）：归并

（数据少）：插排