算法笔记-001 归并，快速，堆排序

三个排序方法的实践复杂度
在最基础的插入排序，选择排序，冒泡排序中，时间复杂度为O(n^2)，空间复杂度为O(1)

归并排序，快速排序，堆排序的时间复杂度为O(N*logN)
空间复杂度三者不一样，分别为：
归并：O(N)，快速：O(logN)，堆：O(1)

归并排序（递归）

递归利用栈先进后出的结果，进行存储。 (子过程和主过程共享同样的流程，但是作用域比主过程小)

//输出数组中的最大值
public class 视频_递归演示 {
	public static void main(String[] args) {
		int arr[] = {1,5,3,7,4,6,11};
		int max = getMax(arr, 0, arr.length-1);
		System.out.println(max);
	}

	private static int getMax(int[] arr, int leftIndex, int rightIndex) {
		if (leftIndex == rightIndex) {
			return arr[leftIndex];
		}
		int mid = (leftIndex + rightIndex)/ 2;
		int maxLeft = getMax(arr,leftIndex, mid);
		int maxRight = getMax(arr, mid+1, rightIndex);
		return Math.max(maxLeft, maxRight);
	}
}

归并排序：
将数组分成两份，两份都进行排序，排序完成之后再逐个比较元素大小

public class 视频_归并排序 {
	public static void mergeSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		sortProcess(arr, 0, arr.length-1);
   	}

	private static void sortProcess(int[] arr, int leftIndex, int rightIndex) {
		if (leftIndex == rightIndex) {
			return;
		}
		int mid = (leftIndex + rightIndex) / 2;
		sortProcess(arr, leftIndex, mid);
		sortProcess(arr, mid +1, rightIndex);
		merge(arr, leftIndex, mid, rightIndex);
	}

	private static void merge(int[] arr, int leftIndex, int mid, int rightIndex) {
		int[] help = new int[rightIndex- leftIndex + 1];//定义一个help数组长度为left到right
		int i = 0;//代表help中每个元素应填写在的位置
		int p1 = leftIndex;//将p1位置指向leftindex位置
		int p2 = mid + 1;//将p2指向mid+1的位置
		//p1的边界时leftindex到mid，p2的边界时mid+1到rightindex
		
		while (p1 <= mid && p2 <= rightIndex) {
			//p1和p2谁小谁就写在help数组对应位置
			help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
		}
		
		//两个必有且只有一个先越界，越界后上面的while循环停止，下面处理剩下未越界的那个数组中的数字
		while (p1 <= mid) {
			help[i++] = arr[p1++];
		}
		while (p2 <= rightIndex) {
			arr[leftIndex + 1] = help[i];
		}
		for (i = 0;  i < help.length; i++) {
			arr[leftIndex + i] = help[i];
		}
		
	}
}