冒泡排序
比较两个相邻的元素，将值大的元素交换到右边
实现代码：
/** * 冒泡排序 * @param array */ public static void bubbleSort(int[] array){ for(int i=0;i<array.length-1;i++){ //比较后的就不在比较了，所以是length-1-i次 for(int j=0;j<array.length-1-i;j++){ if(array[j]>array[j+1]){ int t = array[j]; array[j] = array[j+1]; array[j+1] = t; } } } System.out.println(Arrays.toString(array)); }
插入排序
把n个元素的数列分成有序（前）和无序（后）的两部分，每次处理就是将无序的数列中第一个元素与有序数列的元素从后到前比较，找到插入位置，将该元素插入到有序数列的适当的最终的位置上（稳定排序）。
实现代码：
public static void insertSort(int[] arr){ //进行循环 for(int i=1;i<arr.length;i++){ //如果当前数字比前一个数字小 if(arr[i]<arr[i-1]){ //把当前遍历的数字存储起来 int temp = arr[i]; //遍历当前位置之前的所有值 int j; for(j=i-1;j>=0&&temp<arr[j];j--){ //把前一个数字赋给后一个数字 arr[j+1] = arr[j]; } //把临时值放入不满足条件的位置 arr[j+1] = temp; } } }
选择排序
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。
实现代码：
public static void chooseSort(int[] arr){ //从第一位开始循环 for(int i = 0;i<arr.length;i++){ int temp = arr[i]; //最小值的下标； int t = i; //开始循环之后所有值 for(int j=i+1;j<arr.length;j++){ //如果有比temp小的，记录最小值以及最小值位置 if(arr[j]<temp){ temp = arr[j]; t = j; } } arr[t] = arr[i]; arr[i] = temp; } }
希尔排序
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
实现代码：
public static void shellSort(int[] arr){ //遍历所有的步长 for(int d=arr.length/2;d>0;d/=2){ //遍历所有元素 for(int i=d;i<arr.length;i++){ //遍历本组中所有元素 for(int j=i-d;j>=0;j-=d){ //如果当前元素大于加上步长后的那个元素 if(arr[j]>arr[j+d]){ int temp = arr[j]; arr[j] = arr[j+d]; arr[j+d] = temp; } } } } }
基数排序
基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。
代码实现：
public static void radixSort(int[] arr){ //获取数组中最大的数字 int max = Integer.MIN_VALUE; for(int i=0;i<arr.length;i++){ if(arr[i]>max){ max = arr[i]; } } //计算最大数字是几位 int maxLength = (max+"").length(); //用于存放临时数据的数组 int[][] temp = new int[10][arr.length]; //用于记录在temp中对应的数组中存放的数字的数量 int[] counts = new int[10]; //根据最大长度的数决定比较的次数 for(int i=0,n=1;i<maxLength;i++,n*=10){ //把每个数字都分别计算余数 for(int j=0;j<arr.length;j++){ //计算余数 int ys = (arr[j]/n)%10; //把当前遍历的数据放入指定的数组中 temp[ys][counts[ys]] = arr[j]; //记录数量 counts[ys]++; } //记录取出的元素需要放的位置 int index = 0; //把数字取出来 for(int k=0;k<counts.length;k++){ //记录数量的数组中当前余数记录的数量不为0 if(counts[k]!=0){ //循环取出数组 for(int x =0;x<counts[k];x++){ //取出元素 arr[index] = temp[k][x]; //记录下一个位置 index++; } //把数量置空 counts[k] = 0; } } } }
归并排序
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。
实现代码：
/** * @Description: 递归 */ public static void mergeSort(int[] arr,int low,int high){ if(low<high){ int middle = (high+low)/2; mergeSort(arr,low,middle); mergeSort(arr,middle+1,high); marge(arr,low,middle,high); } } public static void marge(int[] arr,int low,int middle,int high){ //递归的临时数组 int[] tempArr = new int[high-low+1]; //记录左边的下标 int i = low; //记录右边的下标 int j = middle+1; //记录初始index int index = 0; //开始同时遍历俩个数组 while(i<=middle&&j<=high){ //如果左边的比右边的小，把小的放入临时数组中，左边指针向右移动一位 if(arr[i]<arr[j]){ tempArr[index] = arr[i]; i++; }else { tempArr[index] = arr[j]; j++; } index++; } //左边的遍历完之后，把剩余的放入临时数组 while(i<=middle){ tempArr[index] = arr[i]; i++; index++; } //右边的遍历完之后，把剩余的放入临时数组 while(j<=high){ tempArr[index] = arr[j]; j++; index++; } //把临时数组中的值放到arr中 for(int t=0;t<tempArr.length;t++){ arr[t+low] = tempArr[t]; } }
快速排序
设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选快排图用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
实现代码：
public class QuickSort { public static void main(String[] args) { int[] arrays = new int[]{2,4,2,1,7,4,8,9}; quickSort(arrays,0,arrays.length-1); System.out.println(Arrays.toString(arrays)); } public static void quickSort(int[] arrays,int start,int end){ if(start<end){ //把数组中的第0个数字作为标准数 int stard = arrays[start]; //记录需要排序的下标 int low = start; int high = end; //循环查找比标准数大的数和比标准数小的数 while(low<high){ //右边的数字比标准数大，移动下标 while(low<high&&stard<=arrays[high]){ high--; } //如果右边的数字比标准数小，使用右边的数字替换左边的数字 arrays[low] = arrays[high]; //如果左边的数字比标准数小，移动下标 while(low<high&&arrays[low]<=stard){ low++; } //如果左边的数字比标准数大，使用左边的数字替换右边的数字 arrays[high] = arrays[low]; } //把标准数据给分割位置 arrays[low]=stard; //处理所有小的数字 quickSort(arrays,start,low); //处理所有大的数字 quickSort(arrays,low+1,end); } } }
堆排序