最通俗易懂的排序算法（一）

  这里的几种排序，其排序过程都是在内存中进行，而不涉及数据的内、外存交换，这样的排序称之为内排序。
  冒泡排序 快速排序 直接插入排序 希尔排序
  选择排序、归并排序、基数排序

一、交换排序

1.冒泡排序
  相邻两个元素进行大小比较和交换，将较小的元素交换到较大元素的前面，第一趟之后最小的元素就到达最前面，第二趟将第二小的元素交换到第二个位置，经过若干趟所有元素排列成从小到大的顺序，这样的排序就是冒泡排序。
排序过程如图所示：

冒泡排序算法：

import java.util.Arrays;
public class BubbleSortTest{
	public static void main(String[] args){
		int[] array = new int[]{9,8,7,6,5,4,3,2,1};
		bubbleSort(array);
		System.out.println(Arrays.toString(array));
	}
	public static void bubbleSort(int[] array){
		for(int i=0;i<array.length-1;i++){
			for(int j=array.length-1;j>i;j--){
				if(array[j]<array[j-1]){
					int temp = array[j];
					array[j] = array[j-1];
					array[j-1] = temp;
				}
			}
		}
	}
}

2.快速排序
  快速排序是由冒泡排序改进而得到的，它的基本思想是在待排序的n个元素中任取一个元素（通常取第一个元素）作为基准，把该元素放到适当位置后，数据序列就会被此元素分为两部分。所有比基准元素小的排在它的前面，比它大的排在后面。之后对产生的两部分分别重复上述过程，直到每一部分内只有一个元素或空为止。
算法过程分析：
  一趟快速排序过程，无序区中的元素array[start]，array[start+1]，··· ，array[end]，定义两个指针元素 low和high分别指向无序区的第一个元素和最后一个元素，low的初值为start，high的初值为end，首先将array[start]作为基准元素stard，指针high从end位置向前扫描，直到array[hight]<stard，此时将R[high]移到指针low指向的位置，然后让指针low向后扫描，直到array[low]>stard，此时将R[low]移到指针high指向的位置，依次循环直到 low=high，最后将基准元素stard移到指针low指向的位置，此时基准元素归位。基准元素前面的数字都是大于它的，后面的都是小于它的。

快速排序算法：

import java.util.Arrays;
public class QuickSort {
    public static void main(String[] args) {
        int[] array = new int[]{9,8,7,6,0,1,5,4};
        quickSort(array,0,array.length-1);
        System.out.println(Arrays.toString(array));
    }
    public static void quickSort(int[] array,int start,int end){
        if (start<end){
            //把数组中第O个数组作为基准数
            int stard = array[start];
            //记录需要排序的上下标
            int high = end;
            int low = start;
            //循环找出比基准数小和比基准数大的数字
            while(low<high){
                //从右向左扫描，找出小于基准数的元素
                while(low<high&&array[high]>=stard){
                    high--;
                }
                array[low]=array[high];
                //从左向右扫描，找出大于基准数的元素
                while(low<high&&array[low]<=stard){
                    low++;
                }
                array[high]=array[low];
            }
            //将基准元素归位
            array[low]=stard;
            //对左区间排序
            quickSort(array,start,low-1);
            //对右区间排序
            quickSort(array,low+1,end);
        }
    }
}

二、插入排序
  插入排序的基本思想：每次将一个待排序的元素按其大小插入到有序区的适当位置，直到所有元素都插入完成为止。根据其寻找插入位置的方法不同可以分为直接插入排序、希尔排序等。
1.直接插入排序
  直接插入排序的一趟操作是将无序区的开头元素R[i] (1<=i<=n-1)插入到有序区R[0...i-1]中的适当位置，使R[0...i-1]变为新的有序区。这种方法通常称为增量法，因为每次使有序区增加一个元素。（通常让待排序序列的第一个元素为有序区，后面的元素为无序区） &emsp;&emsp;关键是如何将无序区第一个元素插入到有序区的适当位置。其过程是先将R[i]暂放到temp中，j(初值i-1)在有序区中从后往前找，（R[j]>temp）凡是大于temp的元素都向后移动一个位置,若R[j]<temp，则将temp放到R[j]后面，R[j+1]=temp。


直接插入排序算法：

import java.util.Arrays;
public class InsertSort{
	public static void main(String[] args){
		int[] array = new int[]{9,8,7,6,5,4,3,2,1};
		insertSort(array);
		System.out.println(Arrays.toString(array));
	}
	public static void insertSort(int[] array){
		for(int i = 1;i<array.length;i++){
			int temp = array[i];
			if(array[i]<array[i-1]){
				int j = i-1;
				while(j>=0&&array[j]>temp){
					array[j+1]=array[j];
					j--;
				}
				array[j+1]=temp;
			}
		}
	}
}

2.希尔排序
  希尔排序也是插入排序的一种，实际上是一种分组插入的方法。基本思想是：设置一个变量d，让d=n/2，将待排序序列分为d个组，将所有距离为d的倍数的元素放到一个组中，然后对每个组进行直接插入排序，然后选取新的增量d=d/2，重复上述操作，直到d=1，即所有元素放在同一个组中进行直接插入排序为止。

希尔排序算法：

import java.util.Arrays;
public class ShelltSort{
	public static void main(String[] args){
		int[] array = new int[]{9,8,7,6,5,4,3,2,1};
		shellSort(array);
		System.out.println(Arrays.toString(array));
	}
	public static void shellSort(int[] array){
		//分组
		for(int d=array.length/2;d>0;d/=2){
			for(int i=d;i<array.length;i++){
				int temp=array[i];
				int j=i-d;
				while(j>=0&&array[j]>temp){
					array[j+d]=array[j];
					j=j-d;
				}
				array[j+d]=temp;
			}
		}
	}
}