插入，选择，希尔和快速速度比较以及算法实现

实验：比较80000个随机数据排序的快慢

public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr2 = new int[80000];
		for(int i=0;i<80000;i++) {
			arr2[i]=(int) (Math.random()*80000);
		}
		String time1 =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
		System.out.println(time1);
		//quick(arr2);
		//shell(arr2);
		charu(arr2);
		String time2 =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
		System.out.println(time2);
	}

1.插入排序
基本思想：基本思想是：将整个数组a分为有序和无序的两个部分。前者在左边，后者在右边。开始有序的部分只有a[0] , 其余都属于无序的部分。每次取出无序部分的第一个（最左边）元素

public static void charu(int[] arr2) {
		for(int i=1 ;i<arr2.length;i++) {
			int insert = arr2[i];
			int insertIndex = i-1;
			while(insertIndex>=0 && insert<arr2[insertIndex]) {
				arr2[insertIndex+1] = arr2[insertIndex];
				insertIndex--;
			}
				arr2[insertIndex+1] = insert;
		}
	}

运行时间大概2秒

2.选择排序
基本思想：如果有N个元素需要排序，首先从N个元素中找到最小的那个元素，然后与索引i=0位置上的元素进行交换(如果没有比原来索引i=0位置上的元素小就不用交换),接着再从剩下的N-1个元素中找出最小的元素，再与索引i=1位置上的元素进行交换；之后，再从剩下的N-2个元素中找出最小的元素，再与索引i=2位置上的元素进行交换,…重复上面的操作，一直到完全排序完成为止

public static void xuanzhe(int[] arr) {
		// TODO Auto-generated constructor stub
		for(int i=0;i<arr.length-1;i++) {
			int min = arr[i];
			int index = i ;
			for(int j=i+1 ;j<arr.length;j++) {
				if(min>arr[j]) {
					min = arr[j];
					index = j;
				}
			}
			if(index!=i) {
				arr[index] = arr[i];
				arr[i] = min;
				
			}
		}
	}

运行时间小于或者等于一秒

3.希尔排序
基本思想：当有大量的数据需要排序时，可以将大量的数据分组成若干子序列，此时每个子序列的数据比较少，可以对每个子序列使用直接插入排序。当整个序列基本有序时(基本有序：小的关键字基本在前，大的基本在后，不大不小的基本在中间)。再对整体的数据进行一次直接插入排序。对原始数据进行分割的目的就是减少待排序数据的个数，使得整个序列朝着基本有序方向发展

//采用移位法速度快了很多
	public static void shellSort2(int[] arr) {
		for (int gap = arr.length / 2; gap > 0; gap = gap / 2) {
			for (int i = gap; i < arr.length; i++) {
				int j = i;
				int temp =arr[j];
					while(j-gap>=0&&temp<arr[j-gap]) {
						arr[j] = arr[j-gap];
						j = j-gap;
					}
					arr[j] = temp;
			}
		}
	}

运行时间小于一秒
4.快速排序
基本思想：将一个数组按照一个基准数分为两部分，如果从小到大排序的话，将大于基准数的放在数组右边，小于基准数的放在数组左边。对于分治算法，当每次划分时，算法若都能分成两个等长的子序列时，那么分治算法效率会达到最大。也就是说，基准的选择是很重要的。选择基准的方式决定了两个分割后两个子序列的长度，进而对整个算法的效率产生决定性影响。最理想的方法是，选择的基准恰好能把待排序序列分成两个等长的子序列

以数组中间值为轴
public static void quick(int[] arr,int left,int right) {
		int l =left;
		int r =right;
		//中轴值
		int pivot = arr[(l+r)/2];
		int temp = 0;
		while(l < r) {
			
			//从左边找出比中间值大的那个数
			while(arr[l] < pivot) {
				l++;
			}
			//从右边找出比中间值小的那个数
			while(arr[r]> pivot) {
				r--;
			}
			//退出条件  
			if(l == r) {
				r--;
				l++;
				break;
			}
			//将找到的两个数交换
			temp = arr[l];
			arr[l] = arr[r];
			arr[r] = temp;
			
			//避免死循环  如果中间值的前一个数或者后一个数相等会出现死循环  这时候将 r--, l++,就不满足
			//最外层的while(l < r) 这个条件，就退出了
			if(arr[l] == pivot) {
				r--;
			}if(arr[r] == pivot) {
				l++;
			}
			
		}
		//退出过后进行递归
		if(left < r) {
			quick(arr, left, r);
		}if(right >l) {
			quick(arr, l,right);
		}
		
		
	}

运行时间小于1秒

总结：
插入排序：适用于待排序数据大部分已排序时，如果元素包含的内容过大，就不适合直接插入排序，因为直接插入排序需要移动元素的次数比较多.
选择排序：不稳定，适用于数据量不大，并且对稳定性没有要求的情况。
希尔排序：不稳定，希尔排序是对直接插入排序的一种优化，可以用于大型的数组，希尔排序比插入排序和选择排序要快的多，并且数组越大，优势越大。
快速排序：一般应用中，比其他排序快得多，适用于数组长度比较大的情况，对于小数组，不稳定，快速排序比插入排序慢。