经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】

经典十大排序算法【Java版完整代码】

  • 写在前面的话
  • 十大排序算法对比
  • 冒泡排序
  • 快速排序
  • 直接选择排序
  • 堆排序
  • 归并排序
  • 插入排序
  • 希尔排序
  • 计数排序
  • 桶排序
  • 基数排序
  • 完整测试类

写在前面的话

       虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助，每天进步一点点！！！

       我用通俗的理解写下对算法的解释，对某个算法的运行过程不是很理解的话或者想看比较官方的解释的话，单独搜索某个算法，看几篇不同的解释，就可以有自己的理解了，这里我主要展示代码以及进行通俗的解释！整起来，再强调一次，一定要自己敲一遍，这样才能理解的更深刻！

十大排序算法对比

在这里插入图片描述

关于最后一列的稳定性，我稍微解释下，例如对序列：1 2 4 2 6 排序，序列中存在两个2，如果我们把这两个2标记上（让他俩不同），排序之后，前面的2还在前面，那么就称这种排序是稳定的，反之不稳定。

冒泡排序

简单解释：
       原理就如算法名字一样，就像水中的气泡一样，每次我都把最大的或最小的放到最后面，这样总共需要n-1趟即可完成排序，这就是第一层循环，第二次循环就是遍历未被固定的那些数（理解成数组左边的数，因为每层循环都会把最大或最小的数升到最右边固定起来，下次就不遍历这些数了），两层循环遍历结束后，所有的数就排好序了。
       两层循环所以冒泡排序算法的时间复杂度是O( n 2 n^{2} n2)，是一个非常高的时间复杂度，我在下面的代码进行了优化，加了一个标志位，如果上一次循环未发生交换，就说明已经是有序的了，就不继续下去了，反之继续进行下一轮。

本文的图片来源网络，仅用于大家学习，侵权联系删除！（下同）

完整代码：

package com.keafmd.Sequence;/*** Keafmd** @ClassName: BubbleSort* @Description: 冒泡排序* @author: 牛哄哄的柯南* @date: 2021-06-24 10:31*/
public class BubbleSort {//冒泡排序public static void bubbleSort(int[] arr, boolean ascending) { //exchange标志表示为升序排序还是降序排序boolean flag = true; //加一个标志位，记录上一次是否发生了交换，如果是，我们则进行下一轮，如果没有，说明已经冒泡好了for (int i = 1; i < arr.length && flag; i++) { //控制次数，第几趟排序，只需要n-1趟，有交换时进行，只有flag=false就说明上一次一个元素都没有进行交换/*System.out.print("第"+i+"次遍历：");for (int i1 : arr) {System.out.print(i1+" ");}System.out.println();*/flag = false; //假定未交换for (int j = 0; j < arr.length - i; j++) {if (ascending ? arr[j] > arr[j + 1] : arr[j] < arr[j + 1]) { //控制升序还是降序int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;flag = true;}}}}//冒泡排序 -- 默认不传参升序public static void bubbleSort(int[] arr) {bubbleSort(arr, true);}
}

测试代码：

升序排序（从小到大）

package com.keafmd.Sequence;import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;/*** Keafmd** @ClassName: Sort* @Description: 十大排序算法* @author: 牛哄哄的柯南* @date: 2021-06-16 21:27*/
public class Sort {public static void main(String[] args) {int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};int[] temparr;//测试冒泡排序System.out.println("测试冒泡排序:");temparr = nums.clone();BubbleSort.bubbleSort(temparr);//逆序排序//BubbleSort.bubbleSort(temparr,false);for (int i = 0; i < temparr.length; i++) {System.out.print(temparr[i] + " ");}System.out.println();}
}

运行结果：

测试冒泡排序:
-66 -13 -1 1 4 9 12 25 25 26 34 47 58 99 162 10093

降序排序（从大到小）

//测试冒泡排序
System.out.println("测试冒泡排序:");
temparr = nums.clone();
BubbleSort.bubbleSort(temparr,false);
for (int i = 0; i < temparr.length; i++) {System.out.print(temparr[i] + " ");
}
System.out.println();

运行结果：

测试冒泡排序:
10093 162 99 58 47 34 26 25 25 12 9 4 1 -1 -13 -66

下面几个算法的测试也就是换了下类名和方法名（换成相应的排序算法），如果想降序就在数组后面传个false即可。我就不一一复制了，我在最下面给出含所有算法的测试类，需要的自取即可。

快速排序

简单解释：
快速排序就是每次找一个基点（第一个元素），然后两个哨兵，一个从最前面往后走，一个从最后面往前面走，如果后面那个哨兵找到了一个比基点大的数停下来，前面那个哨兵找到比基点大的数停下来，然后交换两个哨兵找到的数，如果找不到最后两个哨兵就会碰到一起就结束，最后交换基点和哨兵相遇的地方的元素，然后就将一个序列分为比基点小的一部分和比基点大的一部分，然后递归左半部分和右半部分，最后的结果就是有序的了。

完整代码：

package com.keafmd.Sequence;/*** Keafmd** @ClassName: QuickSort* @Description: 快速排序* @author: 牛哄哄的柯南* @date: 2021-06-24 10:32*/
public class QuickSort {//快速排序public static void quickSort(int[] arr) {quickSort(arr, true);}public static void quickSort(int[] arr, boolean ascending) {if (ascending) {quickSort(arr, 0, arr.length - 1, true);} else {quickSort(arr, 0, arr.length - 1, false);}}public static void quickSort(int[] arr, int begin, int end, boolean ascending) {if (ascending)quickSort(arr, begin, end);elsequickSortDescending(arr, begin, end);}//快排序升序 -- 默认public static void quickSort(int[] arr, int begin, int end) {if (begin > end) { //结束条件return;}int base = arr[begin];int i = begin, j = end;while (i < j) { // 两个哨兵（i左边，j右边）没有相遇while (arr[j] >= base && i < j) { //哨兵j没找到比base小的j--;}while (arr[i] <= base && i < j) { //哨兵i没找到比base大的i++;}if (i < j) { //如果满足条件则交换int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}//最后将基准为与i和j相等位置的数字交换arr[begin] = arr[i];arr[i] = base;quickSort(arr, begin, i - 1); //递归调用左半数组quickSort(arr, i + 1, end); //递归调用右半数组}//快排序降序public static void quickSortDescending(int[] arr, int begin, int end) {if (begin > end) { //结束条件return;}int base = arr[begin];int i = begin, j = end;while (i < j) { // 两个哨兵（i左边，j右边）没有相遇while (arr[j] <= base && i < j) { //哨兵j没找到比base大的j--;}while (arr[i] >= base && i < j) { //哨兵i没找到比base小的i++;}if (i < j) { //如果满足条件则交换int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}//最后将基准为与i和j相等位置的数字交换arr[begin] = arr[i];arr[i] = base;quickSortDescending(arr, begin, i - 1); //递归调用左半数组quickSortDescending(arr, i + 1, end); //递归调用右半数组}}

直接选择排序

简单解释：
数组分为已排序部分（前面）和待排序序列（后面）
第一次肯定所有的数都是待排序的
从待排序的序列中找到最大或最小的那个元素，放到前面的已排序部分，然后一直找，不断缩小待排序的范围，直到所有的数都是已排序的了

完整代码：

package com.keafmd.Sequence;/*** Keafmd** @ClassName: SelectSort* @Description: 选择排序* @author: 牛哄哄的柯南* @date: 2021-06-24 10:33*/
public class SelectSort {//直接选择排序public static void selectSort(int[] arr, boolean ascending) {for (int i = 0; i < arr.length; i++) {int m = i; //最小值或最小值的下标for (int j = i + 1; j < arr.length; j++) {if (ascending ? arr[j] < arr[m] : arr[j] > arr[m]) {m = j; //找到待排序的数中最小或最大的那个数，记录下标}}//交换位置int temp = arr[i];arr[i] = arr[m];arr[m] = temp;}}public static void selectSort(int[] arr) {selectSort(arr, true);}
}

堆排序

先理解下大顶堆和小顶堆，看图
大顶堆，双亲结点的值比每一个孩子结点的值都要大。根结点值最大
小顶堆，双亲结点的值比每一个孩子结点的值都要小。根结点值最小

简单解释：
构建好大顶堆或小顶堆结构，这样最上面的就是最大值或最小值，那么我们取出堆顶元素，然后重新构建结构，一直取，一直重新构建，那么最后达到排序的效果了。

完整代码：

package com.keafmd.Sequence;/*** Keafmd** @ClassName: HeapSort* @Description: 堆排序* @author: 牛哄哄的柯南* @date: 2021-06-24 10:34*/
public class HeapSort {//堆排序public static void heapSort(int[] arr) {//对传入的数组进行建立堆，这里默认建立大顶堆，进行升序排列heapSort(arr, true);}public static void heapSort(int[] arr, boolean maxheap) {//1.构建大顶堆for (int i = arr.length / 2 - 1; i >= 0; i--) {//从第一个非叶子结点从下至上，从右至左调整结构sift(arr, i, arr.length , maxheap);}//2.调整堆结构+交换堆顶元素与末尾元素for (int j = arr.length - 1; j > 0; j--) {//现在的数组第一个就是根结点，最小值所在，进行交换，把它放到最右边int temp = arr[j];arr[j] = arr[0];arr[0] = temp;//重新建立堆sift(arr, 0, j , maxheap); //重新对堆进行调整}}//建立堆的方法/*** 私有方法，只允许被堆排序调用** @param arr     要排序数组* @param parent  当前的双亲节点* @param len     数组长度* @param maxheap 是否建立大顶堆*/private static void sift(int[] arr, int parent, int len, boolean maxheap) {int value = arr[parent]; //先取出当前元素ifor (int child = 2 * parent + 1; child < len; child = child * 2 + 1) { //从parent结点的左子结点开始，也就是2*parent+1处开始if (child+1 < len && (maxheap ? arr[child] < arr[child + 1] : arr[child] > arr[child + 1])) { //如果左子结点小于右子结点，child指向右子结点child++; //右孩子如果比左孩子大，我们就将现在的孩子换到右孩子}//判断是否符合大顶堆的特性， 如果右孩子大于双亲，自然左孩子也大于双亲，符合//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换)if (maxheap ? value < arr[child] : value > arr[child]) {arr[parent]=arr[child];parent = child;}else {//如果不是，说明已经符合我们的要求了。break;}}arr[parent] =value; //将value值放到最终的位置}}

归并排序

简单解释：
该算法是采用分治法，把数组不断分割，直至成为单个元素，然后比较再合并（合并的过程就是两部分分别从头开始比较，取出最小或最大元素的放到新的区域内，继续取两部分中最大或最小的元素，直到这两部分合并完，最后所有的都合并完，最后形成完整的有序序列）

完整代码：

package com.keafmd.Sequence;/*** Keafmd** @ClassName: MergeSort* @Description: 归并排序* @author: 牛哄哄的柯南* @date: 2021-06-24 10:35*/
public class MergeSort {//归并排序public static void mergeSort(int []arr ,boolean ascending){int[] temp = new int[arr.length]; //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间mergeSort(arr,0,arr.length-1,temp,ascending);}public static void mergeSort(int []arr){mergeSort(arr,true);}/**** @param arr 传入的数组* @param left 当前子数组的起始下标* @param right 当前子数组的结束下标* @param temp 拷贝暂存数组*/public static void mergeSort(int []arr,int left,int right,int[] temp,boolean ascending){if(left<right){ //这里是递归结束的条件，我们是对半分，那当left==right的时候肯定大家都是只有一个元素了。//对半分，比如总长度是10，left=0，right=9，mid=4确实是中间分了，0~4，5~9//当长度9，left=0，right=8，mid=4，0~4，5~8int mid = left + (right-left)/2; // 防止越界的写法//int mid = (left+right)/2;mergeSort(arr,left,mid,temp,ascending); //左边归并排序，使得左子序列有序mergeSort(arr,mid+1,right,temp,ascending); //右边归并排序，使得右子序列有序merge(arr,left,mid,right,temp,ascending); //将两个有序子数组合并操作}}private static void merge(int[] arr,int left,int mid,int right,int[] temp,boolean ascending){int i = left; //左序列起始下标int j = mid+1; //右序列起始下标int t = 0; //临时数组指针while(i<=mid&&j<=right){if(ascending?arr[i]<arr[j]:arr[i]>arr[j]){ //比较两个序列第一个元素谁小，谁小先拷贝谁到temp，然后对应子序列下标加1temp[t++] = arr[i++];}else {temp[t++] = arr[j++];}}while(i<=mid){ //将左边剩余元素填充进temp中——左序列有一些数总是比右边的大的数temp[t++] = arr[i++];}while(j<=right){ //将右序列剩余元素填充进temp中——右序列有一些数总是比左边的大的数temp[t++] = arr[j++];}t = 0;//将temp中的元素全部拷贝到原数组中while(left<=right){arr[left++] = temp[t++];}}}

插入排序

简单解释：
最简单的理解就是打地主时我们拿到牌后的整理过程，从第二个牌（假设我们拿起来这个牌开始比较）开始，（说下升序）从后往前比较如果比前面的那个牌小，就把牌往后移动，直到找到一个合适的位置（这个位置的前面的那个牌不比这个要放下的牌大）就把这个牌放到这个位置，慢慢的前面的部分变得有序，直至全部有序即可。

完整代码：

package com.keafmd.Sequence;/*** Keafmd** @ClassName: StraghtInsertSort* @Description: 插入排序* @author: 牛哄哄的柯南* @date: 2021-06-24 10:36*/
public class StraghtInsertSort {//插入排序public static void straghtInsertSort(int[] arr) {straghtInsertSort(arr, true);//默认进行升序}public static void straghtInsertSort(int[] arr, boolean ascending) {for (int i = 1; i < arr.length; i++) {int temp = arr[i];int j=0; //这就是那个合适的位置for (j = i - 1; j >= 0 && (ascending ? temp < arr[j] : temp > arr[j]); j--) {arr[j + 1] = arr[j];}//把牌放下，为啥是j+1，//是因为上面的循环遍历到不符合情况的时候 j是合适的位置的前面的那个数的位置//有点拗口，但是就是这个意思，看图方便理解下arr[j + 1] = temp;}}
}

希尔排序

简单解释：
希尔排序是插入排序的改进版，我们理解一个叫做下标差的的东西，也就是下面那个图中的增量d，初始下标差为arr.length/2，然后继续/2，对在同一下标差（相当于把这几个数单独拿出来了）的若干个数进行插入排序即可。



完整代码：

package com.keafmd.Sequence;/*** Keafmd** @ClassName: ShellSort* @Description: 希尔排序* @author: 牛哄哄的柯南* @date: 2021-06-24 10:39*/
public class ShellSort {public static void shellSort(int[] arr) {shellSort(arr,true);}public static void shellSort(int[] arr,boolean ascending) {for(int d = arr.length/2;d>0;d/=2){for(int i=d;i< arr.length;i++){int temp = arr[i];int j=0;for(j=i-d;j>=0&&(ascending?temp<arr[j]:temp>arr[j]);j-=d){arr[j+d]=arr[j];}arr[j+d] = temp;}}}
}

计数排序

简单解释：
这个排序算法看名字也很好理解，就是就是额外找个数组来计数，然后在这个数组从小到大或从大到小把数取出来即可。

完整代码：

package com.keafmd.Sequence;/*** Keafmd** @ClassName: CountSort* @Description: 计数排序* @author: 牛哄哄的柯南* @date: 2021-06-24 11:31*/
public class CountSort {public static void countSort(int[]arr){countSort(arr,true);}public static void countSort(int[]arr,boolean ascending){int d,min=arr[0],max=arr[0];//找出最大、最小值for(int i=0;i< arr.length;i++){if(arr[i]<min){min =arr[i];}if(arr[i]>max){max = arr[i];}}//建立一个用于计数的数组d = min;int[] count_map = new int[max-min+1];for(int i=0;i< arr.length;i++){count_map[arr[i]-d]++;}int k =0;if(ascending){for(int i=0;i< arr.length;){if(count_map[k]>0){arr[i] = k+d;i++;count_map[k]--;}elsek++;}}else {for(int i=arr.length-1;i>=0;){if(count_map[k]>0){arr[i] = k+d;i--;count_map[k]--;}elsek++;}}}
}

桶排序

简单解释：
就是把一个数组分成几个桶（其实是几个区间，从小到大或从大到小的几个区间）装，然后让每个桶（区间）有序，然后取出来放一起就可以了，相当于把几个有序的段拿出来放一起，自然还是有序的，当然需要是按照区间的顺序拿了。

完整代码：

package com.keafmd.Sequence;import java.util.ArrayList;
import java.util.Collections;/*** Keafmd** @ClassName: BucketSort* @Description: 桶排序* @author: 牛哄哄的柯南* @date: 2021-06-24 13:32*/
public class BucketSort {public static void bucketSort(int[] arr){bucketSort(arr,true);}public static void bucketSort(int[] arr,boolean ascending){if(arr==null||arr.length==0){return;}//计算最大值与最小值int max = Integer.MIN_VALUE;int min = Integer.MAX_VALUE;for(int i=0;i<arr.length;i++){max = Math.max(arr[i],max);min = Math.min(arr[i],min);}//计算桶的数量int bucketNUm = (max-min)/ arr.length+1;ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNUm);for(int i=0;i<bucketNUm;i++){bucketArr.add(new ArrayList<>());}//将每个元素放入桶中for(int i=0;i<arr.length;i++){int num = (arr[i]-min)/ (arr.length);bucketArr.get(num).add(arr[i]);}//对每个桶进行排序for (int i = 0; i < bucketArr.size(); i++) {//用系统的排序，速度肯定没话说Collections.sort(bucketArr.get(i));}//将桶中元素赋值到原序列int index;if(ascending){index=0;}else{index=arr.length-1;}for(int i=0;i<bucketArr.size();i++){for(int j= 0;j<bucketArr.get(i).size();j++){arr[index] = bucketArr.get(i).get(j);if(ascending){index++;}else{index--;}}}}
}

基数排序

简单解释：
首先说一下，我发现好多人写的基数排序只能排序正整数，其实只要处理下就可以排序含有负数的了，就是我们排序前先把所有的数整体变大（就是减上最小的负数，也就是加了），都变成正数，然后排序好之后，在减下来（加上最小的负数，也就减了）就好了。
基数排序就是按数位排序可分为LSD（从最低位[也就是个位]开始排序）和MSD（从最高位开始排序），下面写的事LSD基数排序。
基数排序就是把数按位考虑，让后我们一位数只能是[0，9]，就是我们在考虑某位（个位、百位· · ·）的时候就只看这个位的数，放到在[0，9]相应的位置，然后顺序取出，最后再按其它位这样操作（上面说了要不从低位开始到高位，要不就是从高位到低位）

完整代码：

package com.keafmd.Sequence;/*** Keafmd** @ClassName: RadixSort* @Description: 基数排序* @author: 牛哄哄的柯南* @date: 2021-06-24 14:32*/
public class RadixSort {public static void radixSort(int[] arr){radixSort(arr,true);}public static void radixSort(int[]arr,boolean ascending){int max = Integer.MIN_VALUE;int min = Integer.MAX_VALUE;//求出最大值、最小值for (int i = 0; i < arr.length; i++) {max = Math.max(max, arr[i]);min = Math.min(min, arr[i]);}if (min<0) {	//如果最小值小于0，那么把每个数都减去最小值，这样可以保证最小的数是0for (int i = 0; i < arr.length; i++) {arr[i] -= min;}max -= min; //max也要处理！}//很巧妙求出最大的数有多少位int maxLength = (max+"").length();int[][] bucket = new int[10][arr.length]; //一个二维数组，一维代表0到9，二维存放符合数int[] bucketElementCount = new int[10]; // 用于记录0到9某位存在数字的个数for (int i = 0 ,n = 1 ; i < maxLength ; i++,n*=10) { //个位 十位 百位 这样遍历for (int j = 0; j < arr.length ; j++) {int value = arr[j]/n % 10;bucket[value][bucketElementCount[value]] = arr[j];bucketElementCount[value]++;}//升序if(ascending) {int index = 0;//从左到右，从下到上取出每个数for (int j = 0; j < bucketElementCount.length; j++) {if (bucketElementCount[j] != 0) {for (int k = 0; k < bucketElementCount[j]; k++) {arr[index] = bucket[j][k];index++;}}bucketElementCount[j] = 0;}}else { // 降序int index=0;//从右到左，从下到上取出每个数for (int j = bucketElementCount.length-1; j >=0; j--) {if (bucketElementCount[j] != 0) {for (int k = 0; k <bucketElementCount[j]; k++) {arr[index] = bucket[j][k];index++;}}bucketElementCount[j] = 0;}}/*for (int i1 = 0; i1 < arr.length; i1++) {System.out.print(arr[i1]+" ");}System.out.println();*/}if (min<0){for (int i = 0; i < arr.length ; i++) {arr[i] += min;}}}
}

完整测试类

package com.keafmd.Sequence;import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;/*** Keafmd** @ClassName: Sort* @Description: 十大排序算法测试类* @author: 牛哄哄的柯南* @date: 2021-06-16 21:27*/
public class Sort {public static void main(String[] args) {int[] nums = {12, 4, 25, 47, 58, 34, 25, 9, 99, 26, 1, -13, 162, 10093, -66, -1};
//        int[] nums = {12, 43,56,42,26,11};int[] temparr;//利用系统Collections.sort方法进行对比//将int数组转换为Integer数组//1、先将int数组转换为数值流temparr = nums.clone();IntStream stream = Arrays.stream(temparr);//2、流中的元素全部装箱，转换为流 ---->int转为IntegerStream<Integer> integerStream = stream.boxed();//3、将流转换为数组Integer[] integers = integerStream.toArray(Integer[]::new);//把数组转为ListList<Integer> tempList = new ArrayList<>(Arrays.asList(integers));//使用Collections.sort()排序System.out.println("使用系统的Collections.sort()的对比:");//Collections.sortCollections.sort(tempList, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o1-o2;//return o2-o1;}});//tempList.sort 也可以排序/* tempList.sort(new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {//return o1-o2;return o2-o1;}});*///遍历输出结果for (Integer integer : tempList) {System.out.print(integer+" ");}System.out.println();//测试冒泡排序System.out.println("测试冒泡排序:");temparr = nums.clone();BubbleSort.bubbleSort(temparr);//降序//BubbleSort.bubbleSort(temparr,false);for (int i = 0; i < temparr.length; i++) {System.out.print(temparr[i] + " ");}System.out.println();//测试快速排序System.out.println("测试快速排序:");temparr = nums.clone();QuickSort.quickSort(temparr);//QuickSort.quickSort(temparr,false);for (int i = 0; i < temparr.length; i++) {System.out.print(temparr[i] + " ");}System.out.println();//测试直接选择排序System.out.println("测试直接选择排序:");temparr = nums.clone();SelectSort.selectSort(temparr);//SelectSort.selectSort(temparr,false);for (int i = 0; i < temparr.length; i++) {System.out.print(temparr[i] + " ");}System.out.println();//测试堆排序System.out.println("测试堆排序:");temparr = nums.clone();HeapSort.heapSort(temparr);//HeapSort.heapSort(temparr,false);for (int i = 0; i < temparr.length; i++) {System.out.print(temparr[i] + " ");}System.out.println();//测试归并排序System.out.println("测试归并排序:");temparr = nums.clone();MergeSort.mergeSort(temparr);//MergeSort.mergeSort(temparr,false);for (int i = 0; i < temparr.length; i++) {System.out.print(temparr[i] + " ");}System.out.println();//测试插入排序System.out.println("测试插入排序:");temparr = nums.clone();StraghtInsertSort.straghtInsertSort(temparr);//StraghtInsertSort.straghtInsertSort(temparr,false);for (int i = 0; i < temparr.length; i++) {System.out.print(temparr[i] + " ");}System.out.println();//测试希尔排序System.out.println("测试希尔排序:");temparr = nums.clone();ShellSort.shellSort(temparr);//ShellSort.shellSort(temparr,false);for (int i = 0; i < temparr.length; i++) {System.out.print(temparr[i] + " ");}System.out.println();//测试计数排序System.out.println("测试计数排序:");temparr = nums.clone();CountSort.countSort(temparr);//CountSort.countSort(temparr,false);for (int i = 0; i < temparr.length; i++) {System.out.print(temparr[i] + " ");}System.out.println();//测试桶排序System.out.println("测试桶排序:");temparr = nums.clone();BucketSort.bucketSort(temparr);//BucketSort.bucketSort(temparr,false);for (int i = 0; i < temparr.length; i++) {System.out.print(temparr[i] + " ");}System.out.println();//测试基数排序System.out.println("测试基数排序:");temparr = nums.clone();RadixSort.radixSort(temparr);//RadixSort.radixSort(temparr,false);for (int i = 0; i < temparr.length; i++) {System.out.print(temparr[i] + " ");}System.out.println();}}

每天进步一点点！
不进则退！

版权声明：
原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/

看完如果对你有帮助，感谢点赞支持！
如果你是电脑端，看到右下角的 “一键三连” 了吗，没错点它[哈哈]
在这里插入图片描述
加油！

共同努力！

Keafmd

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/71429.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

使用O2OA二次开发搭建企业办公平台（一）平台部署篇：平台下载和部署

使用O2OA二次开发搭建企业办公平台（一）平台部署篇：平台下载和部署

转载&#xff1a;https://my.oschina.net/u/3931542/blog/2209110 本博客为O2OA系列教程&#xff0c;教程目录和各章节天梯将在连载完后更新。 服务器下载和安装 1、服务器安装包下载 访问http://www.o2oa.io网站&#xff0c;如下图所示: 在网站顶部导航里点击下载&#xff0…
阅读更多...
O2PLS(绘制载荷图)--R

O2PLS(绘制载荷图)--R

##绘制载荷图## gene_loading <- as.data.frame(fit0$W.) meta_loading <- as.data.frame(fit0$C.) colnames(gene_loading) <- c("pq1","pq2") colnames(meta_loading) <- c("pq1","pq2") #添加新的一列&#xff0c;按组…
阅读更多...
Java8 Stream：2万字20个实例，玩转集合的筛选、归约、分组、聚合

Java8 Stream：2万字20个实例，玩转集合的筛选、归约、分组、聚合

Java8 Stream 1 Stream概述2 Stream的创建3 Stream的使用案例使用的员工类3.1 遍历/匹配&#xff08;foreach/find/match&#xff09;3.2 筛选&#xff08;filter&#xff09;3.3 聚合&#xff08;max/min/count)3.4 映射(map/flatMap)3.5 归约(reduce)3.6 收集(collect)3.6.1 …
阅读更多...
O2S.Components.PDFView4NET显示pdf（winform）

O2S.Components.PDFView4NET显示pdf（winform）

O2S.Components.PDFView4NET显示pdf&#xff08;winform&#xff09; 首先得把这个dll导入工具箱 选中该dll组件 按确定就多出来这些东西 然后再按确定&#xff0c;工具箱就有下面这些组件啦 2. 拉一个PDFpageview&#xff0c;和一个pdfdocument就可以用来显示了 然后放代码…
阅读更多...
Java8对中文汉字排序的Comparator实现类

Java8对中文汉字排序的Comparator实现类

最近由于工作需要需要对中文汉字排序&#xff0c;编写了Comparator实现类分享给大家。 直接上代码&#xff1a; import java.util.Comparator;public class ChineseComparator<T> implements Comparator<T> {private static boolean isDigit(char ch) {return ch …
阅读更多...
Collectors.toMap mergeFunction参数，(o1,o2)-＞o1的含义

Collectors.toMap mergeFunction参数，(o1,o2)-＞o1的含义

文章目录 前言结论代码示例源码分析 前言 在java8 Stream流中经常有看到这么一种写法Collectors.toMap(Person::getName, Function.identity(),(o1, o2)->o2), 经常会比较好奇o1,o2指的是什么含义&#xff0c;本篇博文主要讲解o1,o2的含义。 结论 这里使用(o1, o2)->o…
阅读更多...
O2OA：移动办公市场中的另一股清流

O2OA：移动办公市场中的另一股清流

相比多数管理软件为外资品牌主导的尴尬局面&#xff0c;移动OA市场罕有为国产厂商独霸天下。 一方面&#xff0c;随着中国经济的蓬勃发展&#xff0c;企业数量快速增长。有资料显示&#xff0c;截至2017年三季度末&#xff0c;全国工商注册的中小企业总量超过4200万家&#xff…
阅读更多...
公开信呼吁，所有 AI 实验室应立即暂停训练比 GPT-4 更强大的 AI 模型？

公开信呼吁，所有 AI 实验室应立即暂停训练比 GPT-4 更强大的 AI 模型？

呼吁所有 AI 实验室立即暂停训练比 GPT-4 更强大的 AI 系统&#xff0c;为期至少 6 个月。 本文转自&#xff1a;机器之心 人们一直在说 ChatGPT 有风险&#xff0c;OpenAI CEO 也这么说&#xff0c;现在终于有人出手了。 在 GPT-4 诞生两周之际&#xff0c;一封公开信正在社交…
阅读更多...
交互式数据分析和处理新方法：pandas-ai =Pandas + ChatGPT

交互式数据分析和处理新方法：pandas-ai =Pandas + ChatGPT

Python Pandas是一个为Python编程提供数据操作和分析功能的开源工具包。这个库已经成为数据科学家和分析师的必备工具。它提供了一种有效的方法来管理结构化数据(Series和DataFrame)。 在人工智能领域&#xff0c;Pandas经常用于机器学习和深度学习过程的预处理步骤。Pandas通过…
阅读更多...
GPT-4将在下周发布！！

GPT-4将在下周发布！！

来源&#xff1a;学术头条 GPT-4 将在下周发布&#xff01;&#xff01; 3 月 9 日&#xff0c;微软德国 CTO Andreas Braun 在一场名为 “AI in Focus - Digital Kickoff” 的活动中表示&#xff0c;GPT-4 将在下周发布&#xff0c;将提供多模态模型。自 3 月初发布 Kosmos-1 …
阅读更多...
用LangChain构建大语言模型应用

用LangChain构建大语言模型应用

用LangChain构建大语言模型应用 自 ChatGPT 发布以来&#xff0c;大型语言模型 (LLM) 广受欢迎。尽管您可能没有足够的资金和计算资源从头开始训练自己的大语言模型&#xff0c;但您仍然可以使用预训练的大语言模型来构建一些很酷的东西&#xff0c;例如&#xff1a; 可以根据…
阅读更多...
开发一个App大概要多少钱？只讲干货

开发一个App大概要多少钱？只讲干货

结合自己的各种采坑失败经验以及周边个别成功试水经验&#xff0c;站在个人角度给出一些理解。 APP制作有多种形式&#xff0c;所以需要的成本差异较大。 1.寻找外包公司 2.模板APP&#xff08;内行叫SAAS&#xff09; 3.自己组建团队 互联网外包公司的成本构成&#xff1f…
阅读更多...
chatgpt赋能python：为什么Python报错GBK，如何解决？

chatgpt赋能python：为什么Python报错GBK，如何解决？

为什么Python报错GBK&#xff0c;如何解决&#xff1f; Python 是一种广泛使用的编程语言&#xff0c;但在使用过程中经常会出现 “GBk” 相关报错。本文将探讨这种报错的原因和解决方法。 什么是GBK&#xff1f; GBK 是中文编码&#xff0c;是用来在计算机上表示中文字符集…
阅读更多...
谷歌如何注册账号？手机号无法验证处理方法！2023年最新教程！

谷歌如何注册账号？手机号无法验证处理方法！2023年最新教程！

最近学会了如何爬网站&#xff0c;然后在观看油管过程中&#xff0c;想要注册一个油管账号&#xff0c;也就是谷歌账号。但是在注册过程中&#xff0c;您发现无法使用手机号进行验证。您已经查阅了一些解决方法&#xff0c;不过没有解决&#xff0c;最后钞能力在某宝&#xff0…
阅读更多...
【实战案例】分享6种常用的信用卡欺诈检测算法（附 Python 代码）

【实战案例】分享6种常用的信用卡欺诈检测算法（附 Python 代码）

大家好&#xff0c;本文旨在使用 XGBoost、随机森林、KNN、逻辑回归、SVM 和决策树解决信用卡潜在欺诈的分类问题&#xff0c;内容较长&#xff0c;建议收藏、点赞。 文章目录 技术提升案例简介导入相关模块导入数据探索性数据分析特征选择和数据集拆分模型建立模型评估准确率F…
阅读更多...
计算机毕业设计（附源码）python信用卡逾期数据处理分析系统

计算机毕业设计（附源码）python信用卡逾期数据处理分析系统

项目运行 环境配置&#xff1a; Pychram社区版 python3.7.7 Mysql5.7 HBuilderXlist pipNavicat11Djangonodejs。 项目技术&#xff1a; django python Vue 等等组成&#xff0c;B/S模式 pychram管理等等。 环境需要 1.运行环境&#xff1a;最好是python3.7.7&#xff0c;…
阅读更多...
毕业论文使用的卡方检验该如何分析？

毕业论文使用的卡方检验该如何分析？

一、卡方检验基本说明 有时&#xff0c;在研究中某个随机变量是否服从某种特定的分布是需要进行检验的。可以根据以往的经验或者实际的观测数据分布情况&#xff0c;推测总体可能服从某种分布函数F&#xff08;x&#xff09;。卡方检验就是这样一种用来检验给定的概率值下数据…
阅读更多...
金融学毕业论文选题哪些比较少人写而且资料比较多的？

金融学毕业论文选题哪些比较少人写而且资料比较多的？

提到金融学专业&#xff0c;你的第一印象是什么&#xff1f; 或许是金融学专业&#xff0c;是一个非常吸金的专业&#xff0c;又或者金融学专业是比较难考的专业&#xff0c;在这学习金融学专业的人都非常厉害&#xff0c;因为金融学非常难学&#xff0c;涉及的领域非常广。 …
阅读更多...
教资教育知识与能力中学生发展心理

教资教育知识与能力中学生发展心理

5.1 心理发展特征 1、中学生心理发展的一般特点【选择/材料】独闭不会过动 独立性&#xff1a;成人感、独立意识 闭锁性&#xff1a;不轻易表露内心世界 不平衡性&#xff1a;心理发展有时落后生理发展 社会学&#xff1a;关注社会生活 过渡性&#xff1a;半幼稚、半成熟…
阅读更多...
缺考计算机软件考试影响诚信吗,教资缺考一次会被记入诚信档案？会影响之后的考试？...

缺考计算机软件考试影响诚信吗,教资缺考一次会被记入诚信档案？会影响之后的考试？...

大家好&#xff0c;我是小灵通岳麓sir 关注我(csylzxxy)&#xff0c;了解更多相关资讯 很多小伙伴都想问&#xff1a;如果没能去参加考试&#xff0c;会影响下一次报考&#xff1f;听说还会被记入诚信档案&#xff1f;那么不去考试&#xff0c;会不会造成严重的影响呢&#xff…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023