链表基础用法

最新推荐文章于 2023-02-05 15:26:42 发布
最新推荐文章于 2023-02-05 15:26:42 发布
阅读量180 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65136138/article/details/125689322
版权

单链表

单链表通过next节点，把每一个元素串联起来，形成一个链状结构

基本用法：

  1 写一个节点类，包含要存储的元素，还要一个next节点。

   2 写一个链表类，类中最重要的就是一个头节点，其他元素不用保存，单链表就是通过头节点  ，   管理每一个节点的。不过头节点一般不能动，都是使用临时变量进行操作

   3 在链表类中实现各种操作的方法

package LinkedList;

public class SingleLinkListDemo {

    public static void main(String[] args) {

        VTuberNode vTuberNode = new VTuberNode(1, "东雪莲", "管人痴");
        VTuberNode vTuberNode1 = new VTuberNode(2, "嘉然", "嘉心糖");
        VTuberNode vTuberNode2 = new VTuberNode(3, "永雏塔菲", "热水器");
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addVTuber(vTuberNode);
        singleLinkedList.addVTuber(vTuberNode1);
        singleLinkedList.addVTuber(vTuberNode2);

        singleLinkedList.addOrderBy(vTuberNode2);
        singleLinkedList.showList();
        System.out.println("\n\n");


        singleLinkedList.update(new VTuberNode(2, "嘉然", "主人"));
        singleLinkedList.showList();
        System.out.println("\n\n");


        singleLinkedList.delete(new VTuberNode(2, "嘉然", "主人"));
        singleLinkedList.showList();
        System.out.println("\n\n");


        singleLinkedList.addOrderBy(vTuberNode1);
        singleLinkedList.showList();
        System.out.println("\n\n");


    }


}

//链表类，用于管理每一个节点，单链表我们只要保存它的头节点就可以了（这个很重要），通过头节点进行管理。
class SingleLinkedList {
    //初始化头节点，这个头节点是不能动的，//不存放具体数据
    private VTuberNode head = new VTuberNode(0, " ", " ");

    //添加方法
    //找到最后一个，把它的next指向
    public void addVTuber(VTuberNode vTuberNode) {
        VTuberNode temp = head;//头节点不能动，所以需要一个临时变量，指向头节点
        while (true) {
            if (temp.next == null) {
                break;//找到就返回
            }


            temp = temp.next;

        }
        //结束循环后，就指向了最后一个元素
        temp.next = vTuberNode;//

    }

    //输出链表
    public void showList() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }

        //头节点不能动，需要一个辅助变量遍历

        VTuberNode temp = head.next;

        while (true) {
            if (temp == null) {
                break;//到链表尾了
            }

            System.out.println(temp);
            temp = temp.next;

        }


    }

    //顺序插入方法

    public void addOrderBy(VTuberNode vTuberNode) {
        VTuberNode temp = head; //临时
        boolean flag = false;    //记录是否已经存在这样一个节点了，默认是不存在
        while (true) {
            if (temp.next == null) //到链表的尾部了
                break;
            if (temp.next.no == vTuberNode.no)//找到了相同的节点
            {
                flag = true;
                break;

            }

            if (temp.next.no > vTuberNode.no)//找的位置了
            {
                break;
            }

            temp = temp.next;

        }

        if (flag) {
            System.out.println("添加失败。这个节点已经存在了");
            return;

        }

        VTuberNode temp2 = temp.next;

        temp.next = vTuberNode;
        vTuberNode.next = temp2;
        System.out.println("添加成功");


    }

    //更新节点的方法,序列号不变，其他信息做修改

    public void update(VTuberNode vTuberNode) {

        boolean flag = false;//记录是否存在这个节点
        VTuberNode temp = head;

        while (true) {
            if (temp.next == null) {
                break;
            }
            //没有找到
            if (temp.next.no == vTuberNode.no) {
                flag = true;
                break;
            }

            temp = temp.next;
        }

        if (!flag) {
            System.out.println("更新失败，不存在这样一个节点");
            return;
        }

        VTuberNode temp2 = temp.next.next;
        temp.next = vTuberNode;
        vTuberNode.next = temp2;
        System.out.println("修改成功");


    }

    //删除节点的方法
    //由于是单链表，我们需要找到前一个一个元素

    public void delete(VTuberNode vTuberNode) {
        VTuberNode temp = head;
        boolean flag = false;

        while (true) {
            if (temp.next == null) {
                break;
            }
            //没有找到
            if (temp.next.no == vTuberNode.no) {
                flag = true;
                break;
            }

            temp = temp.next;
        }

        if (!flag) {

            System.out.println("删除失败，不存在这样一个元素");

            return;

        }
        temp.next = temp.next.next;//重新指向
        System.out.println("删除成功");
    }


}


class VTuberNode { //节点类

    public int no;//顺序
    public String name; //名字
    public String nickname;//昵称
    public VTuberNode next;//下一个节点

    public VTuberNode(int no, String name, String nickname) { //构造方法
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

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

双向链表

相对于单链表的区别就是它有头指针和尾指针，分别指向前一个元素和后一个元素。有了两个指针，方便了很多操作

package LinkedList;

import java.util.LinkedList;

public class DoubleLinkedListDemo {

    public static void main(String[] args) {

        VTuberNode2 vTuberNode = new VTuberNode2(1, "东雪莲", "管人痴");
        VTuberNode2 vTuberNode1 = new VTuberNode2(2, "嘉然", "嘉心糖");
        VTuberNode2 vTuberNode2 = new VTuberNode2(3, "永雏塔菲", "热水器");
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();

        doubleLinkedList.addVTuber(vTuberNode);
        doubleLinkedList.addVTuber(vTuberNode1);
        doubleLinkedList.addVTuber(vTuberNode2);
        doubleLinkedList.showList();
        System.out.println("\n\n");

        VTuberNode2 vTuberNode3 = new VTuberNode2(2, "嘉然", "主人");
        doubleLinkedList.update(vTuberNode3);
        doubleLinkedList.showList();
        System.out.println("\n\n");


       doubleLinkedList.delete(vTuberNode3);
        doubleLinkedList.showList();
        System.out.println("\n\n");

        VTuberNode2 vTuberNode4 = new VTuberNode2(2, "嘉然", "嘉心糖");
        doubleLinkedList.addVTuber(vTuberNode4);
        doubleLinkedList.showList();
        System.out.println("\n\n");
    }


}

class DoubleLinkedList {

    private VTuberNode2 head = new VTuberNode2(0, "", "");

    //遍历方法

    public void showList() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }

        //头节点不能动，需要一个辅助变量遍历

        VTuberNode2 temp = head.next;

        while (true) {
            if (temp == null) {
                break;//到链表尾了
            }

            System.out.println(temp);
            temp = temp.next;

        }


    }

    //添加方法

    public void addVTuber(VTuberNode2 vTuberNode) {
        VTuberNode2 temp = head;//头节点不能动，所以需要一个临时变量，指向头节点
        while (true) {
            if (temp.next == null) {
                break;//找到就返回
            }


            temp = temp.next;

        }
        //结束循环后，就指向了最后一个元素,形成一个双向链表
        temp.next = vTuberNode;//
        vTuberNode.pre = temp;//


    }

    //修改方法
    public void update(VTuberNode2 vTuberNode) {

        boolean flag = false;//记录是否存在这个节点
        VTuberNode2 temp = head.next;
          if(temp==null)
          {
              System.out.println("更新失败，不存在这样一个节点");
              return;
          }

        while (true) {

            //没有找到
            if (temp.no == vTuberNode.no) {
                flag = true;
                break;
            }

            temp = temp.next;
        }

        if (!flag) {
            System.out.println("更新失败，不存在这样一个节点");
            return;
        }

        temp.name = vTuberNode.name;
        temp.nickname = vTuberNode.nickname;
        System.out.println("修改成功");


    }

    //删除节点方法
    public void delete(VTuberNode2 vTuberNode) {

        VTuberNode2 temp = head.next;
        boolean flag = false;
        if (head.next == null) {
            System.out.println("删除失败，不存在这样一个元素");

            return;
        }

        while (true) {
            if (temp == null) {
                break;
            }
            if (temp.no == vTuberNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.pre.next = temp.next;
            if (temp.next != null) {//最后一个元素不为空
                temp.next.pre = temp.pre;

            }
            System.out.println("删除成功");
        } else {
            System.out.println("删除失败，元素不存在");
        }
    }


}


class VTuberNode2 { //节点类

    public int no;//顺序
    public String name; //名字
    public String nickname;//昵称
    public VTuberNode2 next;//下一个节点
    public VTuberNode2 pre;//前一个节点

    public VTuberNode2(int no, String name, String nickname) { //构造方法
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

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

栈溢出了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表的常见用法
qq_30534935的博客
02-06 1586
转载： https://blog.csdn.net/zjwsa/article/details/77892208 https://segmentfault.com/a/1190000017790779 一、定义 链表的头文件： #include< stdlib> 链表的建立： struct node { int data; struct node *next...
链表使用
Sympathizer的博客
05-15 467
链表从堆中分配空间, 每个节点没有相对固定的位置关系。即写入内存的物理地址不是连续的（比如某个节点在地址A其后的节点不一定是A+1,而在内存的其他空闲区域，呈现一种随机的状态。） 链表定义：//定义链表中的节点 typedef struct node{ int data; //链表中的数据 struct node * p_next;//指向下一节点的指...
链表的用法
expleeve
01-25 620
<br />学习数据结构的时候，链表感觉比较简单，但是总是不太用它。<br /> <br />比如说最近经常用的<br />struct  struct1{<br />    void *data;<br />    struct struct1* next;<br />};<br /> <br />同时对其进行封装，如get,set,insert,append,delete等方法。<br /> <br />这样对于数据整体的操作都很明了，屏蔽了底层的操作。<br /> <br />不同类型的结构之间即使有
链表的基本使用
weixin_62403934的博客
05-30 1325
链表 1.链表的定义 使由若干个结点组成（每个结点代表一个元素），且结点在内存中的存储位置通常是不连续的。除此之外，链表的两个结点之家你一般通过一个指针来从一个结点指向另一个结点，因此链表的结点一般由两部分组成，即数据域和指针域： struct node{ int data; node* next; }; 2.链表的操作 创建链表 主要用到三个指针，p, pre(前驱指针，指向当前结点的前驱结点), head(头结点) node* create(int a[]){ node *p, *pre
链表的使用
clmm_的博客
02-05 705
1.链表的基本概念2.创建单链表3.插入结点（头部插入法）4.遍历链表5.链表结点的删除6.链表的释放。
python的链表基础知识点
12-17
链表是一种重要的数据结构，它在Python中虽然不如数组或列表那样直接存在，但可以通过类和对象的概念来模拟实现。链表不同于数组，数组中...理解链表的基本概念和操作对于学习和使用Python或其他编程语言是非常有益的。
基础链表练习（附详细注释）
04-08
此外，还需要一个链表类（如`StringList`），包含一个头结点属性和上述操作的方法。 代码实现可能如下： ```python class ListNode: def __init__(self, data=None): self.data = data self.next = None class...
Python单向链表和双向链表原理与用法实例详解
09-20
Python实现链表时，可以使用内置的类来简化操作，如`collections`模块中的`deque`可以用来模拟双向链表，但通常我们会选择自定义数据结构，以便更好地理解和控制链表的行为。 总的来说，链表在内存效率和动态性方面...
Qt基础练习，QGraphics制作可视化链表
最新发布
08-25
可以使用Qt的QWidget和QLayout类来创建这些控件，并将它们与链表操作的方法关联起来。 7. **测试与调试**：编写测试用例来确保链表操作的正确性，同时检查可视化效果是否符合预期。 通过以上步骤，我们可以创建一...
链表的基本用法
白日梦~
04-01 539
普通链表 struct STR{ int a; char c; struct STR *next; }; struct STR *creat(){ struct STR* head = NULL, * p1, * p2, * rear = NULL; int n = 0; p1 = p2 = (struct STR*)malloc(sizeof(struct STR));/*完全...
链表的用法示例
06-25
可以让你更深的了解并使用链表，但是解释说明比较少，全看个人领悟了，最好找书参考一下
详细讲解链表的使用方法
galaxyrt的博客
06-04 3162
链表的使用 链表是常见的数据结构，由若干节点组成，这些节点可以在运行时动态生成 头指针：存放一个地址，该地址指向第一个节点， 结点：由需要处理的实际数据和指向下一个节点的指针组成 创建链表： 定义三个指针： head---表头指针，指向第一个节点 newnode---指向当前动态创建的节点 tail---表尾指针，指向当前链表的最后一个节点 创建步骤： 1、置空表： head=NULL; 2、动态创建新节点，让newnode指向该节点，并向其数据域输入数据： newnode=ne...
链表的基本操作
小橘是橘子的博客
04-30 4728
单链表的简单介绍: 链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始； 链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的； 其中每个结点都有指针成员变量指向列表中的下一个结点； 链表是由结点构成，head指针指向第一个成为表头的结点，而终止于最后一个指向NULL的指针。一般使用时都要定义一个头结点，头结点不存放数据，只是为了方便查找。 一般的单链表的操作(增，删，改，查)如下代码： package com.mrz.test; public class Si
linux内核中链表结构及使用方法
Tony的博客
04-21 6829
声明：在学习linux 内核数据结构之链表部分时参考了http://blog.chinaunix.net/uid-14114479-id-2932024.html。 Linux kernel里面从来就不缺少简洁，优雅和高效的代码，只是我们缺少发现和品味的眼光。在Linux kernel里面，简洁并不表示代码使用神出鬼没的超然技巧，相反，它使用的不过是大家非常熟悉的基础数据结构，但是kernel开
链表基础：存储与操作优化
本资源主要介绍了线性表中的链式存储方式，特别是链表数据结构。链表是一种不同于数组的存储方式，它通过节点之间的链接来保持...理解和掌握链表的基本概念、操作方法以及优缺点，对于编写高效、灵活的程序至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值