1.思路分析：
第一步我们假定数组中的首元素是有序的，然后从第二个元素开始，先把该元素拷贝到temp中，我们用temp与该元素下标之前的元素进行比较如果该元素的值大于temp那么就让它向后移动一位，这样当遇到比temp小的元素时该元素后面的位置插入temp。
2.画图演示：
3.代码描述：
public static void insertSort(int [] array){
if(array.length <= 1){
return;
}
for (int i = 1; i < array.length; i++) {
int temp = array[i];
int j = i - 1;
while(j >= 0 && array[j] > temp){
array[j + 1] = array[j];
j--;
}
array[j + 1] = temp;
}1.思路分析：
希尔排序又称缩小增量法，其基本思想就是先对改数据进行分组，分为gap组然后在对这gap组元素分别进行直接插入排序，然后缩小gap的值直到gap = 1时，对该组元素进行排序。（希尔排序是对直接插入排序的优化）
当gap > 1时都是预排序，目的是让数组更加接近有序。这样就会对整体而言产生优化的效果。
2.画图演示：
3.代码描述：
if(array.length <= 1){
return;
}
int gap = array.length / 2;
while(gap > 0){
for (int i = gap; i < array.length; i++) {
int temp = array[i];
int j = i - gap;
while(j >= 0 && array[j] > temp){
array[j + gap] = array[j];
j -= gap;
}
array[j + gap] = temp;
}
gap /= 2;
}1.思路分析：
每一次从待排序的数据元素中选出最小的一个元素，存在序列的起始位置，直到全部待排序的数据元素排完。
2.画图演示：
3.代码描述：
public static void selectSort(int[] array){
for (int i = 0; i < array.length; i++) {
int index = i;
for (int j = i + 1; j < array.length ; j++) {
if(array[j] < array[index]){
index = j;
}
}
swap(array,i,index);
}
}
public static void swap(int[] array,int i,int index){
int temp = array[index];
array[index] = array[i];
array[i] = temp;
}1.思路分析：对于一组要排序的元素列，依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面，如此继续，直到比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成。
2.画图演示：
上图就是冒泡排序的第一趟排序，从首元素开始交换，最后得到一个未排序数据的最大值放于数据尾，那么下一趟排序只需交换到该最大值-1的位置处
3.代码描述：
public static void bubSort(int[] array){
for (int i = 0; i < array.length; i++) {
boolean flag = false;
for (int j = 0; j < array.length - 1 - i; j++) {
if(array[j] < array[j + 1]){
swap(array,j,j+1);
flag = true;
}
if(flag == false){
return;
}
}
}
}
public static void swap(int[] array,int i,int index){
int temp = array[index];
array[index] = array[i];
array[i] = temp;
}1.思路分析：
快速排序是指通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序。整个排序过程可以递归进行，以此达到整个数据变成有序序列。
2.画图演示：
第一次先以首元素为基准两个指针一个在首元素位置另外一个在末尾元素，right指针先往前走找到一个比temp小的元素A把A的值赋给left的元素值然后left指针往后走遇到一个比temp大的元素B，把B的值赋给A，然后再把temp的值赋给B。
3.代码描述：
public static void quickSort(int[] array,int left,int right){
if(right - left <= 0){
return;
}
int div = partion(array,left,right);
quickSort(array,left,div);
quickSort(array,div+1,right);
}
public static int partion(int[] array,int left,int right){
int temp = array[left];
while(left < right){
while(left <right && array[right] >= temp){
right--;
}
array[left] = array[right];
while(left < right && array[left] <= temp){
left ++;
}
array[right] = array[left];
}
array[left] = temp;
return left;
}1.思路分析：
归并排序用的更多的是解决在磁盘中的外排序问题，它采用分治算法，先使每个子序列有序，再使子序列段有序。若将两个有序表合并成一个有序表，称为二路归并。
2.画图演示：
3.代码描述：
public static void mergeSort(int[] array){
mergeSortFunc(array,0,array.length - 1);
}
public static void mergeSortFunc(int [] array,int left,int right){
if(left >= right){
return;
}
int div = (left + right) / 2;
mergeSortFunc(array,left,div);
mergeSortFunc(array,div +1,right);
merg(array,left,div,right);
}
public static void merg(int [] array,int left,int div,int right){
int[] arr = new int[right - left + 1];
int k = 0;
int s1 = left;
int e1 = div;
int s2 = div + 1;
int e2 = right;
while(s1 <= e1 && s2 <= e2){
if(array[s1] <= array[s2]){
arr[k] = array[s1];
s1++;
k++;
}else{
arr[k] = array[s2];
s2++;
k++;
}
}
while(s1 <= e1){
arr[k] = array[s1];
s1++;
k++;
}
while(s2 <= e2){
arr[k] = array[s2];
s2++;
k++;
}
for (int i = 0; i < k; i++) {
array[i + left] = arr[i];
}
}
