【2019春招准备：8.排序】

【内容】
【补充】

0. 时间复杂度

排序方法	时间复杂度	稳定性
快排	N log(N)
堆排	N log(N)	不稳定

1. 快排
   两种理解思路：单次交换法和双次交换法

package q3_sort;
import java.util.Scanner;
/**
 * 时间复杂度（NlogN）
 * @author ziboris
 * @date 2018年11月26日 上午9:37:04
 *
 */
public class Test1_QuickSort {
	public static void quick_sort(int[] a, int left, int right) {
		if (left < right) {
			// i,j都是移动的指针 x理解成放置元素的暂存器
			int i = left, j = right, x = a[left];
			while (i < j) {// 最外层的while保证下面两个while能够一直交互进行
				while (i < j && a[j] >= x)
					j--; // i j 在内层变化，因此需要包含最外层while的条件;x初试放置的是i 先从右边开始
				// 跳出循环是需要填坑了
				if (i < j)
					a[i++] = a[j];
				while (i < j && a[i] < x)
					++i;
				if (i < j)
					a[j--] = a[i];
			}
			// 跳出循环一定是i==j
			a[i] = x;
			quick_sort(a, left, i - 1);
			quick_sort(a, i + 1, right);
		}
	}
	public static void main(String[] args) {

		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int[] a = new int[n];// 初始化一个确定长度的数组

//		System.out.println(a.length);
		for (int i = 0; i < n; ++i) {
			a[i] = scanner.nextInt();
		}
		quick_sort(a, 0, a.length - 1);
		for (int i : a) {
			System.out.println(i);
		}
	}
}

2. 堆排序
   完全二叉树：堆（因此可以用数组表示 下标从1开始 不然很魔性）
   大顶堆 小顶堆

1-n n/2是最后一个非叶节点的下标

package q3_sort;

import java.util.Arrays;
import java.util.Scanner;

public class Test2_HeapSort {
	static int n = 10;
	static int[] a = new int[11];// 初始化一个确定长度的数组;

	public static void downAdjust(int low, int high) {
		int i = low;
		int j = i * 2;
		while (j <= high) {
			//如果有更大的右节点
			if (j + 1 <= high && a[j + 1] > a[j])
				j = j + 1;//下面将要交换的就是ij 只需要修改被交换过的j 没有被交换过的之前已经是顺序排列了
			
			//都是需要调整的时候 如果改增不需要调整，则他的下面更不需要调整
			if (a[i] < a[j]) {
				int temp = a[j];
				a[j] = a[i];
				a[i] = temp;
				i = j;
				j = j * 2;
			} else {
				break;
			}
		}
	}

	public static void heap_sort() {
//		create_heap();	
		for (int i = n / 2; i >= 1; --i) {
			downAdjust(i, n);
		}

//		sort
		for (int i = n; i > 1; --i) {
			int temp = a[1];
			a[1] = a[i];
			a[i] = temp;
			downAdjust(1, i - 1);
		}
	}

	public static void main(String[] args) {
		
//		72 6 57 88 60 42 83 73 48 85
		Scanner scanner = new Scanner(System.in);
		n = scanner.nextInt();

//		System.out.println(a.length);
		// 堆排序下标最好从1 开始 不然很魔性
		for (int i = 1; i <= n; ++i) {
			a[i] = scanner.nextInt();
		}

		heap_sort();

		System.out.println(Arrays.toString(a));
	}
}