Day_43插入排序

news2024/11/24 5:38:47

目录

一. 关于插入排序

        1. 排序的定义

        2. 插入排序

二. 插入排序的实现过程

三. 代码实现过程

        1. 插入排序核心代码

四. 代码展示

五. 数据测试

六. 总结

一. 关于插入排序

        1. 排序的定义

        排序，就是重新排列表中的元素，使表中的元素满足按关键字有序的过程。为了查找方便，通常希望计算机中的表是按关键字有序的。排序的确切定义如下：

        输入：n个记录R_{1},R_{2}...R_{n}，对应的关键字为k_{1},k_{2}...k_{n}。

        输出:输入序列的一个重排R_{1}^{'},R_{2}^{'}...R_{n}^{'}使得k_{1}^{'}\leqslant k_{2}^{'}\leqslant ...\leqslant k_{n}^{'}; (其中“≤”可以换成其他的比较大小的符号)。

        算法的稳定性。若待排序表中有两个元素R_{i}和R_{j}其对应的关键字相同即key_{i}=key_{j}，且在排序前R_{i}在R_{j}的前面，若使用某一排序算法排序后，R_{i}仍然在R_{j}的前面，则称这个排序算法是稳定的，否则称排序算法是不稳定的。需要注意的是，算法是否具有稳定性并不能衡量一个算法的优劣，它主要是对算法的性质进行描述。如果待排序表中的关键字不允许重复，则排序结果是唯一的，那么选择排序算法时的稳定与否就无关紧要。对于不稳定的排序算法，只需举出一组关键字的实例，说明它的不稳定性即可。

        在排序过程中，根据数据元素是否完全在内存中，可将排序算法分为两类：①内部排序，是指在排序期间元素全部存放在内存中的排序；②外部排序，是指在排序期间元素无法全部同时存放在内存中，必须在排序的过程中根据要求不断地在内、外存之间移动的排序。一般情况下，内部排序算法在执行过程中都要进行两种操作：比较和移动。通过比较两个关键字的大小，确定对应元素的前后关系，然后通过移动元素以达到有序。当然，并非所有的内部排序算法都要基于比较操作，事实上，基数排序就不基于比较。

        每种排序算法都有各自的优缺点，适合在不同的环境下使用，就其全面性能而言，很难提出一种被认为是最好的算法。通常可以将排序算法分为插入排序、交换排序、 选择排序、归并排序和基数排序五大类。内部排序算法的性能取决于算法的时间复杂度和空间复杂度，而时间复杂度一 般是由比较和移动的次数决定的。

        2. 插入排序

        插入排序是最简单直观的排序方法，其基本思想是每次将一个待排序的记录按其关键字大小插入前面已排好序的子序列，直到全部记录插入完成。由插入排序的思想可以引申出三个重要的排序算法：直接插入算法，折半插入算法和希尔排序算法。

二. 插入排序的实现过程

        根据上面的插入排序思想，不难得出一种最简单也最直观的直接插入排序算法。

        1）查找出L(i)在L[1,...i-1]中的插入位置k

        2)将L[k,...i-1]中的所有元素依次向后移动一个位置

        3)将L(i)复制到L(k)

        为了实现对L[1,...n]的排序，可以将L(2)-L(n)依次插入前面已排好序的子序列，初始L(1)可以视为是一个已排好序的子序列。上述操作执行n-1次就能得到一个有序的表。插入排序在实现上通常采用就地模式(时间复杂度为O(1))，因而在从后向前的比较过程中，需要反复把已排序元素逐步向后挪位，为新元素提供插入空间。

                

直接插入排序计算过程示意图

 

三. 代码实现过程

        1. 插入排序核心代码

        代码就一部分，关键就是理解从i=2...n开始判断，寻找在已排好序的数组里面i的位置，并且将之前大于i的数字向后面移位，直到空出一个位置，将节点i填入即可。注意这里我们添加了哨兵位，即这个位置上面的数是所有需要排序里面最小的，若节点i一直比较到哨兵位之后，自动结束循环。

    /**
     *********************
     * Insertion sort. data[0] does not store a valid data. data[0].key should
     * be smaller than any valid key.
     *********************
     */
    public void insertionSort() {
        DataNode tempNode;
        int j;
        for (int i = 2; i < length; i++) {
            tempNode = data[i];

            //Find the position to insert.
            //At the same time, move other nodes.
            for (j = i - 1; data[j].key > tempNode.key; j--) {
                data[j + 1] = data[j];
            } // Of for j

            //Insert.
            data[j + 1] = tempNode;

            System.out.println("Round " + (i - 1));
            System.out.println(this);
        } // Of for i
    }// Of insertionSort

四. 代码展示

        主类：

package Day_43;

import Day_41.DataArray;

public class demo1 {
    /**
     *********************
     * The entrance of the program.
     *
     * @param args Not used now.
     *********************
     */
    public static void main(String args[]) {
//        System.out.println("\r\n-------sequentialSearchTest-------");
        int []paraKeyArray;
        paraKeyArray=new int[]{11,2,3};
        String[] paraContentArray = new String[]{"121","21","324"};
        DataArray test=new DataArray(paraKeyArray,paraContentArray);

//        test.insertionSort();
//        System.out.println("Result\r\n" + test);
        test.insertionSortTest();


    }// Of main
}

        调用类：(这里我包括了所有关于查找排序的代码，这样符合封装的思想)

package Day_41;
/**
 * Data array for searching and sorting algorithms.
 *
 * @author Jian An 2569222191@qq.com.
 */
public class DataArray {
    /**
     * An inner class for data nodes. The text book usually use an int value to
     * represent the data. I would like to use a key-value pair instead.
     */
    class DataNode {
        /**
         * The key.
         */
        int key;

        /**
         * The data content.
         */
        String content;

        /**
         * ********************
         * The first constructor.
         * ********************
         */
        DataNode(int paraKey, String paraContent) {
            key = paraKey;
            content = paraContent;
        }// Of the first constructor

        /**
         * ********************
         * Overrides the method claimed in Object, the superclass of any class.
         * ********************
         */
        public String toString() {
            return "(" + key + ", " + content + ") ";
        }// Of toString
    }// Of class DataNode

    /**
     * The data array.
     */
    DataNode[] data;

    /**
     * The length of the data array.
     */
    int length;

    /**
     * ********************
     * The first constructor.
     *
     * @param paraKeyArray     The array of the keys.
     * @param paraContentArray The array of contents.
     *                         ********************
     */
    public DataArray(int[] paraKeyArray, String[] paraContentArray) {
        length = paraKeyArray.length;
        data = new DataNode[length];

        for (int i = 0; i < length; i++) {
            data[i] = new DataNode(paraKeyArray[i], paraContentArray[i]);
        } // Of for i
    }// Of the first constructor

    /**
     * ********************
     * Overrides the method claimed in Object, the superclass of any class.
     * ********************
     */
    public String toString() {
        String resultString = "I am a data array with " + length + " items.\r\n";
        for (int i = 0; i < length; i++) {
            resultString += data[i] + " ";
        } // Of for i

        return resultString;
    }// Of toString

    /**
     * ********************
     * Sequential search. Attention: It is assume that the index 0 is NOT used.
     *
     * @param paraKey The given key.
     * @return The content of the key.
     * ********************
     */
    public String sequentialSearch(int paraKey) {
        data[0].key = paraKey;

        int i;
        // Note that we do not judge i >= 0 since data[0].key = paraKey.
        // In this way the runtime is saved about 1/2.
        // This for statement is equivalent to
        //for (i = length - 1; data[i].key != paraKey; i--);
        for (i = length - 1; data[i].key != paraKey; i--) {
            ;
        }//Of for i
        return data[i].content;
    }// Of sequentialSearch

    /**
     * ********************
     * Test the method.
     * ********************
     */
    public static void sequentialSearchTest() {
        int[] tempUnsortedKeys = {-1, 5, 3, 6, 10, 7, 1, 9};
        String[] tempContents = {"null", "if", "then", "else", "switch", "case", "for", "while"};
        DataArray tempDataArray = new DataArray(tempUnsortedKeys, tempContents);

        System.out.println(tempDataArray);

        System.out.println("Search result of 10 is: " + tempDataArray.sequentialSearch(10));
        System.out.println("Search result of 5 is: " + tempDataArray.sequentialSearch(5));
        System.out.println("Search result of 4 is: " + tempDataArray.sequentialSearch(4));
    }// Of sequentialSearchTest

    /**
     * ********************
     * Binary search. Attention: It is assume that keys are sorted in ascending
     * order.
     *
     * @param paraKey The given key.
     * @return The content of the key.
     * ********************
     */
    public String binarySearch(int paraKey) {
        int tempLeft = 0;
        int tempRight = length - 1;
        int tempMiddle = (tempLeft + tempRight) / 2;

        while (tempLeft <= tempRight) {
            tempMiddle = (tempLeft + tempRight) / 2;
            if (data[tempMiddle].key == paraKey) {
                return data[tempMiddle].content;
            } else if (data[tempMiddle].key <= paraKey) {
                tempLeft = tempMiddle + 1;
            } else {
                tempRight = tempMiddle - 1;
            }
        } // Of while

        // Not found.
        return "null";
    }// Of binarySearch

    /**
     * ********************
     * Test the method.
     * ********************
     */
    public static void binarySearchTest() {
        int[] tempSortedKeys = {1, 3, 5, 6, 7, 9, 10};
        String[] tempContents = {"if", "then", "else", "switch", "case", "for", "while"};
        DataArray tempDataArray = new DataArray(tempSortedKeys, tempContents);

        System.out.println(tempDataArray);

        System.out.println("Search result of 10 is: " + tempDataArray.binarySearch(10));
        System.out.println("Search result of 5 is: " + tempDataArray.binarySearch(5));
        System.out.println("Search result of 4 is: " + tempDataArray.binarySearch(4));
    }// Of binarySearchTest

//    ----------------------------------------------------
//    ----------------------------------------------------
//    ----------------------------------------------------


    /**
     *********************
     * The second constructor. For Hash code only. It is assumed that
     * paraKeyArray.length <= paraLength.
     *
     * @param paraKeyArray     The array of the keys.
     * @param paraContentArray The array of contents.
     * @param paraLength       The space for the Hash table.
     *********************
     */
    public DataArray(int[] paraKeyArray, String[] paraContentArray, int paraLength) {
        // Step 1. Initialize.
        length = paraLength;
        data = new DataNode[length];

        for (int i = 0; i < length; i++) {
            data[i] = null;
        } // Of for i

        // Step 2. Fill the data.
        int tempPosition;

        for (int i = 0; i < paraKeyArray.length; i++) {
            // Hash.
            tempPosition = paraKeyArray[i] % paraLength;

            // Find an empty position
            while (data[tempPosition] != null) {
                tempPosition = (tempPosition + 1) % paraLength;
                System.out.println("Collision, move forward for key " + paraKeyArray[i]);
            } // Of while

            data[tempPosition] = new DataNode(paraKeyArray[i], paraContentArray[i]);
        } // Of for i
    }// Of the second constructor

    /**
     *********************
     * Hash search.
     *
     * @param paraKey The given key.
     * @return The content of the key.
     *********************
     */
    public String hashSearch(int paraKey) {
        int tempPosition = paraKey % length;
        while (data[tempPosition] != null) {
            if (data[tempPosition].key == paraKey) {
                return data[tempPosition].content;
            } // Of if
            System.out.println("Not this one for " + paraKey);
            tempPosition = (tempPosition + 1) % length;
        } // Of while

        return "null";
    }// Of hashSearch

    /**
     *********************
     * Test the method.
     *********************
     */
    public static void hashSearchTest() {
        int[] tempUnsortedKeys = { 16, 33, 38, 69, 57, 95, 86 };
        String[] tempContents = { "if", "then", "else", "switch", "case", "for", "while" };
        DataArray tempDataArray = new DataArray(tempUnsortedKeys, tempContents, 19);

        System.out.println(tempDataArray);

        System.out.println("Search result of 95 is: " + tempDataArray.hashSearch(95));
        System.out.println("Search result of 38 is: " + tempDataArray.hashSearch(38));
        System.out.println("Search result of 57 is: " + tempDataArray.hashSearch(57));
        System.out.println("Search result of 4 is: " + tempDataArray.hashSearch(4));
    }// Of hashSearchTest


//    ----------------------------------------------------
//    ----------------------------------------------------
//    ----------------------------------------------------

    /**
     *********************
     * Insertion sort. data[0] does not store a valid data. data[0].key should
     * be smaller than any valid key.
     *********************
     */
    public void insertionSort() {
        DataNode tempNode;
        int j;
        for (int i = 2; i < length; i++) {
            tempNode = data[i];

            //Find the position to insert.
            //At the same time, move other nodes.
            for (j = i - 1; data[j].key > tempNode.key; j--) {
                data[j + 1] = data[j];
            } // Of for j

            //Insert.
            data[j + 1] = tempNode;

            System.out.println("Round " + (i - 1));
            System.out.println(this);
        } // Of for i
    }// Of insertionSort

    /**
     *********************
     * Test the method.
     *********************
     */
    public static void insertionSortTest() {
        int[] tempUnsortedKeys = { -100, 5, 3, 6, 10, 7, 1, 9 };
        String[] tempContents = { "null", "if", "then", "else", "switch", "case", "for", "while" };
        DataArray tempDataArray = new DataArray(tempUnsortedKeys, tempContents);

        System.out.println(tempDataArray);

        tempDataArray.insertionSort();
        System.out.println("Result\r\n" + tempDataArray);



    }// Of insertionSortTest

}// Of class DataArray

五. 数据测试

        运算结果：

六. 总结

        这一小节的知识很简单，最基础的插入排序的内容，其核心思想是每次选定一个需要插入的节点，判断位置信息，由于是原地计算需要移动位置，最后将需要插入的节点填入即可。这里的直接插入排序不仅仅可以应用于顺序表，同样它也可以应用于链表。

        直接插入算法给我们提供了一个思路，这为我们后面学习希尔排序打了一个基础。

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

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

相关文章

AIGC与AidLux互联应用——AidLux端AIGC测评（二）PC端云端Stable Diffusion模型推理应用(文生图，图生图)

AIGC与AidLux互联应用——AidLux端AIGC测评（二）PC端云端Stable Diffusion模型推理应用(文生图，图生图)

在这里插入图片描述 Stable Diffusion模型搭建首先下载diffusers&#xff0c;然后安装&#xff0c;命令如下&#xff1a; git clone https://github.com/huggingface/diffusers.git pip install diffusers cd diffusers pip install . ubuntu和win系统下都可以 文生图&#x…
阅读更多...
React Hooks 组件化开发（常用）

React Hooks 组件化开发（常用）

本文章视频地址&#xff1a;视频链接 一、React组件分类 二、Hook函数概览 Hook 是 React 16.8 的新增特性&#xff01;并且只能运用到函数组件中&#xff01; 1.useState 作用&#xff1a;在函数组件中使用状态&#xff0c;修改状态值可让函数组件更新&#xff0c;类似于类…
阅读更多...
鸿蒙初识

鸿蒙初识

学习官网&#xff1a;https://www.harmonyos.com/cn/develop 准备 注册&#xff0c;安装软件(node:12, DevEco Studio)&#xff1a; 在实际开发中node最好使用nvm进行版本管理。 https://developer.harmonyos.com/cn/docs/documentation/doc-guides/software_install-00000010…
阅读更多...
ChatGPT-Plugins-Searchable

ChatGPT-Plugins-Searchable

ChatGPT Plus 用户应该都知道Plus已经开放了插件功能&#xff0c;但是在插件商店里存在一个较大的问题插件数量超过100款&#xff0c;却没有便捷的搜索功能。 而我们在查找一款插件时&#xff0c;需要从插件商店的第一页点击到最后一页一个个找&#xff0c;显然这非常的麻烦。 …
阅读更多...
驱动开发--驱动模块

驱动开发--驱动模块

目录 1.驱动模块 hello.c Makefile 2.内核中的打印函数&#xff08;编写第一个驱动程序&#xff09; Source Insight 使用&#xff1a; 3.打印函数编写 分析 4、驱动的多文件编译 5、模块传递参数 6、安装好驱动之后如何传参&#xff1f; 7、字符设备驱动 8、字符设…
阅读更多...
chatgpt赋能python：Python如何突破VIP限制

chatgpt赋能python：Python如何突破VIP限制

Python如何突破VIP限制 在这个数字内容时代&#xff0c;我们经常使用各种网站和应用程序来获取视频、音乐、软件等数字资源。但是&#xff0c;某些资源可能受到VIP限制&#xff0c;这意味着我们需要付费才能获得完整的访问权限。但是&#xff0c;如果你了解Python编程&#xf…
阅读更多...
Agile | 聊聊敏捷开发

Agile | 聊聊敏捷开发

什么是敏捷开发 敏捷开发是一种迭代和增量的项目管理方法&#xff0c;优先考虑适应性、协作和快速交付&#xff0c;而不是遵循严格的计划[0]。它是在《敏捷软件开发宣言》和《12项原则》中表达的一组价值观和原则[1]。敏捷是基于这些价值观和原则的一组框架和实践的总称。敏捷…
阅读更多...
【数据库】修改数据库密码及端口

【数据库】修改数据库密码及端口

一、修改MySQL配置文件 想要在没有密码的状态下修改MySQL的密码&#xff0c;必须跳过MySQL登录时的登录密码权限的验证&#xff0c;取消掉这个验证的方式如下&#xff1a; 1、找到MySQL的安装文件中的my.ini文件 一般人应该能找到的吧&#xff0c;配置MySQL的环境变量中也有安…
阅读更多...
关于数据中心机房动环监控系统的应用与设计 安科瑞 许敏

关于数据中心机房动环监控系统的应用与设计 安科瑞 许敏

摘 要&#xff1a; 机房动力和环境监控系统是对分布的精密机房及通信局&#xff08;站&#xff09;内的电源、空调、油机、蓄电池、高低压配电等多种设备和环境的各种参数、图像、声音等进行遥测、并对设备进行集中监控、集中维护和集中管理&#xff0c;是现代化机房管理手段和…
阅读更多...
【Leetcode -138.复制带随机指针的链表 -2130.链表最大孪生和】

【Leetcode -138.复制带随机指针的链表 -2130.链表最大孪生和】

Leetcode Leetcode -138.复制带随机指针的链表Leetcode -2130.链表最大孪生和 Leetcode -138.复制带随机指针的链表 题目&#xff1a;给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构…
阅读更多...
chatgpt赋能python：Python如何设置画笔颜色

chatgpt赋能python：Python如何设置画笔颜色

Python如何设置画笔颜色 在Python中&#xff0c;有很多库可以用来画图&#xff0c;比如常用的Matplotlib、Seaborn和Plotly等等&#xff0c;但无论是哪种库&#xff0c;设置画笔颜色都是非常基础且重要的操作&#xff0c;因为它可以让我们更好地展示数据图表&#xff0c;突出重…
阅读更多...
【TCP/IP】基于UDP的服务器端/客户端实现 II - 实践与实现

【TCP/IP】基于UDP的服务器端/客户端实现 II - 实践与实现

基于UDP的回声服务器端/客户端 结合之前基于TCP实现的回声服务器&#xff0c;我们尝试再用UDP来完成对回声服务器/客户端的设计。 echo_server: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <arpa…
阅读更多...
内蒙古自治区关于加快充换电基础设施建规划 安科瑞 许敏

内蒙古自治区关于加快充换电基础设施建规划 安科瑞 许敏

摘要&#xff1a;为深入贯彻落实《国务院办公厅关于印发新能源汽车产业发展规划&#xff08;2021—2035年&#xff09;的通知》&#xff08;国办发 ﹝2020﹞39号&#xff09;、《国家发展改革委等部门关于进一步提升电动汽车充电基础设施服务保障能力的实施意见》&#xff08;发…
阅读更多...
异常值检验(t分布查表)、方差分析

异常值检验(t分布查表)、方差分析

异常值检验 T-test 参考&#xff1a;1.ttest和ttest2 区别 2. ttest在 matlab 3.T test分布表 单侧 方差分析&#xff08;ANOVA&#xff09; Def: 方差分析&#xff08;analysis of variance, ANOVA&#xff09;是一种统计检验&#xff0c;用于检验两组或更多组样本的均值是…
阅读更多...
PRL：上海交大张文涛团队实现量子材料相关突破

PRL：上海交大张文涛团队实现量子材料相关突破

来源&#xff1a;上海交通大学 近期&#xff0c;上海交通大学物理与天文学院张文涛研究组利用自行研制的高能量和高时间分辨率角分辨光电子能谱系统对量子材料1T-TiSe₂电子结构进行了超快激光操控研究。利用超快光激发与电荷密度波相有关的相干声子&#xff0c;引起晶格内原子…
阅读更多...
高压放大器在微波光子雷达中的应用有哪些

高压放大器在微波光子雷达中的应用有哪些

微波光子雷达是一种新型的雷达技术&#xff0c;它利用微波和光子相结合的方式进行探测和成像。在微波光子雷达系统中&#xff0c;高压放大器作为一个关键的组件&#xff0c;主要用于对微波信号进行放大&#xff0c;以增强雷达系统的探测能力和成像精度。本文将详细介绍高压放大…
阅读更多...
20230606夏新（Amoi）的4K显示器D320B2000的亮点检测

20230606夏新（Amoi）的4K显示器D320B2000的亮点检测

20230606夏新&#xff08;Amoi&#xff09;的4K显示器D320B2000的亮点检测 2023/6/7 0:14 https://item.jd.com/63690000655.html 夏新&#xff08;Amoi&#xff09;电脑显示器高清家用办公电竞吃鸡游戏液晶监控直播大屏便携显示屏幕 32英寸【直面 4k/144hz双模式 全面屏】黑 …
阅读更多...
Linux内核文件写入流程

Linux内核文件写入流程

文本代码基于Linux 5.15 。 当用户层调用write 去做写入&#xff0c; linux 内核里面是如何处理的&#xff1f; 本文以exfat 为例&#xff0c; 讨论这个流程 入口函数 write 系统调用的定义如下&#xff1a; fs/read_write.c ssize_t ksys_write(unsigned int fd, const ch…
阅读更多...
数据库期末复习(7.2)查询优化

数据库期末复习(7.2)查询优化

查询优化的概述 商用数据库花了很多的资金投入到查询优化。 查询优化的分类 逻辑查询优化 物理查询优化 比逻辑查询计划多了怎么去执行的方式，为的是数据操作速度更快 逻辑查询优化的三种关键技术 在科学研究的道路上我们往往不是一帆风顺的,人的认识也是局限的，但是我…
阅读更多...
SciencePub学术 | 计算机科学类重点SCIEI征稿中

SciencePub学术 | 计算机科学类重点SCIEI征稿中

SciencePub学术刊源推荐: 计算机科学类SCI&EI征稿中&#xff01;录用率高&#xff0c;自引率低&#xff0c;进展顺利。信息如下&#xff0c;录满为止&#xff1a; 一、期刊概况&#xff1a; 【期刊简介】IF&#xff1a;4.0-4.5↑&#xff0c; JCR 2区&#xff0c;中科院3区…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023