十大基础算法

news2024/9/22 10:03:59

一、选择排序

过程简单描述：
首先，找到数组中最小的那个元素，其次，将它和数组的第一个元素交换位置(如果第一个元素就是最小元素那么它就和自己交换)。其次，在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。这种方法我们称之为选择排序。

为方便理解我还准备了动图：

.

public class SelectionSort {

    public static void main(String[] args) {
        int[] arr = {5, 3, 6, 8, 1, 7, 9, 4, 2};
        //定义内外两层循环，从最外层循环第一个值开始匹配，内层循环从外层循环加以开始向后匹配
        //如果遇到小的值就进行交换
        //外层循环到倒数第二为止，内层循环到倒数第一为止
        for (int i = 0; i < arr.length-1; i++) {
            int min = i;
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i]>=arr[j]){
                    min = j;
                    int temp = arr[i];
                    arr[i] = arr[min];
                    arr[j] = temp;
                }
            }
        }
        CommonUtils.print(arr);
    }
}

性质：1、时间复杂度：O(n2)  2、空间复杂度：O(1)  3、非稳定排序  4、原地排序

二、插入排序

我们在玩打牌的时候，你是怎么整理那些牌的呢？一种简单的方法就是一张一张的来，将每一张牌插入到其他已经有序的牌中的适当位置。当我们给无序数组做排序的时候，为了要插入元素，我们需要腾出空间，将其余所有元素在插入之前都向右移动一位，这种算法我们称之为插入排序。

过程简单描述：

1、从数组第2个元素开始抽取元素。

2、把它与左边第一个元素比较，如果左边第一个元素比它大，则继续与左边第二个元素比较下去，直到遇到不比它大的元素，然后插到这个元素的右边。

3、继续选取第3，4，….n个元素,重复步骤 2 ，选择适当的位置插入。

为方便理解我还准备了动图：

public class InsertionSort {
    public static void main(String[] args) {
        int[] a = { 9, 3, 1, 4, 6, 8, 7, 5, 2 };
        for (int i = 1; i < a.length; i++) {
            //内层比较是从外层的赋值为起始点
            //该值会和它前面的值比较，如果比前面的值小就交换
            for (int j = i;j>0; j--) {
                if(a[j]<a[j-1]){
                    CommonUtils.swap(a,j,j-1);
                }
            }
        }
        CommonUtils.print(a);
    }
}

三、冒泡排序

1、把第一个元素与第二个元素比较，如果第一个比第二个大，则交换他们的位置。接着继续比较第二个与第三个元素，如果第二个比第三个大，则交换他们的位置….

我们对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样一趟比较交换下来之后，排在最右的元素就会是最大的数。

除去最右的元素，我们对剩余的元素做同样的工作，如此重复下去，直到排序完成。

为方便理解我还准备了动图：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 3, 6, 8, 1, 7, 9, 4, 2};
        for (int i = 0; i < arr.length; i++) {
            //内层循环像指针一样指导着程序运行
            for (int j = 0; j < arr.length-i-1; j++) {

                if(arr[j]>arr[j+1]){
                    CommonUtils.swap(arr,j,j+1);
                }
            }
        }

        CommonUtils.print(arr);
    }
}

四、冒泡排序

希尔排序可以说是插入排序的一种变种。无论是插入排序还是冒泡排序，如果数组的最大值刚好是在第一位，要将它挪到正确的位置就需要 n - 1 次移动。也就是说，原数组的一个元素如果距离它正确的位置很远的话，则需要与相邻元素交换很多次才能到达正确的位置，这样是相对比较花时间了。

希尔排序就是为了加快速度简单地改进了插入排序，交换不相邻的元素以对数组的局部进行排序。

希尔排序的思想是采用插入排序的方法，先让数组中任意间隔为 h 的元素有序，刚开始 h 的大小可以是 h = n / 2,接着让 h = n / 4，让 h 一直缩小，当 h = 1 时，也就是此时数组中任意间隔为1的元素有序，此时的数组就是有序的了。

为方便理解我还准备了图片：

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {5, 3, 6, 8, 1, 7, 9, 4, 2};
        int h = arr.length/2;
        for (int gap = h; gap > 0; gap--) {//间隔的循环
            for (int j = 0; j < arr.length-gap; j++) {
                if(arr[j]>arr[j+gap]){
                    CommonUtils.swap(arr,j,j+gap);
                }
            }

        }

        CommonUtils.print(arr);
    }
}

五、归并排序

将一个大的无序数组有序，我们可以把大的数组分成两个，然后对这两个数组分别进行排序，之后在把这两个数组合并成一个有序的数组。由于两个小的数组都是有序的，所以在合并的时候是很快的。

通过递归的方式将大的数组一直分割，直到数组的大小为 1，此时只有一个元素，那么该数组就是有序的了，之后再把两个数组大小为1的合并成一个大小为2的，再把两个大小为2的合并成4的 ….. 直到全部小的数组合并起来。

为方便理解我还准备了动图：

public class MergeSort {

    public static void main(String[] args) {
        int[] arr = {1,4,7,8,3,6,9};
        sort(arr, 0, arr.length-1);

        CommonUtils.print(arr);
    }
    static void sort(int[] arr, int left, int right) {
        if(left==right){
            return;
        }
        int mid = left + (right-left)/2;
        sort(arr,left,mid);
        sort(arr,mid+1,right);
        merge(arr,left,mid+1,right);
    }


    //先定义合并的方法
    static void merge(int[] arr, int leftPtr, int rightPtr, int rightBound) {
        int i = leftPtr;
        int j = rightPtr;
        int mid = rightPtr -1;
        int[] temp = new int[rightBound - leftPtr + 1];
        int tempPtr = 0;

        //进行比较赋值
        while (i<=mid&&j<=rightBound){
            if(arr[i]>arr[j]){
                temp[tempPtr]=arr[j];
                j++;
                tempPtr++;
            }else {
                temp[tempPtr]=arr[i];
                i++;
                tempPtr++;
            }
        }

        //将未放入临时数组的数放入临时数组
        while(i<=mid) temp[tempPtr++] = arr[i++];
        while(j<=rightBound) temp[tempPtr++] = arr[j++];

        //数组复制
        for (int i1 = 0; i1 < temp.length; i1++) {
            arr[leftPtr+i1]=temp[i1];
        }
    }
}

六、快速排序

我们从数组中选择一个元素，我们把这个元素称之为中轴元素吧，然后把数组中所有小于中轴元素的元素放在其左边，所有大于或等于中轴元素的元素放在其右边，显然，此时中轴元素所处的位置的是有序的。也就是说，我们无需再移动中轴元素的位置。

从中轴元素那里开始把大的数组切割成两个小的数组(两个数组都不包含中轴元素)，接着我们通过递归的方式，让中轴元素左边的数组和右边的数组也重复同样的操作，直到数组的大小为1，此时每个元素都处于有序的位置。

为方便理解我还准备了动图：

public class QuickSort {

    public static void main(String[] args) {
        int[] arr = {1,5,7,6,4};
        sort(arr,0,arr.length-1);

        CommonUtils.print(arr);
    }

    static void sort(int[] arr, int leftBound, int rightBound) {
        if(leftBound>=rightBound) {
            return;
        }
        int mid = partition(arr, leftBound, rightBound);
        sort(arr,leftBound,mid-1);
        sort(arr,mid+1,rightBound);
    }

    static int partition(int[] arr, int leftBound, int rightBound) {
        int left = leftBound;
        int mid = rightBound;
        int right = rightBound-1;

        while (left<=right){
            //1、这两个指针分别寻找小于标杆和大于标杆的数，找到以后指针停止
            //2、交换两边指针停止位置的数
            //3、将标杆放到中间的位置
            while (left<=right&&arr[left]<=arr[mid]){
                left++;
            }
            while (left<=right&&arr[right]>arr[mid]){
                right--;
            }
            if(left<right){
                CommonUtils.swap(arr,left,right);
            }
        }
        //把标杆放中间
        CommonUtils.swap(arr,left,rightBound);
        return left;
    }
}

七、计数排序

计数排序是一种适合于最大值和最小值的差值不是不是很大的排序。

基本思想：就是把数组元素作为数组的下标，然后用一个临时数组统计该元素出现的次数，例如 temp[i] = m, 表示元素 i 一共出现了 m 次。最后再把临时数组统计的数据从小到大汇总起来，此时汇总起来是数据是有序的。

为方便理解我还准备了动图：

public class CountSort {
    public static void main(String[] args) {

        int[] arr = {2, 4, 2, 3, 7, 1, 1, 0, 0, 5, 6, 9, 8, 5, 7, 4, 0, 9};

        int[] result = sort(arr);

        CommonUtils.print(result);

    }
    public static int[] sort(int[] arr) {
        int[] temp = new int[10];
        for (int a : arr) {
            temp[a]++;
        }

        int[] result = new int[arr.length];
        int r = 0;
        for (int i = 0; i < temp.length; i++) {

            while (temp[i]>0){
                result[r]=i;
                r++;
                temp[i]--;
            }
        }
        return result;
    }
}

八、桶排序

桶排序就是把最大值和最小值之间的数进行瓜分，例如分成  10 个区间，10个区间对应10个桶，我们把各元素放到对应区间的桶中去，再对每个桶中的数进行排序，可以采用归并排序，也可以采用快速排序之类的。

之后每个桶里面的数据就是有序的了，我们在进行合并汇总。

为方便理解我还准备了图片：

public class BucketSort {

    public static void main(String[] args) {

        int[] arr = {2, 4, 2, 3, 7,0};

        int[] result = sort(arr);

        CommonUtils.print(result);

    }

    public static int[] sort(int[] arr) {
        int max = findMax(arr);
        int mini = findMini(arr);
        int group = (max-mini)/5+1;
        List<List<Integer>> totalBucket = new LinkedList<>();

        //初始化桶
        for (int i = 0; i < group; i++) {
            totalBucket.add(new LinkedList<Integer>());
        }

        for (int i = 0; i < arr.length; i++) {
            //得到所在区间
            int i1 = (arr[i] - mini) / (max - mini);
            //向所在区间添加元素
            totalBucket.get(i1).add(arr[i]);
        }

        //复制结果
        for (List<Integer> integers : totalBucket) {
            Collections.sort(integers);
        }




        //复制结果
        int[] result = new int[arr.length];
        int r = 0;
        for (int i = 0; i < totalBucket.size(); i++) {
            for (int i1 = 0; i1 < totalBucket.get(i).size(); i1++) {
                result[r]= totalBucket.get(i).get(i1);
                r++;
            }
        }
        return result;
    }

    public static int findMax(int[] arr) {
        int max = arr[0];
        for (int i : arr) {
            if(i>max){
                max = i;
            }
        }
        return max;
    }

    public static int findMini(int[] arr) {
        int mini = arr[0];
        for (int i : arr) {
            if(i<mini){
                mini = i;
            }
        }
        return mini;
    }
}

九、基数排序

基数排序的排序思路是这样的：先以个位数的大小来对数据进行排序，接着以十位数的大小来多数进行排序，接着以百位数的大小……

排到最后，就是一组有序的元素了。不过，他在以某位数进行排序的时候，是用“桶”来排序的。

由于某位数（个位/十位….，不是一整个数）的大小范围为0-9，所以我们需要10个桶，然后把具有相同数值的数放进同一个桶里，之后再把桶里的数按照0号桶到9号桶的顺序取出来，这样一趟下来，按照某位数的排序就完成了

为方便理解我还准备了动图：

public class RadioSort {
    public static void main(String[] args) {
        int[] arr = {5, 3, 6, 8, 100, 7, 9, 4, 20};
        sort(arr);
        CommonUtils.print(arr);
    }

    public static int[] sort(int[] arr) {
       if(arr==null||arr.length==2) {
           return arr;
       }
       int max = findMax(arr);
       int num = 1;
       while (max/10>0){
           max= max/10;
           num++;
       }

        List<List<Integer>> totalBucket = new LinkedList<>();

        //初始化桶
        for (int i = 0; i < 10; i++) {
            totalBucket.add(new LinkedList<Integer>());
        }
        for (int i = 0; i < num; i++) {
            //放入对应的桶
            for (int j = 0; j < arr.length; j++) {
                int location = (arr[j] / (int)Math.pow(10,i)) % 10;
                totalBucket.get(location).add(arr[j]);
            }


            int k = 0;
            for (List<Integer> integers : totalBucket) {
                for (Integer integer : integers) {
                    arr[k++]=integer;
                }
                integers.clear();
            }


        }



        return arr;
    }


    public static int findMax(int[] arr) {
        int max = arr[0];
        for (int i : arr) {
            if(i>max){
                max = i;
            }
        }
        return max;
    }
}

十、堆排序

堆的特点就是堆顶的元素是一个最值，大顶堆的堆顶是最大值，小顶堆则是最小值。

堆排序就是把堆顶的元素与最后一个元素交换，交换之后破坏了堆的特性，我们再把堆中剩余的元素再次构成一个大顶堆，然后再把堆顶元素与最后第二个元素交换….如此往复下去，等到剩余的元素只有一个的时候，此时的数组就是有序的了。

为方便理解我还准备了动图：

public class HeadSort {
    public static void main(String[] args) {
        int[] arr = {5, 3, 6, 8, 100, 7, 9, 4, 20};
        int n = arr.length;
         //构建大顶堆
         for (int i = (n - 2) / 2; i >= 0; i--) {
             sort(arr, i, n - 1);
         }

         //进行堆排序
        for (int i = n - 1; i >= 1; i--) {
            // 把堆顶元素与最后一个元素交换
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            // 把打乱的堆进行调整，恢复堆的特性
            sort(arr, 0, i - 1);
         }

        CommonUtils.print(arr);
    }


    public static void sort(int[] arr,int parent, int n) {
        int child = 2*parent+1;

        while (child<n){

            //如果右节点大于左节点这把指针只想左节点
            if(child+1<n&&arr[child]<arr[child+1]){
                child++;
            }
            //比较子节点和父节点的大小
            if(arr[child]>arr[parent]){
                CommonUtils.swap(arr,child,parent);
            }
            parent = child;
            child = 2*parent+1;
        }
    }

}

总结

用一张图汇总了10大排序算法的性质

参考文章：

堆排序详细图解（通俗易懂）_右大臣的博客-CSDN博客 

https://www.cnblogs.com/itsharehome/p/11058010.html

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

翻筋斗觅食策略改进海鸥优化算法

翻筋斗觅食策略改进海鸥优化算法

目录 一、非线性参数A策略 二、翻筋斗觅食策略 基本 SOA 有一些局限性&#xff0c;例如容易陷入局部最优值、后期收敛缓慢、勘探与开发能力不平衡等&#xff0c;在求解复杂优化问题时尤甚。为了改善基本SOA的不足&#xff0c;提出一种基于翻筋斗觅食策略的改进 SOA(SFSOA)。…
阅读更多...
【Neo4j教程之CQL函数基本使用】

【Neo4j教程之CQL函数基本使用】

&#x1f680; Neo4j &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;C…
阅读更多...
基于stm32单片机的ESP-01S模块（wifi模块）的使用

基于stm32单片机的ESP-01S模块（wifi模块）的使用

一、开发环境 开发板&#xff1a;野火stm32f407开发板 wifi模块&#xff1a;ESP-01S&#xff08;核心处理器 ESP8266 &#xff09;&#xff0c;固件版本&#xff08;MQTT固件&#xff09; 操作系统&#xff1a;rt-thread操作系统 二、ESP-01S模块介绍 ESP-01S 是由安信可科技开…
阅读更多...
【已解决】Vue3使用Element-plus按需加载时消息弹框ElMessage没有样式

【已解决】Vue3使用Element-plus按需加载时消息弹框ElMessage没有样式

Vue3使用Element-plus时消息弹框ElMessage没有样式 问题描述 Element-plus在使用ElMessage消息弹框的时候没有样式&#xff0c;按照官方的按需加载的方式引入的 1、Element-plus使用了自动按需导入&#xff0c;vite.config.js配置如下&#xff1a; plugins: [vue(),AutoImpo…
阅读更多...
【领域驱动设计专题】一文带领你透视DDD领域驱动模型的本质和设计原理分析指南（通用语言体系）

【领域驱动设计专题】一文带领你透视DDD领域驱动模型的本质和设计原理分析指南（通用语言体系）

一文带领你透视DDD领域驱动模型的本质和设计原理分析指南&#xff08;通用语言体系&#xff09; 前言介绍降低沟通成本问题&#xff1a;各自建立属于自己领域/层面的语言标准解决方案1&#xff1a;专业术语转换为接地气的话术解决方案2&#xff1a;用简单的案例和背景信息进行描…
阅读更多...
【无监督学习】1、MOCOv1 | 用于提升无监督学习效果的动量对比学习

【无监督学习】1、MOCOv1 | 用于提升无监督学习效果的动量对比学习

文章目录 一、背景二、方法2.1 对比学习&#xff08;字典查表&#xff09;2.2 动量对比函数2.3 Pretext Task 三、效果3.1 数据集3.2 训练细节3.3 实验 论文&#xff1a;Momentum Contrast for Unsupervised Visual Representation Learning 代码&#xff1a;https://github.c…
阅读更多...
【Java|多线程与高并发】wait和notify方法详解

【Java|多线程与高并发】wait和notify方法详解

文章目录 1.前言2.wait和notify的基本使用3. notifyAll方法4. wait和sleep方法的对比5. 总结 1.前言 在Java多线程环境中,线程之间是抢占式执行的,线程的调度是随机的.这就很难受了. 在很多情况下我们希望线程以我们想要的顺序来执行. 这就需要wait和notify这两个方法 2.wait和…
阅读更多...
Java——《面试题——MySQL篇》

Java——《面试题——MySQL篇》

前文 java——《面试题——基础篇》 Java——《面试题——JVM篇》 Java——《面试题——多线程&并发篇》 Java——《面试题——Spring篇》 Java——《面试题——SpringBoot篇》 目录 前文 1、数据库的三范式是什么&#xff1f; 2、MySQL数据库引擎有哪些 3、说说…
阅读更多...
【五子棋实战】第2章 博弈树负值极大alpha-beta剪枝算法

【五子棋实战】第2章 博弈树负值极大alpha-beta剪枝算法

【五子棋实战】第2章 博弈树极大极小值alpha-beta剪枝算法 博弈树 极大极小值搜索Minimax 负值极大法Negamax alpha-beta剪枝 博弈树负值极大alpha-beta剪枝算法代码实现 ## 初始化输入、确定输出 ## 开始回溯 ## 判赢 ## 评估-计算分数 总结 继续学习下一篇实战&…
阅读更多...
注解和异常的详细笔记

注解和异常的详细笔记

注解的理解 注解(Annotation)也被称为元数据(Metadata)&#xff0c;用于修饰解释 包、类、方法、属性、构造器、局部变量等数据信息。和注释一样&#xff0c;注解不影响程序逻辑&#xff0c;但注解可以被编译或运行&#xff0c;相当于嵌入在代码中的补充信息。在 JavaSE 中&am…
阅读更多...
OpenMMLab-AI实战营第二期——相关1. COCO数据集格式和pycocotools使用（目标检测方向）

OpenMMLab-AI实战营第二期——相关1. COCO数据集格式和pycocotools使用（目标检测方向）

文章目录 1. COCO数据集1.1 COCO数据集介绍1.2 COCO数据集格式1.2.1 常见目标检测数据格式1.2.2 COCO数据集文件结构及标注文件说明1.2.3 COCO的evaluation指标 1.3 其他 2. pycocotools2.1 pycocotools简介和安装2.2 基本使用 3. 图像的EXIF使用3.1 图像的EXIF3.1.1 基本介绍3…
阅读更多...
车载以太网MACsec

车载以太网MACsec

车载以太网MACsec 1.概述 MACsec&#xff08;Media Access Control Security&#xff09;定义了基于 IEEE 802 局域网络的数据安全通信的方法。MACsec 可为用户提供安全的 MAC 层数据发送和接收服务&#xff0c;包括用户数据加密&#xff08;Confidentiality&#xff09;、数…
阅读更多...
新浪股票接口获取历史数据

新浪股票接口获取历史数据

这两天做了一个调用新浪股票接口获取实时以及历史股票数据的应用&#xff0c;因为新浪没有公开关于其接口的官方文档&#xff0c;所以通过各种百度差了很多关于新浪股票接口的使用&#xff0c;不过大家基本都是转载或者直接复制&#xff0c;对于实时数据的获取讲的很详细&#…
阅读更多...
Linux【系统学习】（shell篇）

Linux【系统学习】（shell篇）

第 1 章 Shell 概述 1&#xff09;Linux 提供的 Shell 解析器有 Ubuntu 使用的是dash 2&#xff09;bash 和 sh 的关系 3&#xff09;Centos 默认的解析器是 bash 第 2 章 Shell 脚本入门 1&#xff09;脚本格式 &#xff08;结尾不是必须以 .sh 结尾&#xff0c;只是为了区…
阅读更多...
《网络安全0-100》VPN 讲解

《网络安全0-100》VPN 讲解

1、前言 VPN虽好可不要贪玩哦 2、VPN的概念和结构 VPN:虚拟专用网(virtual personal network)是利用internet等公共网络的基础设施&#xff0c;通过隧道技术&#xff0c;为用户提供的专用网络具有相同通信功能的安全数据通道。 ‘虚拟’是指用户无需建立各逻辑上的专用物理线…
阅读更多...
​AVS3支持下的8K内容生产和传输应用实践

​AVS3支持下的8K内容生产和传输应用实践

AVS标准经过20年发展&#xff0c;到AVS3这一代实现了国产标准从跟跑到领跑的突破。博雅睿视团队深度参与AVS3标准制定&#xff0c;开发的8K AVS3实时、离线编解码设备有力支持了我国8K超高清视频产业的落地和推广。 本次分享将会分为三个部分&#xff0c;第一部分重点介绍AVS标…
阅读更多...
MusicGen配乐工具开源，教你怎么给抖音短视频配乐，助你涨粉1000！

MusicGen配乐工具开源，教你怎么给抖音短视频配乐，助你涨粉1000！

大家好&#xff0c;我是千与千寻&#xff0c;好久不见了&#xff0c;很多粉丝私信我说&#xff0c;千寻哥这是去哪了&#xff1f;难道被野外捕捉了。 哈哈哈&#xff0c;当然不是了&#xff0c;千寻依然在学习ChatGPT的道路上和大家一起学习&#xff0c;一起搞钱&#xff01; 但…
阅读更多...
TC8：TCP_MSS_OPTIONS_05-09

TC8：TCP_MSS_OPTIONS_05-09

TCP_MSS_OPTIONS_05: Illegal option length for MSS in a SYN-ACK segment 目的 TCP能够处理SYN+ACK报文段中MSS选项的长度非法，而不会崩溃 可以正常地响应，就是不崩溃，这里指的应该是DUT发送ACK 测试步骤 Tester：让DUT侧的应用程序发起主动open调用DUT：发送SYNTester：…
阅读更多...
C++类和对象--构造函数和析构函数

C++类和对象--构造函数和析构函数

0.前言 在我们写某些需要动态开辟内存空间的函数时候&#xff0c;会经常忘记初始化、销毁&#xff0c;而且有时候程序返回的情况很多&#xff0c;那么销毁函数写起来就会很繁琐&#xff0c;那么有没有什么办法解决这个问题呢&#xff1f;答案是&#xff1a;当然有&#xff01;在…
阅读更多...
Java类 继承

Java类 继承

Java是一种面向对象的编程语言&#xff0c;类是Java中最基本的编程单元。一个类可以包含变量、方法和构造函数等。类的定义需要使用关键字class&#xff0c;例如&#xff1a; public class Person { private String name; private int age; public Person(St…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023