基本思想：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。 算法描述： 1.从第一个元素开始，可以认定第一个元素已经排好序了。 2.取出下一个元素，从以排好序的元素中从后向前扫描。 3.如果该元素（已排序）大于待排序元素，则将该元素及其后面的元素向后移，直到找到合适的位置。 4.将待排序元素插入到该位置。 5.重复步骤（2-4）。 动图演示： 算法实现：
/** * 插入排序 * @param a */ public static void insertSort(int[] a){ int insertNum; // 要插入的数 for (int i = 1; i < a.length; i++){ // 因为第一次不用，所以从1开始 insertNum = a[i]; int j = i - 1; // 序列元素个数 while(j > 0 && a[j] > insertNum){ // 从后往前循环，将大于insertNum的数向后移动 a[j + 1] = a[j]; // 元素向后移动 j--; } a[j + 1] = insertNum; // 找到位置，插入当前元素 } }基本思想：它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。 算法描述： 1.比较相邻的两个元素，如果第一个比第二个大则交换。 2.对每一组元素做相同的操作，到最后的一个元素为所有元素的最大值。 3.对后面的所有元素重复上面的操作，除了最后一个元素。 4.重复以上步骤，直到完成。 动图演示： 算法实现：
//冒泡排序 public static void bubbleSort(int []a){ for(int i=0;i<a.length;i++){ for(int j=0;j<a.length-i-1;j++){ //注意第二重循环的条件 if(a[j]>a[j+1]){ //不符合则交换 int temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; } } } }基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 算法描述： 1.选择一个基准元素，通常为第一个和最后一个。 2.通过一趟排序将要待排序的数组分成两个部分，其中一部分的元素都比基准元素小，一部分都比基准元素大。 3.此时基准元素在其正确位置。 4.然后对这两部分记录用同样的方法进行排序，直到整个序列有序。 动图演示： 算法实现：
//快速排序 public static void quickSort(int[]a,int start,int end){ if(start<end){ int baseNum=a[start];//选基准值 int midNum;//记录中间值 int i=start; int j=end; do{ while((a[i]<baseNum)&&i<end){ i++; } while((a[j]>baseNum)&&j>start){ j--; } if(i<=j){ midNum=a[i]; a[i]=a[j]; a[j]=midNum; i++; j--; } }while(i<=j); if(start<j){ quickSort(a,start,j); } if(end>i){ quickSort(a,i,end); } } }基本思想：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。 算法描述： 1.将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区。 2.将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]； 3.由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。 动图演示： 算法实现：
/** * 堆排序 * @param a */ public void heapSort(int[] a) { int len = a.length; // 循环建堆 for (int i = 0; i < len - 1; i++) { // 建堆 buildMaxHeap(a, len - 1 - i); // 交换堆顶和最后一个元素 swap(a, 0, len - 1 - i); } } // 交换方法 private void swap(int[] data, int i, int j) { int tmp = data[i]; data[i] = data[j]; data[j] = tmp; } // 对data数组从0到lastIndex建大顶堆 private void buildMaxHeap(int[] data, int lastIndex) { // 从lastIndex处节点（最后一个节点）的父节点开始 for (int i = (lastIndex - 1) / 2; i >= 0; i--) { // k保存正在判断的节点 int k = i; // 如果当前k节点的子节点存在 while (k * 2 + 1 <= lastIndex) { // k节点的左子节点的索引 int biggerIndex = 2 * k + 1; // 如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在 if (biggerIndex < lastIndex) { // 若果右子节点的值较大 if (data[biggerIndex] < data[biggerIndex + 1]) { // biggerIndex总是记录较大子节点的索引 biggerIndex++; } } // 如果k节点的值小于其较大的子节点的值 if (data[k] < data[biggerIndex]) { // 交换他们 swap(data, k, biggerIndex); // 将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值 k = biggerIndex; } else { break; } } } }基本思想： 分而治之(divide - conquer);每个递归过程涉及三个步骤 第一, 分解: 把待排序的 n 个元素的序列分解成两个子序列, 每个子序列包括 n/2 个元素. 第二, 治理: 对每个子序列分别调用归并排序MergeSort, 进行递归操作 第三, 合并: 合并两个排好序的子序列,生成排序结果. 算法描述： 参考上 动图演示： 实例： 算法实现：
public void mergeSort(int[] a, int left, int right) { int t = 1;// 每组元素个数 int size = right - left + 1; while (t < size) { int s = t;// 本次循环每组元素个数 t = 2 * s; int i = left; while (i + (t - 1) < size) { merge(a, i, i + (s - 1), i + (t - 1)); i += t; } if (i + (s - 1) < right) merge(a, i, i + (s - 1), right); } } private static void merge(int[] data, int p, int q, int r) { int[] B = new int[data.length]; int s = p; int t = q + 1; int k = p; while (s <= q && t <= r) { if (data[s] <= data[t]) { B[k] = data[s]; s++; } else { B[k] = data[t]; t++; } k++; } if (s == q + 1) B[k++] = data[t++]; else B[k++] = data[s++]; for (int i = p; i <= r; i++) data[i] = B[i]; }基本思想： 基数排序也是非比较的排序算法，对每一位进行排序，从最低位开始排序，复杂度为O(kn),为数组长度，k为数组中的数的最大的位数； 基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。 算法描述： 1.取得数组中的最大数，并取得位数； 2.arr为原始数组，从最低位开始取每个位组成radix数组； 3.对radix进行计数排序（利用计数排序适用于小范围数的特点）； 动图演示： 算法实现：
public void baseSort(int[] a) { //首先确定排序的趟数; int max = a[0]; for (int i = 1; i < a.length; i++) { if (a[i] > max) { max = a[i]; } } int time = 0; //判断位数; while (max > 0) { max /= 10; time++; } //建立10个队列; List<ArrayList<Integer>> queue = new ArrayList<ArrayList<Integer>>(); for (int i = 0; i < 10; i++) { ArrayList<Integer> queue1 = new ArrayList<Integer>(); queue.add(queue1); } //进行time次分配和收集; for (int i = 0; i < time; i++) { //分配数组元素; for (int j = 0; j < a.length; j++) { //得到数字的第time+1位数; int x = a[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i); ArrayList<Integer> queue2 = queue.get(x); queue2.add(a[j]); queue.set(x, queue2); } int count = 0;//元素计数器; //收集队列元素; for (int k = 0; k < 10; k++) { while (queue.get(k).size() > 0) { ArrayList<Integer> queue3 = queue.get(k); a[count] = queue3.get(0); queue3.remove(0); count++; } } } }基本思想： 先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。 算法描述： 1.选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1； 2.按增量序列个数k，对序列进行k 趟排序； 3.每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。 动图演示： 算法实现：
public void sheelSort(int [] a){ int len=a.length;//单独把数组长度拿出来，提高效率 while(len!=0){ len=len/2; for(int i=0;i<len;i++){//分组 for(int j=i+len;j<a.length;j+=len){//元素从第二个开始 int k=j-len;//k为有序序列最后一位的位数 int temp=a[j];//要插入的元素 /*for(;k>=0&&temp<a[k];k-=len){ a[k+len]=a[k]; }*/ while(k>=0&&temp<a[k]){//从后往前遍历 a[k+len]=a[k]; k-=len;//向后移动len位 } a[k+len]=temp; } } } }基本思想： 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 算法描述： n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下： 1.初始状态：无序区为R[1..n]，有序区为空； 2.第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区； 3.n-1趟结束，数组有序化了。
动图演示： 算法实现：
public void selectSort(int[]a){ int len=a.length; for(int i=0;i<len;i++){//循环次数 int value=a[i]; int position=i; for(int j=i+1;j<len;j++){//找到最小的值和位置 if(a[j]<value){ value=a[j]; position=j; } } a[position]=a[i];//进行交换 a[i]=value; } }