Java 【数据结构】常见排序算法实用详解(上) 插入排序/希尔排序/选择排序/堆排序【贤者的庇护】

 登神长阶

上古神器-常见排序算法

插入排序/选择排序/堆排序 


📔 一.排序算法

📕1.排序的概念

排序 :所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。
  • 稳定性:假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,r[i]=r[j],且r[i]r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序算法是稳 定的;否则称为不稳定的。
  • 内部排序:数据元素全部放在内存中的排序。
  • 外部排序:数据元素太多不能同时放在内存中,根据排序过程的要求不能在内外存之间移动数据的排序。

📗2.排序算法

        在Java中,排序算法是一种对数据集合中的元素按照特定顺序进行排列的算法。排序算法通常用于将数据按照升序或者降序排列,以便于后续的查找、插入、删除等操作。排序算法在Java中是非常常见和重要的,因为数据的排序是计算机科学中的基本问题之一,几乎所有的应用场景都需要对数据进行排序。

        在Java中,排序算法可以针对不同的数据结构实现,例如针对数组、链表、树等。常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等。每种排序算法都有其特定的实现方式、时间复杂度和空间复杂度,不同的算法在不同的场景下有着各自的优劣势。

        Java提供了丰富的API和工具类来支持排序操作。比如,可以使用 java.util.Arrays 类的 sort() 方法对数组进行排序,该方法内部使用了优化的快速排序算法或归并排序算法;另外,Java中的集合类如 ArrayListLinkedList 等也提供了 Collections.sort() 方法来对集合进行排序,同样利用了内部的排序算法来实现。

        总之,在Java中,排序算法是程序员必须掌握的基本知识之一,对排序算法的理解和掌握有助于编写出高效、可靠的Java程序。 

        在本次chapter1我们先对插入排序,希尔排序,选择排序,堆排序进行一个深度理解。

📘3.排序的运用

排序算法在Java项目中有着广泛的应用,主要体现在以下几个方面:

  1. 数据存储与检索:在实际项目中,经常需要对大量数据进行存储和检索,而这些数据可能需要按照某种顺序进行排列。例如,对于电子商务网站,商品列表需要按照价格、销量等指标进行排序,以便用户浏览和筛选。在这种情况下,可以利用Java提供的排序算法对数据进行排序,以便更高效地进行检索和展示。

  2. 数据分析与统计:在数据分析和统计领域,经常需要对大量数据进行排序以便进行分析和计算。例如,在金融领域,对交易数据进行排序可以帮助识别交易模式和规律;在科学研究中,对实验数据进行排序可以帮助找到数据的规律和趋势。Java中的排序算法可以帮助开发人员快速对数据进行排序,从而支持数据分析和统计的工作。

  3. 搜索与查找:在搜索和查找功能中,排序算法也发挥着重要作用。例如,在搜索引擎中,对搜索结果进行排序可以根据相关度、权重等指标进行排序,提高搜索结果的质量和用户体验;在数据库系统中,对数据库中的记录进行排序可以提高查询效率,加快数据检索的速度。Java中的排序算法可以帮助开发人员实现这些功能,从而提升系统的性能和用户体验。

  4. 任务调度与优先级管理:在任务调度和优先级管理中,排序算法可以帮助开发人员对任务进行排序和调度,以提高系统的响应速度和效率。例如,在操作系统中,可以利用排序算法对进程进行优先级调度,从而保证系统的稳定性和效率;在分布式系统中,可以利用排序算法对任务进行分配和调度,以实现负载均衡和资源优化。Java中的排序算法可以为开发人员提供实现这些功能的工具和方法。

        总之,排序算法在Java项目中具有广泛的应用场景,可以帮助开发人员解决各种实际问题,提高系统的性能和效率,提升用户体验。通过灵活运用各种排序算法,开发人员可以实现更加高效、稳定和可靠的Java应用程序。

📙二.插入排序

插入排序(Insertion Sort)是一种简单直观的排序算法,在实际应用中也是比较常见的一种。它的基本思想是将一个待排序的元素逐个插入到已经排序好的子序列中,直到所有元素都插入完毕。插入排序通常采用在原地排序的方式进行,不需要额外的存储空间,因此空间复杂度为 O(1)。

基本思想

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中,直到所有的记录插入完为止,得到 一个新的有序序列 。实际中我们玩扑克牌时,就用了插入排序的思想。

基本原理

  1. 从第二个元素开始,将其视为已排序的子序列:初始时,将第一个元素视为已排序的子序列。

  2. 逐个将未排序的元素插入已排序的子序列中:从第二个元素开始,依次将每个元素与已排序的子序列中的元素比较,找到合适的位置插入。

  3. 重复直到所有元素都插入完毕:重复以上步骤,直到所有元素都插入到已排序的子序列中,排序完成。

算法步骤

  1. 从第二个元素开始遍历数组。
  2. 对于当前遍历到的元素,从后往前遍历已排序的子序列,找到合适的位置插入。
  3. 插入元素后,继续遍历下一个未排序的元素,重复以上步骤直到所有元素都插入完毕。

时间复杂度

插入排序的时间复杂度取决于待排序数组的初始状态。在最好情况下,即数组已经有序,插入排序的时间复杂度为 O(n),每个元素只需要与前面的有序序列比较一次。在最坏情况下,即数组完全逆序,插入排序的时间复杂度为 O(n^2),每个元素需要与前面的有序序列比较 n-1 次。平均情况下,插入排序的时间复杂度也为 O(n^2)。

稳定性

插入排序是一种稳定的排序算法,即相等元素的相对顺序在排序前后保持不变。

适用性

  1. 小规模数组:对于小规模数组,插入排序是一个不错的选择,因为它的实现简单且性能较好。

  2. 部分有序的数组:如果数组已经部分有序,插入排序的效率会更高,因为大部分元素都在正确的位置上,只需少量的比较和移动。

  3. 稳定性要求:如果需要保持相等元素的相对顺序不变,插入排序是一个合适的选择。

  4. 链表结构:插入排序在链表结构中也适用,因为它只需要在链表中移动指针,不需要像数组一样进行元素的移动。

源代码

 /**
     * 插入排序
     * 时间复杂度:O(N^2)
     * 空间复杂度:O(1)
     * 稳定性:稳定
     * 场景:当前有一组数据 基本上趋于有序 那么就可以使用直接插入排序
     * 优点:越有序越快
     * @param array
     */
    public static void insertSort(int[] array){
        for (int i = 1; i < array.length; i++) {
            int temp=array[i];
            int j=i-1;
            for (;j>=0;j--){
                //if(array[j]>=temp)该排序就不稳定了
                if (array[j]>temp){
                    array[j+1]=array[j];
                }else{
                    break;
                }
            }
            array[j+1]=temp;
        }
    }

插入排序虽然简单,但在某些特定情况下仍然是一个有效且高效的排序算法。

📓三.希尔排序

希尔排序的基本思想原理都是建立在插入排序之上的可以进行对比学习

希尔排序法又称缩小增量法。

基本原理:

希尔排序是一种改进的插入排序算法,旨在解决插入排序在处理大规模数据时效率较低的问题。它的基本原理是通过将数组分成若干个子序列,并对每个子序列进行插入排序,然后逐步减小子序列的长度,最终达到对整个数组的排序。希尔排序利用了插入排序在局部有序情况下效率较高的特点,通过逐步缩小间隔,最终实现整体排序。

算法步骤:

  1. 选择增量序列: 首先选择一个增量序列,通常使用 Knuth 提出的序列(如 3x+1)。增量序列决定了子序列的划分方式。

  2. 分组: 将数组按照增量序列分成若干个子序列。

  3. 对每个子序列进行插入排序: 对每个子序列进行插入排序,即将每个子序列中的元素按照插入排序的方式进行排序。

  4. 逐步减小增量: 重复以上步骤,但每次使用较小的增量。这样做的目的是逐步使得数组中的元素趋于有序。

  5. 最终排序: 当增量减小到 1 时,整个数组被划分为一个子序列,这时再对整个数组进行一次插入排序,使得整个数组达到有序状态。

时间复杂度:

        希尔排序的时间复杂度不好计算,因为gap的取值方法很多,导致很难去计算,因此在好些树中给出的希尔排序的时间复杂度都不固定

        希尔排序的时间复杂度取决于增量序列的选择。最坏情况下的时间复杂度为 O(n^2),但在实践中,希尔排序通常要优于插入排序的 O(n^2)。理想情况下,时间复杂度为 O(n log^2 n),这是一个未解决的数学问题。

稳定性:

希尔排序是不稳定的排序算法。因为在排序过程中,相同元素的相对位置可能会改变,取决于增量序列的选择和具体的实现方式。

适用性:

  • 希尔排序适用于中等大小的数组,特别是对于需要排序的数据量较大但内存有限的情况。
  • 由于希尔排序是原地排序算法,不需要额外的空间开销,因此适用于内存有限的环境。
  • 在大多数情况下,希尔排序的性能要优于简单的插入排序和冒泡排序,但可能不如快速排序、归并排序等高级排序算法
/**
     * 希尔排序
     * 时间复杂度:O(logN)
     * 空间复杂度:O(1)
     * 稳定性:不稳定
     * @param array
     */
    public static void shellSort(int[] array){
        int gap=array.length;
        while(gap>1){
            gap=gap/3+1;
            shell(array,gap);
        }
    }

    public static void shell(int[] array,int gap){
        for (int i = gap; i < array.length; i++) {
            int temp=array[i];
            int j=i-gap;
            for (;j>=0;j-=gap){
                if (array[j]>temp){
                    array[j+gap]=array[j];
                }else{
                    break;
                }
            }
            array[j+gap]=temp;
        }
    }

希尔排序通过优化插入排序的步骤和增量序列的选择,提高了对大规模数据的排序效率,是一种常用的排序算法之一。

📒四.选择排序

选择排序相对是一种更为简单更为直接的排序算法。

基本原理:

选择排序(Selection Sort)是一种简单直观的排序算法,其基本原理是每次从待排序的数据中选择最小(或最大)的元素,放到已排序序列的末尾。通过不断重复这个过程,直到所有元素都被排序完毕。

算法步骤:

  1. 找到最小元素: 遍历未排序部分的数组,找到最小(或最大)的元素。

  2. 交换位置: 将最小的元素与未排序部分的第一个元素交换位置,将其放到已排序序列的末尾。

  3. 逐步缩小范围: 缩小未排序部分的范围,将已排序部分扩大一个元素。

  4. 重复直至完成: 重复以上步骤,直到所有元素都被排序完毕。

时间复杂度:

选择排序的时间复杂度始终为 O(n^2),无论输入数据的情况如何,因为它每次都要遍历未排序部分的数组来找到最小元素。

稳定性:

选择排序是一种不稳定的排序算法,因为在选择的过程中,相同元素的相对位置可能会改变。例如,在排序过程中,如果有两个相同的最小元素,它们的相对位置可能会发生变化。

适用性:

  • 选择排序适用于小型数组或者简单实现的排序场景。
  • 它是一种原地排序算法,不需要额外的空间开销,因此适用于内存有限的环境。
  • 尽管选择排序的时间复杂度较高,但对于简单的排序任务,或者当内存不足以容纳更复杂的算法时,选择排序仍然是一个合理的选择。
 /**
     * 选择排序
     * 时间复杂度:和数据是否有序无关。均是O(N^2)
     * 空间复杂度: O(1)
     * 稳定性:不稳定的排序
     * @param array
     */
    public static void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            int minIndex=i;
            for (int j = i+1; j < array.length ; j++) {
                if (array[minIndex]>array[j]){
                    minIndex=j;
                }
            }
            int cur=array[i];
            array[i]=array[minIndex];
            array[minIndex]=cur;
        }
    }

    public static void selectSort2(int[] array){
        int left=0;
        int right=array.length-1;
        while(left<right) {
            int minIndex=left;
            int maxIndex=left;
            for (int i = left+1; i <= right; i++) {
                if (array[i]<array[minIndex]){
                    minIndex=i;
                }
                if (array[i]>array[maxIndex]){
                    maxIndex=i;
                }
            }
            swap(array,minIndex,left);
            if (maxIndex==left){
                maxIndex=minIndex;
            }
            swap(array,maxIndex,right);
            left++;
            right--;
        }
    }

    public static void swap(int[] arr,int a,int b){
        int cur=arr[a];
        arr[a]=arr[b];
        arr[b]=cur;
    }

上述代码之中,selectSort2算是选择排序的一种优化 

选择排序虽然简单,但是其效率较低,特别是在大规模数据的情况下。在实际应用中,往往会选择更高效的排序算法,如快速排序、归并排序等。

📃五.堆排序

基本原理:

堆排序(Heap Sort)是一种基于二叉树(Java 【数据结构】 二叉树(Binary_Tree))数据结构的排序算法。它的基本原理是首先将待排序的数组构建成一个最大堆(或最小堆),然后逐步将堆顶元素(最大元素或最小元素)与堆的最后一个元素交换位置,并将剩余元素重新调整为一个最大堆(或最小堆),重复这个过程直至整个数组有序。

需要注意的是排升序要建大堆,排降序建小堆。

算法步骤:

  1. 构建堆: 将待排序的数组看作是一个完全二叉树,并按照从下往上、从右往左的顺序,对每个非叶子节点进行堆化操作,使得整个数组构成一个堆结构(通常是最大堆)。

  2. 堆排序: 将堆顶元素(最大元素或最小元素)与堆的最后一个元素交换位置,然后将剩余元素重新调整为一个最大堆(或最小堆)。

  3. 重复直至完成: 重复上述堆排序步骤,每次将堆的大小减少 1,并重新调整堆结构,直至整个数组有序。

时间复杂度:

堆排序的时间复杂度为 O(n log n),其中 n 是待排序数组的大小。这是因为堆的构建需要 O(n) 的时间,而每次堆调整(包括堆化和交换操作)的时间复杂度为 O(log n),总共需要进行 n 次调整。

稳定性:

堆排序是一种不稳定的排序算法,因为在堆的调整过程中,相同元素的相对位置可能会发生改变。

适用性:

  • 堆排序适用于大规模数据的排序,特别是对于需要稳定性较好的排序算法。
  • 它是一种原地排序算法,不需要额外的空间开销,因此适用于内存有限的环境。
  • 尽管堆排序的时间复杂度较高,但由于其稳定性和原地排序的特性,仍然是一种常用的排序算法。
/**
     * 堆排序
     * 时间复杂度:O(N*logN)
     * 空间复杂度:O(1)
     * 稳定性:不稳定
     * @param arr
     */
    public static void heapSort(int[] arr){
        makebigHeap(arr);
        int end=arr.length-1;
        while(end>=0){
            swap(arr,0,end);
            siftDown(0,arr,end);
            end--;
        }
    }

    public static void makebigHeap(int[] arr){
        for (int parent = (arr.length-1-1)/2; parent >=0; parent--) {
            siftDown(parent,arr,arr.length);
        }
    }

    public static void siftDown(int parent,int[] arr,int end){
        int child=parent*2+1;
        while(child<end){
            if (child+1<end&&arr[child+1]>arr[child]){
                child++;
            }
            if (arr[child]>arr[parent]){
                swap(arr,child,parent);
                parent=child;
                child=parent*2+1;
            }else{
                break;
            }
        }
    }
}

堆排序通过利用堆的特性,实现了对大规模数据的高效排序,是一种重要的排序算法之一。

📑六.总结与反思

生命的路是进步的,总是沿着无限的精神三角形的斜面向上走,什么都阻止他不得。--鲁迅

        在学习了插入排序、希尔排序、堆排序和选择排序之后,我对这些经典的排序算法有了更深入的理解和反思。

插入排序

  • 原理: 插入排序是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
  • 特点: 简单易懂,稳定,对于小规模数据或者基本有序的数据效果较好。
  • 反思: 尽管插入排序简单,但对于大规模数据的排序效率较低,时间复杂度为 O(n^2)。在数据量较大时,不太适用。

希尔排序

  • 原理: 希尔排序是插入排序的一种改进,通过设置一个增量序列,对数组进行分组并进行插入排序,随着增量的逐渐减小,最终整个数组变为有序。
  • 特点: 相较于插入排序,希尔排序在大规模数据下有着更好的性能,时间复杂度在 O(n log n) 到 O(n^2) 之间。
  • 反思: 希尔排序的性能高度依赖于增量序列的选择,不同的增量序列可能导致不同的性能表现,而且实现起来较为复杂。

堆排序

  • 原理: 堆排序利用堆这种数据结构,将待排序的序列构建成一个大顶堆或小顶堆,然后每次取堆顶元素并重新调整堆,直至整个序列有序。
  • 特点: 堆排序具有较高的性能,时间复杂度稳定在 O(n log n)。
  • 反思: 堆排序虽然性能较高,但实现起来较为复杂,需要对堆这种数据结构有深入的理解。另外,堆排序是一种不稳定排序算法。

选择排序

  • 原理: 选择排序是一种简单直观的排序算法,每次从待排序序列中选出最小(或最大)的元素,放到已排序序列的末尾,直至整个序列有序。
  • 特点: 选择排序实现简单,不需要额外的空间,但性能较差,时间复杂度稳定在 O(n^2)。
  • 反思: 选择排序虽然简单,但由于每次都需要找到最小(或最大)元素,导致了不必要的交换次数,因此在大规模数据下不适用。

总结与选择

  • 在实际应用中,需要根据数据规模、数据特点和性能要求等因素综合考虑选择合适的排序算法。
  • 对于小规模数据或基本有序的数据,可以选择插入排序;
  • 对于大规模数据,希尔排序和堆排序是较为合适的选择,具有较好的性能;
  • 选择排序虽然简单,但性能较差,不适用于大规模数据的排序。

综上所述,了解和掌握各种排序算法的原理、特点和实现方法,能够在实际应用中选择合适的排序算法,并对算法进行优化,提高程序的性能。


🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀

以上,就是本期的全部内容啦,若有错误疏忽希望各位大佬及时指出💐

  制作不易,希望能对各位提供微小的帮助,可否留下你免费的赞呢🌸

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

【Python】函数设计

1.联系函数的设计 2.找质数 3.找因子 4.判断水仙花数 5.斐波拉契数列递归调用&#xff0c;并用数组存储已计算过的数&#xff0c;减少重复计算 1、计算利息和本息 编写两个函数分别按单利和复利计算利息,根据本金、年利率、存款年限得到本息和和利息。调用这两个函数计算1…

学习Rust的第22天:mini_grep第2部分

书接上文&#xff0c;在本文中&#xff0c;我们学习了如何通过将 Rust 程序的逻辑移至单独的库箱中并采用测试驱动开发 (TDD) 实践来重构 Rust 程序。通过在实现功能之前编写测试&#xff0c;我们确保了代码的可靠性。我们涵盖了基本的 Rust 概念&#xff0c;例如错误处理、环境…

【linux-汇编-点灯之思路-程序】

目录 1. ARM汇编中的一些注意事项2. IMXULL汇编点灯的前序&#xff1a;3. IMXULL汇编点灯之确定引脚&#xff1a;4. IMXULL汇编点灯之引脚功能编写&#xff1a;4.1 第一步&#xff0c;开时钟4.2 第二步&#xff0c;定功能&#xff08;MUX&#xff09;4.3 第三步&#xff0c;定电…

【笔试训练】day17

1.小乐乐该数字 遇到按位处理的情况可以考虑用字符串去读 代码&#xff1a; #define _CRT_SECURE_NO_WARNINGS 1 #include <iostream> #include<string> using namespace std;int main() {string str;cin >> str;int ans 0;for (int i 0; i < str.siz…

JavaEE 初阶篇-深入了解 Junit 单元测试框架和 Java 中的反射机制(使用反射做一个简易版框架)

&#x1f525;博客主页&#xff1a; 【小扳_-CSDN博客】 ❤感谢大家点赞&#x1f44d;收藏⭐评论✍ 文章目录 1.0 Junit 单元测试框架概述 1.1 使用 Junit 框架进行测试业务代码 1.2 Junit 单元测试框架的常用注解&#xff08;Junit 4.xxx 版本&#xff09; 2.0 反射概述 2.1 获…

神经网络中的优化方法

一、引入 在传统的梯度下降优化算法中&#xff0c;如果碰到平缓区域&#xff0c;梯度值较小&#xff0c;参数优化变慢 &#xff0c;遇到鞍点&#xff08;是指在某些方向上梯度为零而在其他方向上梯度非零的点。&#xff09;&#xff0c;梯度为 0&#xff0c;参数无法优化&…

机器人系统ros2-开发实践04-ROS2 中 tf2的定义及示例说明

1. what ros2 tf2 &#xff1f; tf2的全称是transform2&#xff0c;在ROS&#xff08;Robot Operating System&#xff09;中&#xff0c;它是专门用于处理和变换不同坐标系间位置和方向的库。这个名字来源于“transform”这个词&#xff0c;表示坐标变换&#xff0c;而“2”则…

【Leetcode每日一题】 动态规划 - 简单多状态 dp 问题 - 删除并获得点数(难度⭐⭐)(70)

1. 题目解析 题目链接&#xff1a;740. 删除并获得点数 这个问题的理解其实相当简单&#xff0c;只需看一下示例&#xff0c;基本就能明白其含义了。 2.算法原理 问题分析 本题是「打家劫舍」问题的变种&#xff0c;但核心逻辑依然保持一致。题目要求从给定的数组nums中选择…

C++ stack和queue的使用方法与模拟实现

文章目录 一、 stack的使用方法二、 queue的使用方法三、 容器适配器四、 stack的模拟实现五、 queue的模拟实现 一、 stack的使用方法 stack介绍文档 stack是一种容器适配器&#xff0c;专门用在具有后进先出操作的上下文环境中&#xff0c;其删除只能从容器的一端进行元素的…

Windows如何通过wsl2迅速启动Docker desktop的PHP的Hyperf项目容器?

一、安装WSL 什么是WSL&#xff1f; 官网&#xff1a;什么是WSL&#xff1f; Windows Subsystem for Linux (WSL) 是一个在Windows 10和Windows 11上运行原生Linux二进制可执行文件的兼容性层。 换句话说&#xff0c;WSL让你可以在Windows系统上运行Linux环境&#xff0c;而无需…

【linux】unzip解压乱码或者报错处理办法

✨✨ 欢迎大家来到景天科技苑✨✨ 🎈🎈 养成好习惯,先赞后看哦~🎈🎈 🏆 作者简介:景天科技苑 🏆《头衔》:大厂架构师,华为云开发者社区专家博主,阿里云开发者社区专家博主,CSDN全栈领域优质创作者,掘金优秀博主,51CTO博客专家等。 🏆《博客》:Python全…

2023-2024年数字化转型报告/方案合集(精选198份)

数字化转型报告/方案&#xff08;精选198份&#xff09; 2023-2024年 来源&#xff1a;2023-2024年数字化转型报告/方案合集&#xff08;精选198份&#xff09; 【以下是资料目录】 2023-2024年度医药健康行业数字化调研报告 2023-2024中国财务数字化报告 2023⻝品饮料行业…

Redis运维篇-快速面试笔记(速成版)

文章目录 1. Redis的持久化1.1 RDB&#xff08;快照模式&#xff09;1.2 AOF 模式 2. Redis主从模型&#xff08;高可用&#xff09;2.1 Redis的主从复制2.2 Redis拓扑结构 3. Redis集群模式&#xff08;高并发&#xff09;3.1 Redis的Slots3.2 集群模式的常用命令3.3 多主多从…

使用 MediaMTX 和 FFmpeg 推拉 RTSP 流媒体

实时流传输协议 RTSP&#xff08;Real-Time Streaming Protocol&#xff09;是 TCP/IP 协议体系中的一个应用层协议&#xff0c;由哥伦比亚大学、网景和 RealNetworks 公司提交的 IETF RFC 标准。该协议定义了一对多应用程序如何有效地通过 IP 网络传送多媒体数据。RTSP 在体系…

Unity射击游戏开发教程:(8)构建 UI 元素:添加分数显示

用户界面决定用户如何与屏幕交互。UI 适用于所有类型的游戏和应用程序,在此示例中,我们将为我的太空射击游戏设置一个简单的记分板。 第一步是在层次结构中创建一个 UI 元素。只需在层次结构中右键单击,滚动 UI 并选择要添加的 UI 元素类型。在本例中,我们将使用文本元素。…

STM32入门_江协科技_3~4_OB记录的自学笔记_软件安装新建工程

3. 软件安装 3.1. 安装Keil5 MDK 作者的资料下载的连接如下&#xff1a;https://jiangxiekeji.com/download.html#32 3.2. 安装器件支持包 因为新的芯片层出不穷&#xff0c;所以需要安装Keil5提供的器件升级版对软件进行升级&#xff0c;从而支持新的芯片&#xff1b;如果不…

如何将 redis 快速部署为 docker 容器?

部署 Redis 作为 Docker 容器是一种快速、灵活且可重复使用的方式&#xff0c;特别适合开发、测试和部署环境。本文将详细介绍如何将 Redis 部署为 Docker 容器&#xff0c;包括 Docker 安装、Redis 容器配置、数据持久化、网络设置等方面。 步骤 1&#xff1a;安装 Docker 首…

ICode国际青少年编程竞赛- Python-1级训练场-基本操作

ICode国际青少年编程竞赛- Python-1级训练场-基本操作 1、 Dev.step(3)2、 Dev.step(1)3、 Dev.step(7)4、 Dev.step(-1)5、 Dev.step(-5)6、 Dev.step(3) Dev.step(-8)7、 Dev.turnRight() Dev.step(1)8、 Dev.turnLeft() Dev.step(1)9、 Dev.step(4) Dev.tur…

串的模式匹配之BF算法实现

概述 BF算法-暴力枚举 匹配失败处理 匹配成功结束 算法思想 代码实现 定义串的存储结构&#xff1a;装字符的ch数组标记长度的length 最坏时间复杂度分析 代码整合

微调Mistral 7B以实现命名实体识别 (NER)

文章来源&#xff1a;fine-tuning-mistral-7b-for-named-entity-recognition-ner 2024 年 4 月 19 日 在自然语言处理&#xff08;NLP&#xff09;领域&#xff0c;命名实体识别&#xff08;NER&#xff09;被认为是一项关键任务&#xff0c;应用范围广泛&#xff0c;包括信息…