归并排序，快速排序

快速排序

1.主要思想：找基准数，然后左边的全部比基准数小，右边的都比基准数大。
2.举列：
3.算法思路：假设每次将所需排序的第一个数作为基准数，采用左右指针，先移动右指针，直到右指针所指数小于基准数，此时将右指针所指的值赋给左指针所指位置，同时左指针右移，直到找到比基准数大的数，再赋给此时的右指针所指位置，左右指针如此交替进行，最终相遇，相遇的位置就是基准值所在的位置。
4.学习心得：看了几个视频才懂，有些视频讲的晦涩难懂，多想几遍思路才能清晰。但是这个算法速度是真的很快！
5. 代码。

package 排序;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class QuickSort {

	public static void main(String[] args) {
		//int[] a = {-9,78,0,23,-567,70,-1,900,4561};
		int[] arr = new int[800000];
		for(int i = 0; i<arr.length; ++i) {
			arr[i] = (int) (Math.random() * 800000);
		}
		Date d = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
		String s = sdf.format(d);
		System.out.println("排序前时间："+s);
		
		quick(arr,0,arr.length-1);
		
		Date d2 = new Date();
		String s2 = sdf.format(d2);
		System.out.println("排序前时间："+s2);
	//	System.out.println(Arrays.toString(a));
        

	}
	
	public static void quick(int[] arr, int L, int R) {
		int left = L;
		int right = R;
		if(left > right) {
			return;
		}
		int pivot = arr[left];
		while(left < right) {
			while(left < right && arr[right] >= pivot) {
				right--;
			}
			if(left < right) {
				arr[left] = arr[right];
			}
			while(left < right && arr[left] <= pivot) {
				left++;
			}
			if(left < right) {
				arr[right] = arr[left];
			}
			if(left == right) {
				arr[left] = pivot;
			}
		}
		quick(arr,L,right-1);
		quick(arr,left+1,R);
	}

}
 

归并排序

1.主要思想：采用分治策略，将问题进行递归分解成很小的问题，再“治”进行合并与排序。
2.举列：
3.算法思路：
A.方法divide：将所有待排序的数进行分解，直至全部成为单个，不能再分解。
B.方法merge:将分出来的数，进行排序，再合并到临时数组，最后再拷贝到原数组 。
4.学习心得：有点绕不过来，特别是对于临时数组的创建那块，老师在创建初始数组时就创建了临时数组，大小为该数组大小，主函数调用divide，divide调用merge，但temp真正用到的时候却在merge数组里（拷贝所需），但这里必须提前创建好，因为如果在divide函数里创建，递归时会变得非常慢（8万个数据原来需要不到一秒，如果在divide里创建将会需要5-10秒甚至更久才能完成排序）。
5. 代码。

package 排序;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class MergeSort {

	public static void main(String[] args) {
		//int[] arr = {8,4,5,7,1,3,6,2};
		int[] arr = new int[8000000];
		int[] temp = new int[arr.length];
		for(int i = 0; i<arr.length; ++i) {
			arr[i] = (int) (Math.random() * 8000000);
		}
		Date d = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
		String s = sdf.format(d);
		System.out.println("排序前时间："+s);
		
		divide(arr,0,arr.length - 1,temp);
		
		Date d2 = new Date();
		String s2 = sdf.format(d2);
		System.out.println("排序前时间："+s2);
		
		
		//System.out.println("归并排序后："+ Arrays.toString(arr));
	}
	
	//先写“分”的方法
	/**
	 * @param arr
	 * @param left
	 * @param right
	 * @param temp
	 */
	public static void divide(int[] arr, int left, int right, int[] temp) {
		if(left < right) {
			int mid = (left + right) / 2;//中间索引
			//向左递归进行分解
			divide(arr, left, mid, temp);
			//向右递归进行分解
			divide(arr, mid+1, right, temp);
			//合并
			merge(arr, left, mid, right,temp);
		}
	}
	
	//治的方法(合并和排序)
	/**
	 * @param arr 排序的原始数组
	 * @param left 左边有序序列的初始索引
	 * @param mid 中间索引
	 * @param right 右边索引
	 * @param temp  中转数组
	 */
	public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
		int i = left;//初始化i,左边有序序列的初始索引
		int j = mid + 1;//初始化j,右边有序序列的初始索引
		int t = 0;//指向temp数组的当前索引
		//（一）
		//先把左右两边（有序）的数据按照规则填充到temp数组
		//直到两边的有序序列，有一边被处理完为止
		while(i <= mid && j <= right) {
			//如果左边的有序序列的当前元素，小于等于右边的当前元素
			//就将左边的元素，拷贝到temp数组，然后t++,i++;
			if(arr[i] <= arr[j]) {
				temp[t] = arr[i];
				t += 1;
				i += 1;
			} else {//反之，就将右边的有序序列拷贝进数组，然后t++,j--
				temp[t] = arr[j];
				t += 1;
				j += 1;
				
			}
		}
		
		
		//（二）
		//把剩余数据的一边的数据一次全部填充到temp
		while(i <= mid) {//左边的序列还有剩余的元素，就全部填充到temp
			temp[t] = arr[i];
			i += 1;
			t += 1;
		}
		while(j <= right) {
			temp[t] = arr[j];
			j += 1;
			t += 1;
		}
		
		 //（三）
		//将temp数组的元素拷贝到arr,注意每次拷贝的个数不同
		t = 0;
		int tempLeft = left;
		while(tempLeft <= right) {
			arr[tempLeft] = temp[t];
			t += 1;
			tempLeft += 1;
		}
		
	}

}