数据结构与算法_1.稀疏数组和队列_2

最新推荐文章于 2022-06-13 21:35:08 发布
最新推荐文章于 2022-06-13 21:35:08 发布
阅读量157 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhao416129/article/details/104778717
版权

1.2 队列

  • 单链表
    • 链表为有序列表，在内存中的存储如下：
      在这里插入图片描述
      1. 链表是以节点的方式来存储，是链式存储。
      2. 每个节点包含：data 域和 next 域（指向下一个节点）。
      3. 链表的各个节点不一定是连续存储的。
      4. 链表分有头节点的链表和没有头节点的链表，根据实际的需求来确定。
    • 代码实现（增查）：
/*
	1. 第一种方法：添加节点时，直接添加到链表尾部
*/
public class Demo01SingleLinkedList {
    public static void main(String[] args) {
        // 创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");

        // 创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        // 加入节点
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);

        // 显示链表
        singleLinkedList.list();
    }
}

// 定义SingleLinkedList，管理英雄
class SingleLinkedList {
    // 先初始化一个头节点，头节点不要动，不存放具体数据
    private HeroNode head = new HeroNode(0,"","");

    // 添加节点到单向链表
    /*
        思路：
            当不考虑编号顺序时，
            1. 找到当前链表的最后节点
            2. 将最后这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode) {
        // 需要一个辅助变量temp，因为head节点不能动
        HeroNode temp = head;
        // 遍历链表，找到最后一个节点
        while (true) {
            // 如果是最后，退出
            if (temp.next == null) {
                break;
            }
            // 如果不是最后，将temp后移一个
            temp = temp.next;
        }
        // 当退出while循环时，temp就指向了链表的最后
        // 将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }

    // 显示链表[遍历]
    public void list() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 需要一个辅助变量来遍历，因为头节点不能动
        HeroNode temp = head.next;
        while (true) {
            // 判断是否是链表最后
            if (temp == null) {
                break;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移
            temp = temp.next;
        }
    }
}

// 定义HeroNode，每个HeroNode对象就是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;   // 指向下一个节点

    // 构造器
    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

/*
	2. 第二种方法：添加节点时，按照顺序添加到链表指定位置
*/
public class Demo01SingleLinkedList {
    public static void main(String[] args) {
        // 创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");

        // 创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        // 加入节点（按照顺序）
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        // 显示链表
        singleLinkedList.list();
    }
}

// 定义SingleLinkedList，管理英雄
class SingleLinkedList {
    // 先初始化一个头节点，头节点不要动，不存放具体数据
    private HeroNode head = new HeroNode(0,"","");

    // 添加节点到单向链表
    /*
        思路：
            当不考虑编号顺序时，
            1. 找到当前链表的最后节点
            2. 将最后这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode) {
        // 需要一个辅助变量temp，因为head节点不能动
        HeroNode temp = head;
        // 遍历链表，找到最后一个节点
        while (true) {
            // 如果是最后，退出
            if (temp.next == null) {
                break;
            }
            // 如果不是最后，将temp后移一个
            temp = temp.next;
        }
        // 当退出while循环时，temp就指向了链表的最后
        // 将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }

    // 第二种方法添加节点，按照顺序将节点添加到指定位置
    public void addByOrder(HeroNode heroNode) {
        // 头节点不能动，需要一个辅助变量temp，帮助找到添加的位置
        // 因为是单链表，因为找的temp是位于添加位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;   // flag标志添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {
                break;  // 已经在链表的最后
            }
            if (temp.next.no > heroNode.no) {
                // 位置找到，就在temp和temp.next之间插入
                break;
            } else if (temp.next.no == heroNode.no) {
                // 说明希望添加的heroNode的编号已经存在
                flag = true;
                break;
            }
            // temp后移
            temp = temp.next;
        }
        // 判断flag值
        if (flag) {
            // 说明编号存在，不能添加
            System.out.printf("准别插入的英雄编号 %d 已经存在，不能加入\n", heroNode.no);
        } else {
            // 插入到链表中
            heroNode.next = temp.next;  // 将原先temp.next的值赋值给heroNode.next
            temp.next = heroNode;       // 再将heroNode赋值给temp.next
        }
    }

    // 显示链表[遍历]
    public void list() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 需要一个辅助变量来遍历，因为头节点不能动
        HeroNode temp = head.next;
        while (true) {
            // 判断是否是链表最后
            if (temp == null) {
                break;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移
            temp = temp.next;
        }
    }
}

// 定义HeroNode，每个HeroNode对象就是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;   // 指向下一个节点

    // 构造器
    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}
  • 代码实现（删改）：
public class Demo01SingleLinkedList {
    public static void main(String[] args) {
        // 创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");

        // 创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        
        // 加入节点（按照顺序）
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        // 显示链表
        System.out.println("修改前的链表：");
        singleLinkedList.list();

        // 修改节点
        HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
        singleLinkedList.update(newHeroNode);

        // 显示链表
        System.out.println("修改后的链表：");
        singleLinkedList.list();

        // 删除节点
        singleLinkedList.del(1);
        singleLinkedList.del(4);
        singleLinkedList.del(3);
        singleLinkedList.del(2);

        // 显示链表
        System.out.println("删除后的链表：");
        singleLinkedList.list();
    }
}

// 定义SingleLinkedList，管理英雄
class SingleLinkedList {
    // 先初始化一个头节点，头节点不要动，不存放具体数据
    private HeroNode head = new HeroNode(0,"","");

    // 添加节点到单向链表
    /*
        思路：
            当不考虑编号顺序时，
            1. 找到当前链表的最后节点
            2. 将最后这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode) {
        // 需要一个辅助变量temp，因为head节点不能动
        HeroNode temp = head;
        // 遍历链表，找到最后一个节点
        while (true) {
            // 如果是最后，退出
            if (temp.next == null) {
                break;
            }
            // 如果不是最后，将temp后移一个
            temp = temp.next;
        }
        // 当退出while循环时，temp就指向了链表的最后
        // 将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }

    // 第二种方法添加节点，按照顺序将节点添加到指定位置
    public void addByOrder(HeroNode heroNode) {
        // 头节点不能动，需要一个辅助变量temp，帮助找到添加的位置
        // 因为是单链表，因为找的temp是位于添加位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;   // flag标志添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {
                break;  // 已经在链表的最后
            }
            if (temp.next.no > heroNode.no) {
                // 位置找到，就在temp和temp.next之间插入
                break;
            } else if (temp.next.no == heroNode.no) {
                // 说明希望添加的heroNode的编号已经存在
                flag = true;
                break;
            }
            // temp后移
            temp = temp.next;
        }
        // 判断flag值
        if (flag) {
            // 说明编号存在，不能添加
            System.out.printf("准别插入的英雄编号 %d 已经存在，不能加入\n", heroNode.no);
        } else {
            // 插入到链表中
            heroNode.next = temp.next;  // 将原先temp.next的值赋值给heroNode.next
            temp.next = heroNode;       // 再将heroNode赋值给temp.next
        }
    }

    // 修改节点，
    /*
    	思路：
    		1. 根据 temp.no 来修改，即 temp.no 不能修改。
    		2. 根据 newHeroNode.no 来修改
    */
    public void update(HeroNode newHeroNode) {
        // 判断是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 若不为空，根据no编号找到需要修改的节点
        HeroNode temp = head.next;
        boolean flag = false;   // 表示是否找到该节点
        while (true) {
            if (temp == null) {
                break;  // 已经遍历完链表
            }
            if (temp.no == newHeroNode.no) {
                // 找到该节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        // 根据flag判断是否找到要修改的节点
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
            // 没有找到
            System.out.printf("没有找到编号为 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

    // 删除节点
    /*
        思路：
            1. head不能动，需要temp辅助节点找到待删除节点的前一个节点。
            2. 对 temp.next.no 和 被删除节点的no 进行比较
     */
    public void del(int no) {
        HeroNode temp = head;
        boolean flag = false;   // 标志是否找到待删除节点
        while (true) {
            if (temp.next == null) {
                // 已经到链表的最后
                break;
            }
            if (temp.next.no == no) {
                // 找到待删除的节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next;
        }
        // 判断flag
        if (flag) {
            // 找到，删除
            temp.next = temp.next.next;
        } else {
            System.out.printf("要删除的节点 %d 不存在\n", no);
        }
    }

    // 显示链表[遍历]
    public void list() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 需要一个辅助变量来遍历，因为头节点不能动
        HeroNode temp = head.next;
        while (true) {
            // 判断是否是链表最后
            if (temp == null) {
                break;
            }
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移
            temp = temp.next;
        }
    }
}

// 定义HeroNode，每个HeroNode对象就是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;   // 指向下一个节点

    // 构造器
    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}
Jack_ZZF
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构--单向链表及其增、删、改、查、排序等操作的实现（C语言）
羟基与苯的博客
04-10 2198
文章目录🎃链表🎃单向链表的实现（C语言）📌结点类型描述📌1.创建初始化一个链表结点📌2.从链表尾部插入数据📌3.链表遍历打印📌4.查找链表：按结点序号查找📌5.查找链表：按数据内容查找📌6.在任意位置插入一个数据📌7.删除链表：按结点序号删除📌8.删除链表：按数据内容删除📌9.free释放内存📌10.求链表数据个数🎃单向链表总结 本章内容：单链表的概念；单链表结点模型；单链表的各运算实现。 本文涉及实现单链表完整代码已提交至码云Gitee中，供读者参考。 🎃链表 我们之前实现了数据结构中第一个结构–顺序
Python如何创建一个单链表，以及实现单链表的增，删，改，查操作，以及对单链表的排序功能
Idoit_z的博客
07-02 1436
标题Python如何创建一个单链表，以及实现单链表的增，删，改，查操作，以及对单链表的排序功能 #功能: 实现单链表的构建和功能操作 #定义单链表的类 class Node: """ 思路:将自定义的类视为节点的生成类,实例对象中 包含数据部分和指向下一个节点的next """ def __init__(self, val, next=None...
单链表的基本操作（建立，输出及排序）
In-My-World的专栏
08-08 3593
今天总结了一下单链表的基本操作：建立，求单链表长度，单//尾插法，新建一个链表 ListNode *creatList( ) { ListNode *head,*p,*s; int x,cycle=1; head=new ListNode();//新建头结点, p=head;//p指向头结点 while(cycle)//当输入0时，停止链表的建立 {
合并两个有序链表（LeetCode 21）
Dablelv 的博客专栏。
03-20 4335
不能开辟新空间来存储合并后的链表。如果第一次做该题，很容易会想到使用新链表来存储合并后的有序链表。虽然可以如此实现，但是不符合要求。从上面合并两个有序链表的步骤中可以看出，每次合并的步骤（2）都是一样的，由此我们想到了递归。将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。输入：两个有序的单链表 head1 与 head2。输出：合并后的有序单链表 mergeHead。
数据结构习题集（一）—— 线性表
qq_46064106的博客
06-13 164
线性表相关习题
【Java数据结构与算法】稀疏数组
01-20
文章目录数据结构类型线性结构与非线性结构稀疏数组实例应用二维数组转稀疏数组的思路稀疏数组转原始的二维数组思路 数据结构类型 数据结构包括：线性结构和非线性结构。 线性结构与非线性结构 线性结构 线性结构...
java数据结构与算法.pdf
01-04
在编程领域，数据结构与算法是核心组成部分，它们直接影响到程序的效率和性能。Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点...
线性结构和非线性结构、稀疏数组、队列、链表（LinkedList） 数组和链表.pdf
04-18
线性结构和非线性结构、稀疏数组、队列、链表（LinkedList） 数组和链表.pdf
《数据结构与算法实验》教学大纲.docx
12-14
《数据结构与算法实验》是一门针对信息与计算科学专业的必修课程，旨在培养学生对数据在计算机中的存储形式，即物理结构的理解，以及如何根据不同的数据处理需求选择合适的数据结构和算法。这门课程总共包含48个学时...
数据结构与算法考试大纲.docx
最新发布
04-01
《数据结构与算法》考试大纲主要涵盖了数据结构与算法的基础理论和实际应用，旨在测试学生对数据结构的理解和算法设计的能力。大纲分为不同层次的知识点要求，包括掌握、理解和了解，确保全面评估学生的专业素养。 ...
数据结构单链表的创建，插入，修改，查找以及删除
10-24
数据结构单链表的创建，插入，修改，查找以及删除。线性表操作
有序单链表的合并
你可以混，但不能真的菜！
10-22 1545
设有链表A和链表B分别有序，现需要将两链表合并成一条有序链表。 思路：开辟一条新链表C，分别遍历A、B按次序插入到C即可，需要注意长度问题，当A或B遍历完，另一条未遍历完，此时将未遍历完的链表直接接到C尾部即可。 代码： typedef struct node{ int data; struct node *next; }Lklist; void MergeLklist(Lklist *A,Lklist *B,Lklist *&C){ Lklist *pa,*pb,*t; //pa,
有序链表的合并和链表的反转
wuxudong12138的博客
09-26 243
有序链表的合并和链表的反转有序链表的合并链表的反转 有序链表的合并 主要采用了递归的思想 package com.dataStructure.LinkedList; public class MyLinkedListTest { public static void main(String[] args) { /* * 合并两个链表： * ...
【数据结构】（单链表）归并两个有序单链表 并逆序排列
你好丶下一秒
08-18 1194
算法思想：归并两个有序链表可以采取头插法，或者尾插法，逆序排列，就选择了尾插法，详见代码 void MargeLinkList(LinkList &q,LinkList &p){ if(q->next==NULL&&p->next==NULL) return; LinkList s1=q->next; LinkL...
数据结构与算法(3):单链表的创建删除修改以及应用实例
qq_42400763的博客
09-10 329
一:什么是链表? 链表是一个有序得列表,但是链表在内存中并不是连续存储的 小总结: 1.链表是以节点的方式来存储的,为链式存储. 2.每个节点包括了一个data域,一个next域:指向下一个节点 3.链表中的各个节点不一定是顺序存储的 4.链表分为带头的节点和不带头的节点 5.单链表的逻辑结构如下图所示 二:带头节点的单向链表实现: 实例:同学的排名,姓名,班级. 第一种方法:添加同学信息时,直接添加到链表的尾部 第二种方法:添加同学信息时,根据同学的排名,插入添加. 起始代码实现: ...
【数据结构与算法】单链表 ----节点的修改、删除
懂得一千零一种,赋予你失败的方法！
02-05 498
文章目录单链表的操作节点的修改节点的删除 单链表的操作 节点的修改 在之前创建好链表的基础上，我们对其中的节点进行修改：编号不变，英雄名称和昵称可以改变。 主要的思路就是，通过修改方法传入新的节点(节点编号任意)，若节点编号与已存在的节点相等，进行修改；否则，不好修改。 //进行节点的修改 ---- 根据no编号进行 public void update(HeroNode newHeroNode){ if (head.next==null){ ..
实现两个有序单链表的合并。要求：随机创建两个单链表，实现单链表的排序，再对两个有序单链表进行合并。
学习笔记
07-12 4776
实现两个有序单链表的合并。要求：随机创建两个单链表，实现单链表的排序，再对两个有序单链表进行合并。 ================================= 源代码 #include  using namespace std; template  class node {    public:       T nodeValue;      // data he
数据结构与算法之单链表(增{包含增序增加}、删、改、查、链表反转、有序链表合并{包含递归和非递归两种方式})
qq_35671159的博客
05-29 227
直接上代码吧，后面再总结一下： public class SinglyLinkedList { // 头节点 private final Node headNode = new Node(0, "", ""); /** * 添加节点 * * @param newNode 新节点 */ public void add(Node newNode) { Node temp = headNode; whi
c++实现双向有序链表的，增，删，查，合并
Jey
06-02 1826
#include using namespace std; struct DouLinkList{     DouLinkList* pre;     int data;     DouLinkList* next; }; DouLinkList* createLinkList(){//创建一个带头结点的双向链表，头结点数据域记录链表长度     DouLinkList*
"数据结构与算法基础学习：队列、链表、栈、递归、树学习与稀疏数组处理
总结来说，数据结构与算法是计算机科学的重要内容，其基础知识包括队列、链表、栈、递归和树等。线性结构包括顺序表和链表，非线性结构包括二维数组、多维数组、广义表、树结构和图结构等。程序是由数据结构和算法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值