一、所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。
二、排序算法可以分为内部排序和外部排序。
内部排序是数据记录在内存中进行排序。
外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
常见的内部排序算法有:冒泡排序, 选择排序,插入排序,希尔排序,快速排序,归并排序等.
当然：实际的排序算法可不止这么一点，如果像了解其他算法可以参考：https://baike.baidu.com/item/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95/5399605?fr=aladdin#3
三、这里主要介绍常见的几种排序算法
1) 冒泡排序low版本
a、冒泡排序，是通过每一次遍历获取最大/最小值
b、将最大值/最小值放在尾部/头部
c、然后除开最大值/最小值，剩下的数据在进行遍历获取最大/最小值
d、代码实现
public class MaoPao { public static void sort(int[] arr){ for (int i = 1; i < arr.length; i++) { //第一层for循环,用来控制冒泡的次数 for (int j = 0; j < arr.length-1; j++) { //第二层for循环,用来控制冒泡一层层到最后 //如果前一个数比后一个数大,两者调换 ,意味着泡泡向上走了一层 if (arr[j] > arr[j+1] ){ int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } }
冒泡的bigger版本
在这个版本中,改动了两点
第一点是加入了一个布尔值,判断第二层循环中的调换有没有执行,如果没有进行两两调换,说明后面都已经排好序了,已经不需要再循环了,直接跳出循环,排序结束.
第二点是第二层循环不再循环到arr.length - 1,因为外面的i循环递增一次,说明数组最后就多了一个排好序的大泡泡.第二层循环也就不需要到最末尾一位了,可以提前结束循环
/** * 终极版冒泡排序 * 加入一个布尔变量,如果内循环没有交换值,说明已经排序完成,提前终止 * @param arr */ public static void sortPlus(int[] arr){ if(arr != null && arr.length > 1){ for(int i = 0; i < arr.length - 1; i++){ // 初始化一个布尔值 boolean flag = true; for(int j = 0; j < arr.length - i - 1 ; j++){ if(arr[j] > arr[j+1]){ // 调换 int temp; temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; // 改变flag flag = false; } } if(flag){ break; } } } }
2）选择排序
a、将第一个值看成最小值
b、然后和后续的比较找出最小值和下标
c、交换本次遍历的起始值和最小值
d、说明：每次遍历的时候，将前面找出的最小值，看成一个有序的列表，后面的看成无序的列表，然后每次遍历无序列表找出最小值。
e、代码实现
public static void main(String[] args) { int arr[] = {6, 5, 3, 2, 4}; //选择 for (int i = 0; i < arr.length; 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; } } //然后将最小值与本次循环的，开始值交换 int temp = arr[i]; arr[i] = min; arr[index] = temp; //说明：将i前面的数据看成一个排好的队列，i后面的看成一个无序队列。每次只需要找无需的最小值，做替换 } }
3）插入排序
a、默认从第二个数据开始比较。
b、如果第二个数据比第一个小，则交换。然后在用第三个数据比较，如果比前面小，则插入（狡猾）。否则，退出循环
c、说明：默认将第一数据看成有序列表，后面无序的列表循环每一个数据，如果比前面的数据小则插入（交换）。否则退出。
d、代码实现
public static void main(String[] args) { int arr[] = {7, 5, 3, 2, 4}; //插入排序 for (int i = 1; i < arr.length; i++) { //外层循环，从第二个开始比较 for (int j = i; j > 0; j--) { //内存循环，与前面排好序的数据比较，如果后面的数据小于前面的则交换 if (arr[j] < arr[j - 1]) { int temp = arr[j - 1]; arr[j - 1] = arr[j]; arr[j] = temp; } else { //如果不小于，说明插入完毕，退出内层循环 break; } } } }
4）希尔排序（插入排序变种版）
a、基本上和插入排序一样的道理
b、不一样的地方在于，每次循环的步长，通过减半的方式来实现
c、说明：基本原理和插入排序类似，不一样的地方在于。通过间隔多个数据来进行插入排序。
d、代码实现
public static void main(String[] args) { int arr[] = {7, 5, 3, 2, 4}; //希尔排序（插入排序变种版） for (int i = arr.length / 2; i > 0; i /= 2) { //i层循环控制步长 for (int j = i; j < arr.length; j++) { //j控制无序端的起始位置 for (int k = j; k > 0 && k - i >= 0; k -= i) { if (arr[k] < arr[k - i]) { int temp = arr[k - i]; arr[k - i] = arr[k]; arr[k] = temp; } else { break; } } } //j,k为插入排序，不过步长为i } }
5)堆排序(后补的)
堆排序时间复杂度(O(nlogn)),不是稳定的排序法.空间复杂度O(1).
关于堆排序可自行在网上搜索详细步骤,这里只是附上代码:
public static void main(String[] args) { int[] arr = {1,3,9,7,3,5,0,25,15,34}; heapSort(arr); for(int i = 0 ; i < arr.length;i++) { System.out.println("排序后: "+arr[i]); } } private static void heapSort(int[] arr) { if(arr == null || arr.length <=1) { return; } //建立最大堆; buildMaxHeap(arr); for(int i = arr.length-1;i>=1;i--) { //最大的在0位置,那么,每次交换最大值放到最后面. swap(arr,0,i); //获取0位置最大值 maxHeap(arr,i,0); } } //创建大堆 private static void buildMaxHeap(int[] arr) { int half = (arr.length-1)/2;//树知道一半,其他的节点就都知道 //从向想上遍历 for(int i = half;i>=0;i--) { //大堆 maxHeap(arr,arr.length,i); } } private static void maxHeap(int[] arr, int heapSize, int index) { int left =2*index+1 ; int right = 2*index+2; int largest = index; if(left < heapSize && arr[left] > arr[index]) { largest = left; } if(right < heapSize && arr[right] > arr[largest]) { largest = right; } if(index != largest) { swap(arr,largest,index); maxHeap(arr,heapSize,largest); } } private static void swap(int[] arr, int index1, int index2) { int temp = arr[index1]; arr[index1] = arr[index2]; arr[index2] = temp; }
6）快速排序
a、确认列表第一个数据为中间值，第一个值看成空缺（低指针空缺）。
b、然后在剩下的队列中，看成有左右两个指针（高低）。
c、开始高指针向左移动，如果遇到小于中间值的数据，则将这个数据赋值到低指针空缺，并且将高指针的数据看成空缺值（高指针空缺）。然后先向右移动一下低指针，并且切换低指针移动。
d、当低指针移动到大于中间值的时候，赋值到高指针空缺的地方。然后先高指针向左移动，并且切换高指针移动。重复c、d操作。
e、直到高指针和低指针相等时退出，并且将中间值赋值给对应指针位置。
f、然后将中间值的左右两边看成行的列表，进行快速排序操作。
g、代码实现
public class Sort { public static void main(String[] args) { int arr[] = {7, 5, 3, 2, 4, 1, 8, 9, 6}; //快速排序 int low = 0; int high = arr.length - 1; quickSort(arr, low, high); } public static void quickSort(int[] arr,int begin,int end) { //先定义两个参数接收排序起始值和结束值 int a = begin; int b = end; //先判断a是否大于b if (a >= b) { //没必要排序 return; } //基准数,默认设置为第一个值 int x = arr[a]; //循环 while (a < b) { //从后往前找,找到一个比基准数x小的值,赋给arr[a] //如果a和b的逻辑正确--a<b ,并且最后一个值arr[b]>x,就一直往下找,直到找到后面的值大于x while (a < b && arr[b] >= x) { b--; } //跳出循环,两种情况,一是a和b的逻辑不对了,a>=b,这时候排序结束.二是在后面找到了比x小的值 if (a < b) { //将这时候找到的arr[b]放到最前面arr[a] arr[a] = arr[b]; //排序的起始位置后移一位 a++; } //从前往后找,找到一个比基准数x大的值,放在最后面arr[b] while (a < b && arr[a] <= x) { a++; } if (a < b) { arr[b] = arr[a]; //排序的终止位置前移一位 b--; } } //跳出循环 a < b的逻辑不成立了,a==b重合了,此时将x赋值回去arr[a] arr[a] = x; //调用递归函数,再细分再排序 quickSort(arr,begin,a-1); quickSort(arr,a+1,end); } }
//另一种表达快排 public static void quickSort(int[] arr) { qsort(arr, 0, arr.length - 1); } private static void qsort(int[] arr, int low, int high) { if (low < high) { int pivot = partition(arr, low, high); // 将数组分为两部分 qsort(arr, low, pivot - 1); // 递归排序左子数组 qsort(arr, pivot + 1, high); // 递归排序右子数组 } } private static int partition(int[] arr, int low, int high) { int pivot = arr[low]; // 枢轴记录 while (low < high) { while (low < high && arr[high] >= pivot) --high; arr[low] = arr[high]; // 交换比枢轴小的记录到左端 while (low < high && arr[low] <= pivot) ++low; arr[high] = arr[low]; // 交换比枢轴小的记录到右端 } // 扫描完成，枢轴到位 arr[low] = pivot; // 返回的是枢轴的位置 return low; }
7）归并排序
a、将列表按照对等的方式进行拆分
b、拆分小最小快的时候，在将最小块按照原来的拆分，进行合并
c、合并的时候，通过左右两块的左边开始比较大小。小的数据放入新的块中
d、说明：简单一点就是先对半拆成最小单位，然后将两半数据合并成一个有序的列表。
e、代码实现
public static void main(String[] args) { int arr[] = {7, 5, 3, 2, 4, 1，6}; //归并排序 int start = 0; int end = arr.length - 1; mergeSort(arr, start, end); } public static void mergeSort(int[] arr, int start, int end) { //判断拆分的不为最小单位 if (end - start > 0) { //再一次拆分，知道拆成一个一个的数据 mergeSort(arr, start, (start + end) / 2); mergeSort(arr, (start + end) / 2 + 1, end); //记录开始/结束位置 int left = start; int right = (start + end) / 2 + 1; //记录每个小单位的排序结果 int index = 0; int[] result = new int[end - start + 1]; //如果查分后的两块数据，都还存在 while (left <= (start + end) / 2 && right <= end) { //比较两块数据的大小，然后赋值，并且移动下标 if (arr[left] <= arr[right]) { result[index] = arr[left]; left++; } else { result[index] = arr[right]; right++; } //移动单位记录的下标 index++; } //当某一块数据不存在了时 while (left <= (start + end) / 2 || right <= end) { //直接赋值到记录下标 if (left <= (start + end) / 2) { result[index] = arr[left]; left++; } else { result[index] = arr[right]; right++; } index++; } //最后将新的数据赋值给原来的列表，并且是对应分块后的下标。 for (int i = start; i <= end; i++) { arr[i] = result[i - start]; } } }
//个人感觉这个更好理解 public static void main(String[] args) { int[] arr = {1,3,9,7,3,5,-3,0,25,15,34}; mergeSort(arr,0,arr.length-1); for(int i = 0 ; i < arr.length;i++) { System.out.println(arr[i]); } } public static void mergeSort(int[] a,int left,int right) { if(left < right) { int middle = (left+right)/2; mergeSort(a,left,middle); mergeSort(a,middle+1,right); merge(a,left,middle,right);//合并 } } private static void merge(int[] a, int left, int middle, int right) { int[] tempArray = new int[a.length]; int rightStart = middle+1; int tmp = left; int index = left; //比较两个小数组相应下标位置数组的大小,小的先放进新数组 while(left <= middle && rightStart <= right) { if(a[left] <= a[rightStart]) { tempArray[index++] = a[left++]; }else { tempArray[index++] = a[rightStart++]; } } while(left <= middle) { //左边剩下的拷贝剩余的数 tempArray[index++] = a[left++]; } while(rightStart <= right) { //拷贝剩余的数 tempArray[index++] = a[rightStart++]; } while(tmp <= right) { a[tmp] = tempArray[tmp++]; } }
7)其他排序
比如Arrays工具类提供的排序方法。它内部实现也是快速排序
private static void arraysSort(int[] a){ Arrays.sort(a); }
还有就是将数组转为list,使用集合的排序方法,但是这无异于兜圈子,因为集合底层也是数组
private static void listSort(int[] a){ List<Integer> integers = Ints.asList(a); Collections.sort(integers); integers.toArray(new Integer[a.length]); }