常见八大排序算法实现

最新推荐文章于 2021-07-12 11:06:41 发布
置顶 最新推荐文章于 2021-07-12 11:06:41 发布
阅读量670 收藏 4
点赞数 1
分类专栏： 排序算法 数据结构与算法 文章标签： 排序算法 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44181671/article/details/108557584
版权

常见排序算法的实现（8种）

需要先了解各排序算法的原理

算法原理简单简介链接

在这里插入图片描述
在这里插入图片描述

O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n)

冒泡排序

/**
 * TODO
 *  冒泡排序
 *  相邻两个比较，重复多轮
 * @author Redamancy
 * @version 1.0
 * @since jdk 1.8
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[]{4,5,1,7,2,9,11};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr){
        //控制共比较多少轮
        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]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

快速排序

/**
 * TODO
 *  快速排序
 *  选取一个中间数，数据一分为二，小的在左，大的在右(无序)
 *  过程：右->左，跟第一个比较，大就不动下标 j 前移一位
 *  小就跟第一个交换位置，同时第一个下标 i 后移一位。
 *  最后 i，j 重复的位置放第一个数
 *  下一轮：左右各自以第一个数为比较单位，递归操作，直到剩下一个（i,j 重合）
 *  参数初始传入：arr,0,arr.length-1
 * @author Redamancy
 * @version 1.0
 * @since jdk 1.8
 */
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = new int[]{8,4,5,1,7,2,9,11};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int[] arr,int start,int end){
        //直到剩下一个元素 start = end
        if(start < end){
            //把数组中的第 0 个数字作为标准数
            int stard = arr[start];
            //记录需要排序的下标
            int low = start;
            int high = end;
            //循环找比标准数大的数和比标准数小的数
            while (low < high){
                //左右的比较是轮流的
                //右边的数字比标准数大
                while (low<high && stard<=arr[high]){
                    //下标往前移动
                    high--;
                }
                //使用右边的数字替换左边的数
                //即将当前这轮的标准数替换掉
                arr[low] = arr[high];

                //如果左边的数字比标准数小
                while (low<high && arr[low]<=stard){
                    //下标往后移动
                    low++;
                }
                //使用左边的数字替换右边的数字
                //即将前面替换标准数的小值所在位置替换成新的大值
                arr[high] = arr[low];
            }
            //low 跟 high 已重合
            //把标准数赋值给低位所在位置的元素
            //这一步已经把数组分成两部分：大于标准数 和 小于标准数
            //arr[low] = arr[high]
            arr[low] = stard;
            //递归处理所有小的数字
            quickSort(arr,start,low);
            //递归处理所有大的数字
            quickSort(arr,low+1,end);
        }

    }
}

插入排序

/**
 * TODO
 *  插入排序
 *  下标移动到哪排序到哪，即下标所到之处前面都是排序好的
 *  每次用下标所指元素跟前面的一个一个比较，大的后移直到遇到比他小/无 就停止并把进行判断的元素赋值给该位置的后一个位置
 *  下标从第二个开始就好了，因为默认下标前面都是有序的，第二个开始排序比较
 * @author Redamancy
 * @version 1.0
 * @since jdk 1.8
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] arr = new int[]{8,12,4,5,1,7,2,9,11};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));

    }

    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;
            }
        }
    }
}

希尔排序

/**
 * TODO
 *  希尔排序
 *  使用**步长**：相隔 步长(total/2) 进行比较，每轮 步长/2
 *  通过步长将数据分成几组分别比较，最后组合起来
 *  本质：插入排序
 *  1.确定步长
 *  2.根据步长分组
 *  3.插入排序
 *  4.递归前面步骤 直至步长为0
 * @author Redamancy
 * @version 1.0
 * @since jdk 1.8
 */
public class ShellSort {
    public static void main(String[] args) {
        int[] arr = new int[]{8,12,3,5,1,7,2,9,11};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 遍历所有元素时，i = d 第一次肯定是中间那个，每次 i++ 实际上遍历新的一组元素（内部循环遍历是 步长来 递减 比较)
     * 遍历本组第一次 i-d 的 值 是第一个元素，即表示从第一个元素(本组)开始遍历本组
     * 本组元素一个循环内比较的是 **左->右**（插入排序）即将最新的一个跟前面排序好的比较
     * @param array
     */
    public static void shellSort(int[] array){
        //遍历所有的步长
        for(int d=array.length/2;d>0;d/=2){
            //遍历所有组
            for(int i=d;i<array.length;i++){
                //遍历本组中所有的元素
                for(int j=i-d;j>=0;j-=d){
                    //如果当前元素大于加上步长后的那个元素
                    if(array[j]>array[j+d]){
                        int temp = array[j];
                        array[j] = array[j+d];
                        array[j+d] = temp;
                    }
                }
            }
        }
    }
}

选择排序

/**
 * TODO
 *  选择排序
 *  每次只把未排序的元素中的最小/最大值 挑选出来放到最前面下标前移一位
 * @author Redamancy
 * @version 1.0
 * @since jdk 1.8
 */
public class SelectSort {

    public static void main(String[] args) {
        int[] arr = new int[]{8,12,3,5,1,8,8,2,9,11};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void selectSort(int[] arr){
        //遍历所有的元素
        for(int i=0;i<arr.length;i++){
            int minIndex = i;
            //把当前遍历的数和后面所有的数一次进行比较，并记录最小的数的下标
            for(int j=i+1;j<arr.length;j++){
                //如果后面比较的数比记录的最小数的下标
                if(arr[minIndex] > arr[j]){
                    //记录下最小的那个数的下标
                    minIndex = j;
                }
            }
            //如果最小的数和当前遍历的数的下标不一致
            //说明下标为minIndex的数比当前遍历的数更小
            //将下标为minIndex的数换到 ”最前”
            if(i!=minIndex){
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }
}

归并排序

/**
 * TODO
 *  归并排序
 *  适合于数据本身元素 **部分有序**
 *  递归调用。需要用到 额外数组 装载比较结果
 *  拆成多组，从各自最小的开始比较，小的放进数组
 *  自动处理 middle参数 && 递归处理直到 一组中只有一个元素
 * @author Redamancy
 * @version 1.0
 * @since jdk 1.8
 */
public class MergeSort {
    public static void main(String[] args) {
        int[] arr = new int[]{1,3,5,2,4,6,8,10};
//        System.out.println(Arrays.toString(arr));
//        merge(arr,0,2,arr.length-1);
//        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr));
        mergeSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    //递归处理
    public static void mergeSort(int[] arr,int low,int high){
        int middle=(high+low)/2;
        //直到某组中只有一个元素，停止递归
        if(low<high){
            //处理左边
            mergeSort(arr,low,middle);
            //处理右边
            mergeSort(arr,middle+1,high);
            //归并
            merge(arr,low,middle,high);
        }
    }

    public static void merge(int[] arr,int low,int middle,int high){
        //用于存储归并后的临时数组
        int[] temp = new int[high-low+1];
        //记录第一个数组中需要遍历的下标
        int i = low;
        //记录第二个数组中需要遍历的下标
        int j = middle+1;
        //用于记录在临时数组中存放的下标
        int index = 0;
        //遍历两个数组比较取出较小的数字，放入临时数组中
        //这里的两个数组指的是将原数组分成两部分
        while (i<=middle && j<=high){
            //第一个数组的数据更小
            if(arr[i] <= arr[j]){
                //把小的数据放入临时数组中
                temp[index] = arr[i];
                //让下标向后移动一位
                i++;
            }else{
                //第二个数组的数据更小
                temp[index] = arr[j];
                //让下标向后移动一位
                j++;
            }
            //临时数组下标移动
            index ++;
        }
        //处理第二个数组多余的数据-即第一个数组元素先比较完了
        while (j <= high){
            temp[index] = arr[j];
            j++;
            index++;
        }
        //处理第一个数组多余的数据-即第二个数据元素先比较完了
        while (i <= middle){
            temp[index] = arr[i];
            i++;
            index++;
        }
        //把临时数组中的数据重新存入原数组
        for(int k=0;k<temp.length;k++){
            arr[k+low] = temp[k];
        }
    }
}

基数排序

/**
 * TODO
 *  基数排序
 *  先通过个位数大小按顺序排序，形成新数据
 *  再通过十位数大小按顺序排列，形成新数据，以此类推
 * @author Redamancy
 * @version 1.0
 * @since jdk 1.8
 */
public class RadixSort {
    public static void main(String[] args) {
        int[] arr = new int[]{73,22,93,43,55,14,28,65,39,81};
        radixSort2(arr);
        System.out.println(Arrays.toString(arr));
    }

    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];
                //记录数量,每添加一个（余数相同）记录数+1
                //用于判断该放入二维数组哪个位置
                counts[ys]++;
            }
            //记录取的元素需要放的位置
            int index = 0;
            //把数字取出来
            for(int k=0;k<counts.length;k++){
                //记录数量的数组中当前余数记录的数量不为0
                if(counts[k] != 0){
                    //循环取出元素
                    for(int l=0;l<counts[k];l++){
                        //取出元素
                        arr[index] = temp[k][l];
                        //记录下一个位置
                        index++;
                    }
                    //把数量置为0
                    counts[k] = 0;
                }
            }
        }
    }

    //使用优先队列优化
    public static void radixSort2(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();
        //用于临时存储数据的队列的数组
        MyQueue[] temp = new MyQueue[10];
        //为队列数组赋值
        for(int i=0;i<temp.length;i++){
            temp[i] = new MyQueue();
        }
        //根据最大长度决定比较的次数
        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].add(arr[j]);
            }
            //记录取的元素需要放的位置
            int index = 0;
            //把所有队列中的数字取出来
            for(int k=0;k<temp.length;k++){
                //循环取出元素
                while (!temp[k].isEmpty()){
                    //取出元素
                    arr[index] = temp[k].poll();
                    //记录下一个位置
                    index++;
                }
            }
        }
    }

}

需要的队列类

/**
 * TODO
 *  队列的实现
 * @author Redamancy
 * @version 1.0
 * @since jdk 1.8
 */
public class MyQueue {

    int[] elements;

    public MyQueue(){
        elements = new int[0];
    }

    //入队
    public void add(int element){
        int[] newArr = new int[elements.length+1];
        //把原数组的元素复制到新数组
        for(int i=0;i<elements.length;i++){
            newArr[i] = elements[i];
        }
        //把添加的元素放入新数组中
        newArr[elements.length] = element;
        //新数组替换旧数组
        elements = newArr;
    }

    //出队-第一个元素
    public int poll(){
        int element = elements[0];
        int[] newArr = new int[elements.length-1];
        for(int i=0;i<newArr.length;i++){
            //除去原数组第一个元素
            newArr[i] = elements[i+1];
        }
        //替换数组
        elements = newArr;
        return element;
    }

    public boolean isEmpty(){
        return elements.length==0;
    }
}

堆排序

/**
 * TODO
 *  堆排序的实现
 *  1.构建最大堆/最小堆
 *  2.进行堆排序
 *  升序排序使用大顶堆
 *  降序排序使用小顶堆
 * @author Redamancy
 * @version 1.0
 * @since jdk 1.8
 */
public class HeapSort {
    public static void main(String[] args) {
        int[] arr = new int[]{9,6,8,7,0,1,10,4,2};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));

    }

    /**
     * 开始堆排序
     * @param arr 要使用的数组
     */
    public static void heapSort(int[] arr){
        //开始位置是最后一个非叶子结点，即最后一个节点的父亲
        int start = (arr.length-1)/2;
        //调整为大顶堆
        for(int i = start;i >= 0;i--){
            maxHeap(arr,arr.length,i);
        }
        //先把数组中的第 0 个结点和最后一个节点交换位置
        //再把交换后的结构再次处理为大顶堆
        for(int i = arr.length-1;i > 0;i--){
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            //堆顶最大值交换到最后一位之后就不去动他
            //故数组不变，i每次向前移动一位，固定从堆顶开始重新构建大顶堆
            maxHeap(arr,i,0);
        }
    }

    /**
     * 构建大顶堆
     * @param arr 使用的数组
     * @param size  需要构建的长度
     * @param index 从哪一个节点开始
     */
    public static void maxHeap(int[] arr,int size,int index){
        //左子节点
        int leftNode = 2*index + 1;
        //右子节点
        int rightNode = 2*index + 2;
        //设置临时变量用来存储比较节点与其子节点之间的较大值
        int max = index;
        //与两个子节点进行比较，找出最大的结点
        if(leftNode < size && arr[leftNode] > arr[max]){
            max = leftNode;
        }
        if(rightNode < size && arr[rightNode] > arr[max]){
                max = rightNode;
        }
        //交换位置，使得最大的结点在最上面
        if(max != index){
            int temp = arr[index];
            arr[index] = arr[max];
            arr[max] = temp;
            //交换位置以后，可能会破坏之前排序好的堆
            //所以之前排好的堆需要重新调整
            maxHeap(arr,size,max);
        }
    }
}
chen_179
关注
专栏目录
常见的几种排序算法实现
qq_37976565的博客
03-18 490
排序 插入排序 （简单） 主要思想是从下标为1的位置开始向后走，每次插入到目标位置 public static <AnyType extends Comparable<? super AnyType>> void insertionSort(AnyType[] a){ int k; for (int i = 1; i < a.leng...
常见的八大排序算法
weixin_44514648的博客
11-09 337
概念 我们平常说的排序，通常都是按照从小到大的顺序，而且指的是原地排序(in place sort)。 排序又分内部排序和外部排序： 内部排序——将数据拉到内存中进行排序 外部排序——将数据放到磁盘排序，数据量太大，导致在内存当中不可存放 以下介绍的排序都是内部排序： 标准 判断排序的标准：时间复杂度、空间复杂度、稳定性 这里重点说稳定性：如果一个序列中有若干相等的数据，排序之后其相对位置没有发生改变排序就是稳定的。 比较快速判断是否稳定的方法：如果在排序过程中没有发生跳跃式交换（隔几个数地去交换），就是稳
各种排序算法的实现（更新中）
weixin_33871366的博客
01-08 80
　　这里我只贴出各种排序算法的代码，或者简单的说明，以备日后复习。 　　今晚又把归并排序和快速排序实现了一遍，不要担心做重复的工作，只有把简答的工作做得很好，那么你才有能力去承担更好的工作。虽然说已经写了好多次了，但是每次都能发现自己的问题。 首先是归并排序，实现过程很简单，但是在最后竟然忘记把malloc的空间给free掉。。这是很危险的事情啊！  还有就是快速排序，快速排序的思想是任意选一个...
各种排序算法的实现
qq_41268108的博客
10-20 811
  插入排序 基本思想：每一步将一个待排序的元素，按其排序码的大小，插入到前面已经排好的序的一组元素的合适的位置上去，直到元素全部插完为止。 1.直接插入排序 基本思想：  当插入第i个元素时，前面的array[0]、array[1]、array[2]……array[i-1]已经排好序，此时用array[i]的排序码与array[i-1]、array[i-2]……的排序码进行比较，找到插入...
几种常见排序算法实现
06-16
几种常见排序 基于比较的排序算法: 下界是 nlgn 1.1 SelectionSort：每次选出最下的元素，放在当前循环最左边的位置。 1.2 BubbleSort：每次比较相邻的两个数，使得最大的数像气泡一样冒到最右边。 1. 3 InsertionSort：每次拿起一个数，插入到它左边数组的正确位置。 1.4 QuickSort：选择一个数，作为标准，小于它的放在左边，大于它的放在右边。并把它放在中间；递归地对左右子数组进行排序。 实现时：1. 确定递归结束条件，初始化左右游标, 选择标准数； 2. while循环，do while实现两个游标同时向中间移动，置换； 3. 置换标准数和右边游标所指的数； 4. 递归调用，对左右子数组进行排序。 1. 5 HeapSort：用最大堆实现。 实现时：建堆：置换堆顶元素和最后一个元素，堆大小减少，保持新的堆为最大堆； 保持最大堆: 从底向上依次保持最大堆，从第一个父节点到根部。 1.6 MergeSort：拆分数组，递归实现排序，二路归并。用哨兵来阻止游标的越界。 线性时间运行的算法： 1.7 CountingSort: 假设数据分布在0到k之间的。对于每个输入x，确定出小于x的数的个数。假设小于x的数有17个，那么x就应该在第18个输出位置。 1. 8 Radix sort（基数排序）：从最低位开始，每位采用稳定的排序算法（如计数排序）。 1.9 Bucket sort：当输入数据比较均匀时采用。 先将数据区间分为n个桶，把数据分放到对应的桶中；对桶内的数据采用插入排序；再把各个桶的排序结果串起来。
各种排序算法的实现及其比较
rainharder的专栏
09-17 1104
原贴：http://www.it165.net/pro/html/201403/10524.html 本人介绍的排序算法主要有：插入排序，选择排序，冒泡排序，快速排序，堆排序，归并排序，希尔排序，二叉树排序，桶排序，基数排序（后两者为非比较排序，前面的为比较排序）。 排序的稳定性和复杂度：       不稳定：       选择排序（selection sort
常见的八种排序算法
HackQ_sxj的博客
11-26 548
排序按类别分为：插入排序（插入排序、希尔排序）、选择排序（选择排序、堆排序）、交换排序（冒泡排序、快速排序）、归并排序、基数排序。 1. 冒泡排序 /** * 从第一个数据开始,将顺序表中的每一个数据与其后一个数据比较大小 如果比后边大,就交换位置, 直到倒数第二个与倒数第一个比较完毕 * 我们可以得到最大的数,放在队尾, 不断循环执行,直到数组有序 */ public sta...
利用Python实现数据结构常见的八大排序算法
02-20
以下是利用Python实现数据结构中常见的八大排序算法的知识点。 1. 直接插入排序：直接插入排序是一种简单的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置...
C++常见八大排序算法
01-24
本文将详细介绍在C++中实现的八大排序算法，以及如何在Visual Studio 2017环境下进行编写。 首先，让我们来逐一了解这八大排序算法： 1. **冒泡排序**：这是一种简单的排序方法，通过重复遍历待排序的数列，一次...
常见的八大排序算法及其JAVA实现
04-26
这八大排序算法包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序以及计数排序。 1. 冒泡排序（Bubble Sort）： 冒泡排序是最简单的排序算法之一，通过不断地交换相邻两个元素的位置，使较...
python八大排序算法速度实例对比
09-21
### Python八大排序算法速度实例对比 #### 排序算法概览 本文主要通过实例的方式对Python中的八大排序算法进行了速度对比。这些算法分别是：直接插入排序、希尔排序、简单选择排序、堆排序、冒泡排序、快速排序、...
Java实现常见排序算法（一）
Alex_NINE的博客
05-05 1175
在开发过程中使用得比较多的算法就是排序算法和查找算法了，今天先盘点一下常见的排序算法中的两个大类交换排序和插入排序。 交换排序 快速排序 基本思想：用选取的初始值（一般是第一个）将待排序序列分为小于初始值和大于初始值的两部分，然后重复此操作，最终到排序完成。该算法是一个不稳定的算法（如果待排序序列中存在相同的元素，经过排序后他们的相对位置不发生改变那么这个算法就是稳定的排序算法） 空间复杂度最坏为...
几种排序算法实现
zhonglixianyun的博客
04-01 302
class Sort { public: Sort(void); ~Sort(void); public: inline void Swap(int &amp;a,int &amp;b); //冒泡排序 void BubbleSort(int a[],int n); //直接插入排序 void InsertSort(int a[],int n); //希尔排序 void Sel...
几个常用排序算法的实现
风行天下
12-03 227
import java.util.Arrays; public class SortTest { private static int[] nums = {5,2,9,4,0,7,3,8,6,1}; public static void main(String[] args) { System.out.println("nums:"+Arrays.toString(nums)); // int[] result = maoPaoSort(nums); //
各种常见排序算法实现
icebod的博客
03-19 751
各种常见排序算法实现 近日受一兄台影响，也想学习记录些东西，于是也尝试开始写博客。 排序算法算是最为简单经典的算法问题了，因此从这个开始学习记录，以加深印象。 其中常见的排序算法有： 选择排序 冒泡排序 插入排序 合并排序 快速排序 堆排序 以上排序算法一定无法罗列全部排序算法的大家族，但是暂且讨论以上的算法。 选择排序和冒泡排序属于蛮力解决问题的表现； 插入排序则使用减治法； 合并排序和...
常用几大排序算法实现
shaderdx的专栏
08-27 336
本文主要罗列总结几大常用排序算法。 1、冒泡法排序 3种实现： 2、直接插入法排序 3种实现： 3、希尔排序 4、直接选择排序 5、归并排序 6、快速排序 7、堆排序 8、基数排序 9、 ...
常见排序算法的实现
An_Mo的博客
07-12 291
1、插入排序： 基本思想：直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。 直接插入排序： 当插入第i（i>=1）个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。 直接插入排序
十大经典算法动图演示+python实现(超详细)
Jmayday
01-14 1123
排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括： 1、冒泡排序 关于时间复杂度： 平方阶 (...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值