一.冒泡排序
基本思想:通过对待排序序列此前向后,依次比较相邻元素的值,若发现逆序则进行交换,使得较大的值从前面移动到后面,
类似于水下的气泡一样(是所有排序算法中效率最低的)
public static void BobbleSort(int[] arr){ /*冒泡排序,时间复杂度为O(n^2)*/ if (arr == null || arr.length == 0){ return; } int temp = 0; // 临时变量,用于存放大的数 boolean flag = false; // 是否进行过交换,默认为false for (int i = 0; i < arr.length-1;i++){ //需要遍历的次数 for (int j = 0; j < arr.length-1-i;j++){ //遍历数组中的值,来比较 if (arr[j] > arr[j+1]){ // 如果后面的数比前面的数要大,则进行交换 flag = true;// temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } if (!flag){ // 如果flag==false,表示没有进行过交换,直接退出即可 break; }else{ flag = false; // 要将flag重置,进行下一次的判断 } } } }
测试,使用80000个随机数来进行测试
public static void main(String[] args) { int[] array = createRandomArr(80000); showTime("排序开始时间"); BobbleSort(array); showTime("排序结束时间"); } public static void showTime(String str){ Date d = new Date(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String dStr = sdf.format(d); System.out.println(str+": "+dStr); } public static int[] createRandomArr(int n){ int[] arr = new int[n]; for (int i = 0; i < n; i++) { arr[i] = (int)(Math.random() * 800000); } return arr; }
执行结果: 排序耗时9秒
二.选择排序
基本思想:第一次从arr[0]~arr[n-1]中选出最小值和arr[0]进行交换,第二次从a[1]~a[n-1]选出最小值和a[1]进行交换,第三次从a[2]~a[n-1]选出
最小值和a[2]进行交换,直到执行n-1次,得到一个排序码从小到大的有序序列
public static void selectSort(int[] arr){ /*选择排序*/ if (arr.length == 0 || arr == null){return;} int minIndex = 0; int minValue = 0; for (int i = 0; i < arr.length-1; i++) { minIndex = i; // 记录最小值的下标,从0开始 minValue = arr[i]; // 记录最小值,假设是a[0]开始 for (int j = i+1; j < arr.length;j++){ // 从i后开始循环 if (minValue > arr[j]){ // 如果最小的值,并不是a[i],重置minIndex和minValue minValue = arr[j]; // 获取最小值,和最小值的下标 minIndex = j; } } // 将最小的值放在a[i],比较并进行交换 if (minIndex != i){ arr[minIndex] = arr[i]; // 把a[0]第一个值先放在a[minIndex]处 arr[i] = minValue; // 把保存下来的最小值回填到a[0],即找到了全局的最小值 } } }
测试,使用80000个随机数来进行测试
执行结果: 排序耗时2秒
三.插入排序
基本思想:把n个待排列的元素看成一个有序表和一个无序表,开始时有序表中只包含一个元素,无序表中包含n-1个元素,排序过程中每次从无序表中抽取
第一个元素,将它的排序码依次与有序表元素的排序码进行比较,将其插入到有序表中的适当的位置,成为新的有序表
public static void insertSort(int[] array){ /*插入排序*/ if (array.length == 0 || array == null){return;} int insertVal = 0; int insertIdx = 0; for (int i = 1; i < array.length; i++) { // 定义待插入的数 insertVal = array[i];// 从第二个数开始和第一个数进行比较 insertIdx = i -1; // 第一个数的下标 // 给insertVal找到合适的位置 // 1.insertIdx >=0保证给insertVal插入的位置不越界 // 2.insertVal < array[insertIdx] 找到了待插入的数 // 3.需要将arr[insertIdx]后移 while (insertIdx >=0 && insertVal < array[insertIdx]){ array[insertIdx+1] = array[insertIdx]; insertIdx--; } // 退出while循环时候说明数已经找到,只要把保留下来的数放到前面即可 if (insertIdx+1 != i){ array[insertIdx+1] = insertVal; } } }
测试,使用80000个随机数来进行测试
执行结果: 排序耗时不到1秒
四.希尔排序
基本思想:当插入排序插入的数较小时,会导致频繁移动数组导致执行效率低下,希尔排序是一种优化的插入排序.它将数据按下标的一定增量分组
对每组直接进行简单插入排序,随着增量逐渐减少,每组包含的关键词就越多,当增量减少到1时,所有的数据都已排序完毕
public static void shellSort2(int[] arr){ /*使用移位法进行希尔排序*/ if (arr.length == 0 || arr == null){ return; } int minVal = 0; // 记录最小值 int minIdx = 0; // 记录最小值的下标 for (int gap = arr.length/2; gap >0 ; gap/=2) { // 每次缩小遍历次数增量 每次折半,缩小增量 for (int i = gap; i < arr.length; i++) { // 从gap个位置,逐步对其所在的元素进行插入排序 minVal = arr[i]; // 假定最小值是arr[i] minIdx = i; // 记录i //1.minIdx-gap >=0 确保插入的位置不会越界 //2.minVal < arr[minIdx-gap] 找到了待插入的数 while (minIdx-gap >=0 && minVal < arr[minIdx-gap]){ // 同插入排序 arr[minIdx] = arr[minIdx-gap]; minIdx-=gap; } arr[minIdx] = minVal; } } }
测试,使用80000个随机数来进行测试
执行结果: 排序耗时不到1秒
五.快速排序
基本思想:通过一趟排序将要排序的数据分割成独立的两个部分,其中一部分的数据比另一部分的数据都要小,然后在按照此方法对这两部分数据
进行快速排序,整个排序通过递归实现,以此达到整个数据排列有序
/** * 快速排序 * @param arr 需要排序的数组 * @param left 左索引 * @param right 右索引 */ public static void quickSort(int[] arr,int left,int right){ if (arr.length == 0 || arr == null){return;} int l = left; int r = right; int temp = 0; // 作为交换的临时变量 int pivot = arr[(left+right)/2]; // 找到数组中间的值 //while循环让比pivot值小的放在左边,比pivot值大的放在右边 while (l<r){ //在pivot的左边一直找,直到找到比pivot大的值就退出 while (arr[l] < pivot){ l+=1; } //在pivot的右边一直找,直到找到比pivot小的值就退出 while (arr[r] > pivot){ r-=1; } // 如果l>=r说明左右两边的值已经按照左边全是小于pivot,右边都是大于pivot的值来存放 if (l >= r){ break; } //交换 temp = arr[l]; arr[l] = arr[r]; arr[r] = temp; // 如果交换完成后,发现pivot == arr[l],需要将r--,前移 if (arr[l] == pivot){ r-=1; } // 如果交换完成后,发现pivot == arr[r],需要将l++,后移 if (arr[r] == pivot){ l+=1; } } // 如果出现 l==r,必须要把l++,r--,否则会出现栈溢出 if (l == r){ l+=1; r-=1; } // 向左递归 if (left < r){ quickSort(arr,left,r); } // 向右递归 if (right > l){ quickSort(arr,l,right); } }
测试,使用80000个随机数来进行测试
执行结果: 排序耗时不到1秒
六.归并排序
基本思想:是利用归并的思想实现的排序的算法,该算法采用经典的分治策略.
/** * 分割 * @param arr 原数组 * @param left 左下标 * @param right 右下标 * @param temp 临时数组 */ public static void mergeSort(int[] arr,int left,int right,int[] temp){ if (left < right){ int mid =( left+right )/2; // 向左递归 mergeSort(arr,left,mid,temp); // 向右递归 mergeSort(arr,mid+1,right,temp); // 合并 merge(arr,left,mid,right,temp); } } /** * 合并 * @param arr 需要排序的原始数组 * @param left 左边有序序列的初始索引 * @param mid 中间索引 * @param right 右边有序序列的初始索引 * @param temp 临时数组 */ public static void merge(int[] arr,int left,int mid,int right,int[] temp){ int i = left; // 初始化i,左边有序序列的初始索引 int j = mid + 1; // 初始化j,右边有序序列的初始索引 int t = 0; // 临时数组的索引 /*1.将左右两边的有序数据按照规则填充到temp中,直到左右两边的有序序列有一边处理完为止*/ while (i <= mid && j <= right){ // 继续 if (arr[i] <= arr[j]){ //如果左边的有序序列当前的元素小于右边有序序列当前的元素 temp[t] = arr[i]; // 将左边有序序列的元素填充到temp中 t+=1; i+=1; }else{ //如果右边的有序序列当前的元素小于左边有序序列当前的元素 temp[t] = arr[j];// 将右边有序序列的元素填充到temp中 t+=1; j+=1; } } /*2.把剩余的数据的一边依次全部填充到temp中*/ while (i<=mid){ // 左边的有效数据还有剩余就全部填充到temp中 temp[t] = arr[i]; t+=1; i+=1; } while (j <= right){ // 右边的有效数据还有剩余就全部填充到temp中 temp[t] = arr[j]; t+=1; j+=1; } /*3.将temp数组的元素拷贝到arr中,每次都要拷贝*/ t = 0; // t要清空 int tempLeft = left; while (tempLeft <= right){ arr[tempLeft] = temp[t]; t+=1; tempLeft+=1; } }
测试,使用80000个随机数来进行测试
执行结果: 排序耗时不到1秒
七.基数排序
基本思想:将所有待比较的数统一为同样的数位长度,数位较短的数前补零.然后从最低位开始,依次进行一次排序.这样从最低位排序一直到最高位排序完成后
数列就成了有序序列了.
public static void radixSort(int arr[]){ /*基数排序算法*/ if (arr.length == 0 || arr == null ){ return; } /*1.找出数组中的最大的数*/ int max = arr[0]; for (int ele : arr) { if(ele > max){ max = ele; } } /*2.确定最大数的长度,确定桶排序的循环次数*/ int maxLength = (max+"").length(); /*定义一个二维数组表示10个桶,每个桶就是一个一维数组 * 1.二维数组中包含10个一维数组 * 2.为了防止放数据导致数据溢出,则每一个一维桶的长度是arr.length * */ int[][] bucket = new int[10][arr.length]; /*记录每个桶中存放的有效数据的个数 * 比如:bucketElementCount[0],记录的就是bucket[0]中元素的个数 * */ int[] bucketElementCount = new int[10]; // n表示对数据的位数进行处理,第一次个位,第二次十位,第三次百位,以此类推 for (int i = 0,n=1; i < maxLength; i++,n*=10) { for (int j = 0; j < arr.length; j++) { // 取出每个数对应的位数 int digitOfElement = arr[j] / n % 10; // 放入到对应的桶中 bucket[digitOfElement][bucketElementCount[digitOfElement]] = arr[j]; bucketElementCount[digitOfElement]++; // 每一个桶的记录数递增 } /* 按照桶的顺序,放回到原来的数组*/ int index = 0; //遍历每一个桶,并将桶的数据放回到原数组 for (int k = 0; k < bucketElementCount.length; k++) { // 如果桶中有数据,才放入 if (bucketElementCount[k] != 0){ // 循环第k个桶,放入 for (int l = 0; l < bucketElementCount[k]; l++) { // 取出元素放入到原数组中 arr[index++] = bucket[k][l]; } } // 每次处理完成后,一定要记得将bucketElementCount[k]清空 bucketElementCount[k] = 0; } } }
测试,使用80000个随机数来进行测试
执行结果: 排序耗时不到1秒
八.堆排序
基本思想:将待排序的序列构造成一个大顶堆.此时整个序列的最大值就是堆顶的根节点,把它和末尾的元素进行交换.此时末尾的元素就成了最大值.然后将剩余n-1个元素重新构造成一个
堆.如此反复执行就能到一个有序的序列
/** * 把一个二叉树,调整为大顶堆 * @param array 待调整的数组 * @param i 表示非叶子节点在数组中的索引 * @param length 表示有多少个元素要调整,length逐渐在减少 */ public static void adjustHeap(int[] array,int i,int length){ /*取出当前元素的值,保存在临时变量中*/ int temp = array[i]; /*开始进行调整*/ /* k=2*i+1,k是i的左子节点*/ for (int k = 2*i+1;k < length; k = k*2+1){ /*如果左子节点的值小于右子节点的值*/ if (k+1 < length && array[k] < array[k+1]){ k++; // k指向右子节点 } /*如果子节点大于父节点*/ if (temp < array[k]){ /*把较大的值赋给当前节点*/ array[i] = array[k]; /*i指向k,继续循环比较*/ i = k; }else { break; } } /*当循环结束后,已经把i为父节点的数的最大值放在了顶部,所以此时把temp的值放在调整后的位置*/ array[i] = temp; }
public static void heapSort(int[] array){ if (array.length == 0 || array == null){ System.out.println("数组为空,不能排序"); return; } int temp = 0; /*把一个无序的序列构建成一个堆,根据升序和降序选择大顶堆还是小顶堆*/ for (int i = array.length/2-1; i >= 0; i--) { adjustHeap(array,i,array.length); } /** * 1.将堆顶的元素和堆底的元素进行交换,把最大的元素放在数组的尾部 * 2.重新调整结构,然后继续交换堆顶元素和当前末尾元素,反复执行,使得数组有序 */ for (int j = array.length-1; j > 0; j--) { /*交换*/ temp = array[j]; array[j] = array[0]; array[0] = temp; adjustHeap(array,0,j); } }
测试,使用80000个随机数来进行测试
执行结果: 排序耗时不到1秒
八大排序算法的时间复杂度,空间复杂的比较
