DS_【单链表】

最新推荐文章于 2024-01-27 10:57:28 发布
最新推荐文章于 2024-01-27 10:57:28 发布
阅读量147 收藏
点赞数 2
分类专栏： 数据结构和算法 文章标签： 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36390039/article/details/89060878
版权

数组和链表都是线性存储结构的基础，栈和队列都是线性存储结构的应用～
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的引用链
接次序实现的
在这里插入图片描述
组成：
由n个节点离散的分配，每个节点由头结点和尾节点组成，头结点存放date，尾节点存放下个头结点的引用，在最后的节点没有下一个节点nulll

无头定义

//不带头的
private Node head;
    class Node{
        private int data;
        private Node next;

        public Node(int data) {
            this.data=data;
            this.next=null;
        }
    }

无头的链表在new的时候不含头，在空间存储上也没有。

01单向链表的接口
public interface ILinked {
    //头插法
    void addFirst(int data);
    //尾插法
    void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    boolean addindex(int index,int data);
    //查找是否包含关键字key是否在单链表当中
    boolean contains(int key);
    //删除第一次出现关键字为key的节点
    int remove(int key);
    //删除所有值为key的节点
    void removeAllKey(int key);
    //得到单链表的长度
    int getLength();
    void display();
    void clear();
}

实现单链表

01addFirst【头插法】
//无头
 @Override
    public void addFirst(int data) {
        // TODO Auto-generated method stub
        //第一次插入数据
        Node node = new Node(data);
        if(this.head==null) {
            this.head=node;
        }else {
            node.next=this.head;
            this.head=node;
        }
    }

考虑到没有头结点所以在插入式第一次插入，链表为空，此时插入的数据唯一特殊情况，要考虑。

定义一个新的节点 node 对node进行判定
当进行头部插入时，如果当前链表的头结点 head为空 将这个新的节点定义为头结点，假如不为null 将新建节点的next指向之前头结点的head
在这里插入图片描述

02尾插法
//无头
 @Override
    public void addLast(int data) {
        // TODO Auto-generated method stub
        Node node = new Node(data);
        Node cur = this.head;
        if(cur==null) {
            this.head=node;
        }else {
            while(cur.next!=null) {
                cur=cur.next;
            }
            cur.next=node;
        }
    }

在操作时考虑到链表可能为null

创建一个新的节点node 对所有节点进行遍历找出尾节点然后将尾节点指向新节点
在这里插入图片描述

03addindex【添加指定位置的节点】
01核对下标是否合法

下标的取值范围

//无头与带头相同
 private void checkIndex(int index) {
        if(index<0||index>getLength()) {
            throw new IndexOutOfBoundsException("下标不合法");
        }
    }
02寻找index-1 未知的节点
//无头寻找index前一个节点
private Node serchIndex(int index) {
        checkIndex(index);
        //记录从头到尾的步数
        int count=0;
        if(index==0){
        return null;
     }
    Node cur = this.head;
        while(cur.next!=null&&count<index-1){
            cur=cur.next;
            count++;
        }
        return cur;
    }

或者

 private Node searchPre(int key){
        //判断是不是第一个节点
        Node cur = this.head;           //创建头结点
        if(head.data==key){            //如果头结点符合情况 返回头结点
            return cur;
        }
            //找到符合key节点的前一个节点
            while(cur.next!=null){          //将整个链表从头到尾遍历 结束是最后一个next=null
                if(cur.next.data==key){
                    return cur;
                }else{
                    cur=cur.next;               //不符合情况则下一个
                }
            }
        return null;
    }

通过遍历头结点到index-1的每经过依次next 计数器加一cur.next!=null&&count<index-1

//无头
	 @Override
    public boolean addindex(int index, int data) {
        // TODO Auto-generated method stub
        Node node = new Node(data);
        Node cur = serchIndex(index);
        if(cur==null){
            node.next=this.head;
            this.head=node;
        }else{
            node.next=cur.next;
            cur.next=node;
        }
        return true;
    }

因为本身链表无头所以不能直接将index拿来做便利条件，必须判断index合法情况，在此基础上使用serachIndex函数去找前一个位置

思路 ：
1.通过serchIndex找出index-1上一个节点的next节点
2.然后打断index-1和index节点的连接现将node的next节点指向index的头结点，然后将index-1的next指向node的头节点

03判断是否有元素
	 //判断是否有元素
    @Override
    public boolean contains(int key) {
        // TODO Auto-generated method stub
       Node node  = this.head;
       while(node!=null){
           if(node.data==key){
               return true;
           }else{
               node=node.next;
           }
       }
       return false;
    }

通过反复遍历每一个节点通过对比寻找元素

04删除节点
@Override
    public int remove(int key) {
        // TODO Auto-generated method stub
        int oldData = 0;
        Node pre = searchPre(key);          //找到符合情况的前一个节点
        if(pre==null){
            throw new UnsupportedOperationException("无节点");
        }
       if(pre==this.head&&pre.data==key){               //排除当目标节点为第二个节点时 前一节点为head
           oldData=this.head.data;          //拿到数据存放
           this.head=this.head.next;
           return oldData;
       }
       Node delNode=pre.next;               //拿到前一个节点next节点
       oldData = delNode.data;
       pre.next = delNode.next;             //与目标节点下一个节点相连接
       return oldData;
    }
05removeAllKey
 @Override
    public void removeAllKey(int key) {
        // TODO Auto-generated method stub
       Node cur = this.head.next;           //pre cur   curNdext cur
       Node pre = this.head;
       while(cur!=null){
           if(cur.data==key){
                pre.next=cur.next;
                cur=pre.next;
           }else{
               pre=cur;
               cur=pre.next;
           }
       }
       if(this.head.data==key){
           this.head=this.head.next;
       }
     }

总结：
1.单向不循环链表在执行头插法或者尾插时要考虑头结点因素
2.画图更能掌握单向链表

**总代码
public class Linkedimpl implements ILinked {
    private Node head;
    class Node{
        private int data;
        private Node next;

        public Node(int data) {
            this.data=data;
            this.next=null;
        }
    }
   @Override
    public void addFirst(int data) {
        // TODO Auto-generated method stub
        //第一次插入数据
        Node node = new Node(data);
        if(this.head==null) {
            this.head=node;
        }else {
            node.next=this.head;
            this.head=node;
        }
    }
   @Override
    public void addLast(int data) {
        // TODO Auto-generated method stub
        Node node = new Node(data);
        Node cur = this.head;
        if(cur==null) {
            this.head=node;
        }else {
            while(cur.next!=null) {
                cur=cur.next;
            }
            cur.next=node;
        }
    }
    //寻找index -1 位置的节点
    private Node serchIndex(int index) {
        checkIndex(index);
        //记录从头到尾的步数
        int count=0;
        if(index==0){
        return null;
     }
    Node cur = this.head;
        while(cur.next!=null&&count<index-1){
            cur=cur.next;
            count++;
        }
        return cur;
    }
    private void checkIndex(int index) {
        if(index<0||index>getLength()) {
            throw new IndexOutOfBoundsException("下标不合法");
        }
    }
    @Override
    public boolean addindex(int index, int data) {
        // TODO Auto-generated method stub
        Node node = new Node(data);
        Node cur = serchIndex(index);
        if(cur==null){
            node.next=this.head;
            this.head=node;
        }else{
            node.next=cur.next;
            cur.next=node;
        }
        return true;
    }
    //判断是否有元素
    @Override
    public boolean contains(int key) {
        // TODO Auto-generated method stub
       Node node  = this.head;
       while(node!=null){
           if(node.data==key){
               return true;
           }else{
               node=node.next;
           }
       }
       return false;
    }
    private Node searchPre(int key){
        //判断是不是第一个节点
        Node cur = this.head;           //创建头结点
        if(head.data==key){            //如果头结点符合情况 返回头结点
            return cur;
        }
            //找到符合key节点的前一个节点
            while(cur.next!=null){          //将整个链表从头到尾遍历 结束是最后一个next=null
                if(cur.next.data==key){
                    return cur;
                }else{
                    cur=cur.next;               //不符合情况则下一个
                }
            }
        return null;
    }
    @Override
    public int remove(int key) {
        // TODO Auto-generated method stub
        int oldData = 0;
        Node pre = searchPre(key);          //找到符合情况的前一个节点
        if(pre==null){
            throw new UnsupportedOperationException("无节点");
        }
       if(pre==this.head&&pre.data==key){               //排除当目标节点为第二个节点时 前一节点为head
           oldData=this.head.data;          //拿到数据存放
           this.head=this.head.next;
           return oldData;
       }
       Node delNode=pre.next;               //拿到前一个节点next节点
       oldData = delNode.data;
       pre.next = delNode.next;             //与目标节点下一个节点相连接
       return oldData;
    }
    @Override
    public void removeAllKey(int key) {
        // TODO Auto-generated method stub
       Node cur = this.head.next;           //pre cur   curNdext cur
       Node pre = this.head;
       while(cur!=null){
           if(cur.data==key){
                pre.next=cur.next;
                cur=pre.next;
           }else{
               pre=cur;
               cur=pre.next;
           }
       }
       if(this.head.data==key){
           this.head=this.head.next;
       }
     }
    @Override
    public int getLength() {
        // TODO Auto-generated method stub
        int len=0;
        Node node = this.head;
        while(node!=null) {
            len++;
            node=node.next;
        }
        return len;
    }
    @Override
    public void display() {
        // TODO Auto-generated method stub
        Node node = this.head;
        if(node==null){
            System.out.println("wudi");
        }
        while(node!=null) {
            System.out.print(node.data+" ");
            node=node.next;
        }
    }
    @Override
    public void clear() {
        // TODO Auto-generated method stub
       while(this.head.next!=null){
           Node cur = this.head.next;
           this.head= null;
           this.head = cur;
       }
    }

在执行clear操作时，要保证没一个节点得到释放

单向带头循环链表
public class CLinkedimpl implements ICLinked {
    class Node{
        private Node next;
        private int data;
        public Node(){
            this.data=-1;
        }
        public Node(int data){
            this.data=data;
        }
    }
    private Node head;
    public CLinkedimpl(){
        this.head=new Node();
        this.head.next=this.head;
    }
    @Override
    public void addFirst(int data) {
        Node node  = new Node(data);
        node.next = this.head.next;
        this.head.next=node;
    }
    @Override
    public void addLast(int data) {
        Node node = new Node(data);
        Node cur = this.head;
        while(cur.next!=this.head){
            cur = cur.next;
        }
        node.next=this.head;
        cur.next=node;
    }
    private void checkIndex(int index){
        if(index<0||index>getLength()){
            throw new IndexOutOfBoundsException("下标不合法");
        }
    }
    @Override
    public boolean addIndex(int index, int data) {
        Node node  = new Node(data);
        Node cur = this.head;
        checkIndex(index);
        for(int i=0;i<index;i++){
            cur = cur.next;
        }
        node.next = cur.next;
        cur.next=node;
        return true;
    }

    @Override
    public boolean contains(int key) {
        Node cur = this.head;
        while(cur.next!=this.head){
            if(cur.next.data==key){
                return true;
            }else{
                cur=cur.next;
            }
        }
        return false;
    }

    private Node searchPre(int key){
        Node pre = this.head;
        while(pre.next!=this.head){
            if(pre.next.data==key){
                return pre;
            }else{
                pre=pre.next;
            }
        }
        return null;
    }
    @Override
    public int remove(int key) {
        int oldData=0;
        Node pre = searchPre(key);
        if(pre==null){
            System.out.print("无该节点");
        }

        oldData = pre.next.data;
        pre.next=pre.next.next;
        /**
         * Node delNode = pre.next;
         * oldData = delNode.data;
         * pre.next = delNdoe.next;
         */
        return oldData;
    }

    @Override
    public void removeAllKey(int key) {
        int oldData = 0;
        Node pre = this.head;
        Node cur = this.head.next;
        while(cur!=this.head){
           if(cur.data==key){
               pre.next=cur.next;
               cur=cur.next;
           }else{
               cur=pre;
               cur=cur.next;
           }
        }
    }

    @Override
    public int getLength() {
        Node node = this.head.next;
        int count = 0;
        while(node!=this.head){
            count++;
        }
        return count;
    }

    @Override
    public void display() {
        Node node = this.head.next;
        while(node!=this.head){
            System.out.print(node.data+" ");
            node=node.next;
        }
        System.out.println();
    }

    @Override
    public void clear() {
        while(this.head.next!=this.head){
            Node cur = this.head.next;
            this.head.next=cur.next;
            cur.next=null;
        }
    }
}

带头循环的优点，相比于无头节点，在执行头插法或者尾插法不用考虑头结点。执行遍历时终止条件是转一个圈的头结点
在这里插入图片描述
生命不息！！！奋斗不止！！！

java_Maxhui
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表遍历_单链表及其遍历实现的基本操作
cumt951045的博客
08-03 1万+
单链表遍历 单链表 (Single linked list) Single linked list contains a number of nodes where each node has a data field and a pointer to next node. The link of the last node is to NULL, indicates end of list. ...
A. DS单链表--类实现
Olivia_su的博客
11-13 541
链表的插入、删除、查找操作。新手学习，超详细！！
DS之单链表
Lwolwo's
09-17 1953
DS之单链表的类实现、结点交换、合并操作。
DS：单链表的实现
热门推荐
weixin_51142926的博客
01-27 1万+
在博主的上一篇文章中，很详细地介绍了顺序表实现的过程以及如何去书写代码，如果没看过的友友们建议先去看看哦！ DS：顺序表的实现（超详细！！） 顺序表是线性表的一种，而本文将会介绍另外一种线性表——链表。 ​
DS单链表_反转链表
weixin_74381881的博客
01-04 803
在给出代码之前，我们首先定义了两个类：`ListNode`和`LinkList`。`ListNode`类表示单链表的节点，包含一个整型数据成员和一个指向下一个节点的指针。`LinkList`类表示单链表，包含一个头节点指针和链表长度的成员变量。LinkList();return p;
DS单链表--合并
hjvhvh的博客
12-18 156
题目描述 假定两个单链表是递增有序，定义并实现以下函数，完成两个单链表的合并，继续保持递增有序 int LL_merge(ListNode *La, ListNode *Lb) 输入 第1行先输入n表示有n个数据，接着输入n个数据 第2行先输入m表示有M个数据，接着输入m个数据 输出 输出合并后的单链表数据，数据之间用空格隔开 #include <iostream> using namespace std; class LNode{ int data;
DS单链表--结点交换
m0_74040903的博客
11-12 427
DS单链表--结点交换，本代码仅代表思路
DS单链表--合并 C++
笔记
09-28 764
这是一种窒息的操作
1_DS实验2_单链表的基本操作.zip
10-20
单链表是一种基础的数据结构，广泛应用于计算机科学和编程领域。在这个实验中，我们将深入探讨单链表的基本操作，包括创建、插入、...在进行DS实验2时，你将有机会实践这些操作，加深对链表的理解，并提高编程技能。
DS_ALGO
03-10
Java提供了单链表（LinkedList）和双向链表（DoubleLinkedList）。链表的主要优势在于插入和删除操作的高效性。 3. **栈**：后进先出（LIFO）的数据结构，Java中的`java.util.Stack`类实现了栈。在DS_ALGO中，可能...
ds_java:Java中的数据结构程序
05-15
Java中提供了两种链表实现：单链表（LinkedList类）和双向链表（Deque接口）。例如，`LinkedList<Integer> list = new LinkedList();`。 3. **栈**：栈是一种后进先出（LIFO）的数据结构，Java中的栈可以使用...
DS_Questions：首次提交
03-04
2. **链表**：包括单链表、双链表和循环链表等，不连续的内存空间存储元素，通过指针链接节点。 3. **栈**：后进先出（LIFO）的数据结构，常用操作是压栈（push）和弹栈（pop）。Java中的`java.util.Stack`类提供了...
QYR2024-2030全球及中国机载光电吊舱行业研究及十五五规划分析报告 wugege.pdf
09-05
QYResearch是全球知名的大型咨询公司，行业涵盖各高科技行业产业链细分市场，横跨如半导体产业链（半导体设备及零部件、半导体材料、集成电路、制造、封测、分立器件、传感器、光电器件）、光伏产业链（设备、硅料/硅片、电池片、组件、辅料支架、逆变器、电站终端）、新能源汽车产业链（动力电池及材料、电驱电控、汽车半导体/电子、整车、充电桩）、通信产业链（通信系统设备、终端设备、电子元器件、射频前端、光模块、4G/5G/6G、宽带、IoT、数字经济、AI）、先进材料产业链（金属材料、高分子材料、陶瓷材料、纳米材料等）、机械制造产业链（数控机床、工程机械、电气机械、3C自动化、工业机器人、激光、工控、无人机）、食品药品、医疗器械、农业等。
KLite 是嵌入式操作系统内核，并以MIT协议开放源代码
09-05
KLite的定位是一款入门级的嵌入式实时操作系统内核，以简洁易用为设计目标，旨在降低嵌入式RTOS的入门难度。代码干净工整、架构清晰、函数接口简单易用、不使用条件编译、移植简单、无需配置和裁减。可能是目前最简洁易用的RTOS。
Avatar_Utils-1.4.0-py3-none-any.whl.zip
09-05
Avatar_Utils-1.4.0-py3-none-any.whl.zip
全球与中国合同餐饮市场现状及未来发展趋势（2024版）.docx
09-05
全球与中国合同餐饮市场现状及未来发展趋势（2024版）.docx
qt框架的概要介绍与分析
最新发布
09-05
Qt 是一个跨平台的应用程序框架，它包含了一套功能丰富的工具和 API，使得开发者能够高效地开发出美观且功能强大的 GUI 应用程序。Qt 不仅支持多种操作系统，如 Windows、macOS、Linux，还可以用于开发移动设备上的应用程序。Qt 的主要优点在于其强大的类库、易用的设计工具 Qt Designer 以及信号槽机制，这使得事件处理更加简单。 ### 资源描述 要获取关于 Qt 的学习资源，可以从以下几个方面入手： 1. **Qt 官方文档** - Qt 官网 (<https://doc.qt.io/>) 提供了大量的文档和教程，从入门到精通都有覆盖，是学习 Qt 的最佳起点。 2. **书籍** - 有许多优秀的书籍可以帮助你深入理解 Qt，例如《C++ GUI Programming with Qt 4》、《Programming the Qt 4 Application Framework》等。 3. **在线课程** - 网站如 Pluralsight、Udemy、Coursera 提供了多个关于 Qt 的在线课程，适合不同水平的学习者。 4. **社区
STC8G+HX711体重秤设计
09-05
基于STC8G+HX711体重秤设计，内有Keil程序源码，包括HX711读取，TM1637驱动，数据处理，使用的是keil5版本；嘉立创EDA电路原理图和PCB文件，我使用的是标准版。 电路使用1节干电池作为主电源，通过升压电路和稳压电路为各模块提供稳定的工作电压。使用数字管显示体重数值。选用STC8G1KO8A单片机，用于数据处理和控制显示。
DS单链表_合并k个升序链表
04-03
题目描述 给你一个链表数组，每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中，返回合并后的链表。 示例 输入：lists = [[1,4,5],[1,3,4],[2,6]] 输出：[1,1,2,3,4,4,5,6] ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值