单链表

已于 2022-01-18 20:56:40 修改
阅读量544 收藏 4
点赞数 5
分类专栏： 数据结构与算法 文章标签： 链表 数据结构
于 2021-10-15 15:17:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61784000/article/details/120759238
版权

1.单链表

下一个节点的引用即是存放下个节点的地址 以便于连成一个链表

初始化属性

提供一个带有data next 的构造方法 以便于后面使用

class Node{
    public int data;
    public Node next;
//Node为引用类型 head存放头部地址
    public Node head;
    public Node(int data){

         //初始data默认为data 因为data是传入的
        this.data=data;

        //next为一个引用 因此须默认为null 以便于后面使用
        this.next=null;
    }

一  头插法 

把一个节点插入无头单向非循环单链表的头部 并且让head指向这个节点 


    public void addFirst(int data){

        //1.先生成一个节点
        // 把这个生成的节点赋值为data
        Node node=new Node(data);

         if(this.head==null){//证明第一次插入节点
            this.head=node;
             return ;
         }

        //2.把null改为插入到最前面第一个节点的地址 它存在head中
        node.next=this.head;

        //3.更改头部地址 跟node.next 地址不一样 自己想想
            head指向新头部节点       node存的是当前节点地址
        this.head=node;
    }

若插入有头 插到头节点与第二个节点中间

 

步骤总结：

1.Node node=new Node(data);

node是new之后生成的对象

node这个对象可以通过调用属性来方便后面调用 把data赋给数值域

2.node.next=this.head; 

将next改为第一个节点的地址 则它成为新头节点

3.this.head=node;

node其实就是保存了新节点的地址

应当赋值让head指向这个新头节点 head保存头节点的地址

注意：

如果是第一次插入节点 那么head为null

则须使head保存这第一个节点的地址

this.head=node; 让head指向node 指向新节点

易错点 * 

 不可写成

1.Node node=new Node(data);

2.this.head=node;

3.node.next=this.head;

会导致节点自己指向自己 直接报废

分析如下

1.表示new一个新对象 方便调用

2.node存放的是当前节点的地址 则第二步地址head指向这个尚未插入的新节点

3.node调用next属性并且赋值head head指向新节点自身 即存新节点自身的地址

那么next 最后赋成了自身的地址

恭喜 直接报废 重开

还有一个重要的知识记录一下

Node是一个类

它的属性有data next 相当于一个模板 根据这个模板产生无数个对象

如对象node可以调用属性 

再复习一遍 可能不完整但是核心

Node node=new Node(data);

if(this.head==null){

this.head=node;

return ;

}

node.next=head;

this.head=node;

每new一次 它都可以产生一个新节点 

二 打印单链表

 重新定义一个cur 如果用head会导致到后面移了之后找不到了

代码如下

 public void display(){
        Node cur=this.head;
        while(cur!=null){
            System.out.println(cur.data);
            cur=cur.next;
        }

分析如下：

1.Node cur=this.head;

重新找一个对象为cur  并且赋予head 由于head存放头节点的地址

所以cur指向头节点

2.while(cur!=null) {

打印cur.data数据 通过cur来调用

cur=cur.next; 前面说过next中存放的都是下一个节点的地址 因此cur赋值后可指向下一个节点

当没有下一个节点时 即为cur.next==null  赋值之后cur等于null

为了能打印最后一个节点 则条件为cur!=null 若为cur.next!=0 最后一个节点data不会打印

三 尾插法

把最后一个节点的null变为要插入节点的地址 如图是777 

Node cur=this.head;

让一个cur指向头节点 然后让cur往后走 当cur.next==null时证明ok了

此时把 cur.next=node; 因为node中存着尾插节点的地址

 实现代码如下

最重要的一点是 通过第一步创建新的节点 记住了 跟头插的时候一模一样
      Node node=new Node(data);

public void addLast(int data){
        //传入一个数据data 
        //最重要的一点是 通过第一步创建新的节点 记住了 跟头插的时候一模一样
        Node node=new Node(data);
        //cur指向头节点
        Node cur=this.head;
        while(cur.next!=null){
            cur=cur.next;
        }
        cur.next=node;
    }

四 查找key是否在单链表中

思想与前面类似 代码如下

public boolean contains(int key){

       //当然第一步可省略new一个node 直接第二步开始 但习惯了还是写上去了
        Node node=new Node(data);//由于前面用构造方法实现了data 所以这里可直接用

        Node cur=this.head;//同理 前面构造方法也实现了head 这里也可以直接用
        while(cur!=null){
            //找到了
            if(cur.data==key){
                return true;
            }
            //没找到 继续往后
            cur=cur.next;
        }
        return false;
    }

五 得到单链表的长度

 public int size(){
        Node cur=this.head;
        int count=0;
        while(cur!=null){
            count++;
            cur=cur.next;
        }
        return count;
    }

this总结

 this可以调用属性或方法 养成习惯就好了

this不可以访问局部变量

如  这是错误的 a不是对象 a在栈里

 

 这是正确的 a定义在外面 this可以访问引用了

六  在index(任意位置）插入一个数据(data)

 你要插到2号位 那么就插到2号位的前面即可 注意是从0号位开始的

最终的目的就是把其串起来

代码如下

//  表示要在下标为index处 插入数据为data的节点
public void addIndex(int index,int data){
    Node node=new Node(data);
        //当index为0时 相当于头插
        if(index==0){
            addFirst(data);
            return ;
        }
        //当index等于长度时 等价于尾插
        if(index==this.size()){
            addLast(data);
            return ;
    }

        //先找到index位前面一个节点的地址
        Node cur=searchIndex(index);

        //找到之后进行插入

       node.next=cur.next;
       cur.next=node;

        private Node searchIndex(int index){
      //先堆index检查是否合法
        if(index<0||index>this.size()){
            throw new RuntimeException("index位置不合法");
        }
        Node cur=this.head;
        while(index-1!=0){
            cur=cur.next;
            index--;
        }
        return cur;
    }
}

七 删除第一次出现关键字为key的节点

代码如下

 private Node searchprev(int key) {
        Node prev = this.head;
        while (prev.next != null) {
            //如果下一个数据等于key时 返回prev
            if (prev.next.data == key) {
                return prev;
                //如果不是继续往后找
            } else {
                prev = prev.next;
            }
        }
        //由于Node 为引用类型 那么返回null 代表一个节点的属性
        // data next
        return null;
    }

    public void remove(int key) {
        if (this.head == null) {
            return;
        }
        //如果要删的key就是头节点中的数据
        if (this.head.data == key) {
            this.head = this.head.next;
            return;
        }
        //当要删除的不是头节点时 要删除的在后面
        //1.先找到要删除元素的前驱（前一个）
        //创建一个方法
        Node prev = searchprev(key);
if(prev==null){
    System.out.println("根本没有这个节点");
    return ;
}
//通过Node引用del 确定del的位置 
// del指向我们要删除的节点
Node del=prev.next;
//再一次进行 
prev.next=del.next;
    }
}

八 删除所有值为key的节点

假如把所有值为12的删除

搞出来prev与cur 

这个方法思想是综合与提升

 这个方法只遍历一次链表就可以删除所有关键字为key的元素

注意 先删头后面的节点到最后再返回过来看头

prev 在cur 前一个进行定义通过cur的移动变化 prev进行变化

public void removeAllKey(int key){

        //先判断 从 头 后一个 是不是我们要删除的key
         //最后判断头是不是要删的
        
        //Node定义引用一个prev指向头 Node本身就是引用类型
        Node prev=this.head;
        //定义一个cur 指向头的下一个
        Node cur=this.head.next;
        while(cur!=null){
            //当cur指向的节点中存的数据等于key时 
            // 我们删除
            if(cur.data==key){
                prev.next=cur.next;
                cur=cur.next;
                
                //注意删就删了 不可以把prev往后
                // 如果往后就会可能有忽略产生 自己画图想想看
                
                
            } else {
                //如果不是 继续往后找
                
                prev=cur;//把prev指向cur所指向的位置
                cur=cur.next;
                
            }
            //最后看头 是否是key
            if(this.head.data==key){
                this.head=this.head.next;
            }
        }
    }
}

九 释放链表

 相当于诺米骨牌 推倒第一个就可以了

public void clear(){
    this.head=null;
}

总代码如下

//Node 相当于一个节点 这个节点包括next和data
//Node 表示一个类型

public class Eriksen {

class Node {
    public int data;
    //next中存放一个地址 定义为Node类型
    public Node next;


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

    public Node head;

    public void addFirst(int data) {
        Node node = new Node(data);
        if (this.head == null) {
            this.head = node;
            return;
        }
        node.next = this.head;
        this.head = node;
    }

    public void display(int data) {
        Node cur = this.head;
        while (cur != null) {
            System.out.println(cur.data);
            cur = cur.next;
        }
    }

    public void addLast(int data) {
        Node node = new Node(data);
        if (this.head == null) {
            this.head = node;
            return;
        }
        Node cur = this.head;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = node;
    }

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

    public int size() {
        Node cur = this.head;
        int count = 0;
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

    private Node searchIndex(int index) {
        //先堆index检查是否合法
        if (index < 0 || index > this.size()) {
            throw new RuntimeException("index位置不合法");
        }
        Node cur = this.head;
        while (index - 1 != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }

    //  表示要在下标为index处 插入数据为data的节点
    public void addIndex(int index, int data) {
        Node node = new Node(data);
        //当index为0时 相当于头插
        if (index == 0) {
            addFirst(data);
            return;
        }
        //当index等于长度时 等价于尾插
        if (index == this.size()) {
            addLast(data);
            return;
        }

        //先找到index位前面一个节点的地址
        Node cur = searchIndex(index);

        //找到之后进行插入

        node.next = cur.next;
        cur.next = node;
    }

    private Node searchprev(int key) {
        Node prev = this.head;
        while (prev.next != null) {
            //如果下一个数据等于key时 返回prev
            if (prev.next.data == key) {
                return prev;
                //如果不是继续往后找
            } else {
                prev = prev.next;
            }
        }
        //由于Node 为引用类型 那么返回null 代表一个节点的属性
        // data next
        return null;
    }

    public void remove(int key) {
        if (this.head == null) {
            return;
        }
        //如果要删的key就是头节点中的数据
        if (this.head.data == key) {
            this.head = this.head.next;
            return;
        }
        //当要删除的不是头节点时 要删除的在后面
        //1.先找到要删除元素的前驱（前一个）
        //创建一个方法
        Node prev = searchprev(key);
          if(prev==null){
       System.out.println("根本没有这个节点");
      return ;
   }
//通过Node引用del 确定del的位置
// del指向我们要删除的节点
Node del=prev.next;
//再一次进行
prev.next=del.next;
    }
    public void removeAllKey(int key){

        //先判断 从 头 后一个 是不是我们要删除的key
         //最后判断头是不是要删的

        //Node定义引用一个prev指向头 Node本身就是引用类型
        Node prev=this.head;
        //定义一个cur 指向头的下一个
        Node cur=this.head.next;
        while(cur!=null){
            //当cur指向的节点中存的数据等于key时
            // 我们删除
            if(cur.data==key){
                prev.next=cur.next;
                cur=cur.next;

                //注意删就删了 不可以把prev往后
                // 如果往后就会可能有忽略产生 自己画图想想看


            } else {
                //如果不是 继续往后找

                prev=cur;//把prev指向cur所指向的位置
                cur=cur.next;

            }
            //最后看头 是否是key
            if(this.head.data==key){
                this.head=this.head.next;
            }
        }
    }
}

    public static void main(String[] args) {
        Eriksen nod=new Eriksen();
    }
}

链表的next指向理解
wcy18629063634的博客
10-20 1453
链表指向语言坑爹
数据结构-单向链表（一）（JAVA）
yushen
01-30 394
1.数据结构之链表 链表是一种按照线性顺序排列各对象的数据结构。数组的线性顺序是由数组下标决定的，然而与数组不同的是，链表的顺序        是由各个对象里面的指针决定的。链表为动态集合提供了一种简单而灵活的表示方式。 单向链表中每个对象有一个元素和一个next指针，指向下一个链表对象：x为单向链表中的一个元素，x.next指向它在链表中的 后继元素。链表中最后一个元素是没有后继元素的，它
数据结构之链表
weixin_45540544的博客
01-21 556
数据结构之链表 链表以线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表的插入和删除操作可以达到O(1)的复杂度。而链表有指向性可以分为单向链表和双向链表。 单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针，下图就是一个单链表。 可以由图看出，链表中每个节点都指向下个节点。一般在设置链表时，头节点我一般会设成空节点。 在编写单向链表时，我一般会这样设置链表节点的结构体。 // 定义链表结构体 typedef struct L
数据结构07——单链表查找算法
weixin_45658431的博客
09-20 802
从链表的头指针出发，顺着next域逐个结点往下搜索，直到查找到与要搜索的值相等的数据为止。3）如果查遍整个链表都没有找到其值和e相等的元素，则返回0或“NULL”2）如果找到一个值与e相等的数据元素，则返回其在链表中的地址。1）从第一个结点起，依次和e比较。
（一）找到单链表中倒数第K个结点
Back_Light_F的博客
09-27 1723
本文旨在总结一下这道题的几种解法 题目描述：输入一个链表，输出该链表中倒数第K个结点 解法一：蛮力法    从链表的第一个节点开始，统计当前节点后面的节点个数。如果后面的节点个数小于n-1，说明链表中的节点个数不够。如果数量大于n-1，则移动到下一个结点（作为新的当前节点），重复该过程直至当前节点后面的节点个数等于n-1.算法结束   时间复杂度为O（n^2）。对于每个结点，都需要从当前节...
单链表-实验报告.doc
03-10
单链表是一种基础的数据结构，它由一系列节点组成，每个节点包含数据域和指针域，指针域指向下一个节点。在这个实验报告中，我们主要关注单链表的建立、输出、插入和删除操作。 1. **单链表的建立**： - 实现时，...
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； （2）对已建立的单链表实现插入、...
使用C++实现单链表的基本操作：1、创建单链表2、遍历单链表3、单链表插入4、删除单链表5、判断是否为空6、单链表的
03-27
本文将详细阐述如何使用C++来实现单链表的基本操作，包括创建、遍历、插入、删除、判断空、计算长度以及查找节点。 首先，我们从创建单链表开始。单链表是由一系列节点组成的数据结构，每个节点包含一个数据元素和...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
C++单链表实现大数加法
08-19
C++单链表实现大数加法 大数加法是一种常见的算法问题，特别是在C++中实现大数加法时需要考虑到数字的位数和溢出问题。使用单链表来实现大数加法可以解决这个问题。本文将详细介绍如何使用C++单链表实现大数加法。 ...
[数据结构](线性表之单链表，搞懂这几个题，链表基础就算搞懂了)
qq_54883034的博客
08-19 1140
文章目录1.反转链表2.返回链表的中间节点3.返回链表中倒数第k个节点4.判断链表是否有环5.合并两个有序链表，为一个有序大链表6.已知链表有环，返回链表的入环节点7.判断链表是否是回文链表8.分割链表9.删除链表的中间节点10.链表相交，返回链表链表的相交节点11.从尾到头打印链表 1.反转链表 在以下的问题中都需要一个测试类，TestDemo.java文件,测试方法功能。以及实现链表功能的函数，这些功能方法都存放在MyLinkedList.java文件中 TestDemo.java文件： public
单链表的相关操作
xwt321的博客
01-25 653
1.单链表的读取       在线性表的顺序存储结构中，我们计算任意一个元素的存储位置很容易。单在单链表中，由于第i个元素到底在哪？没办法一开始就知道，必须得从头开始找。获得链表第i个数据的算法思路如下： 1）声明一个结点p指向链表第一个结点，初始化j从1开始； 2）当j 3）若到链表末尾p为空，则说明第i个元素不存在； 4）否则查找成功，返回结点p的数据。 代码算法实现如下： /*
JavaScript获取节点的方法大全
热门推荐
qq_42889406的博客
10-26 1万+
1. 通过document节点获取 1.1 通过ID 语法：document.getElementById（“id”）； 特点： 应用场景： 推荐指数： 示例： 1.2 通过标签名 语法：document.getElementById（“id”）； 特点： 应用场景： 示例： 1.3 通过name值 语法：document.getElementById（“id”）； 特点： 应用场景： 示例： 1.4 通过class 语法：document.getElementById（“id”）； 特点： 应用场景： 示
数据结构单链表的基础操作
weixin_73494910的博客
08-31 194
数据结构链表基本操作，努力加油吧
如何拿到链表的第一个节点
最新发布
m0_74051652的博客
08-13 472
如果你在使用自定义的链表，那么获取第一个节点的方式将取决于你的链表实现。通常情况下，自定义链表会有一个指向链表第一个节点的头指针（head）。通过直接访问这个头指针，你可以获取到链表的第一个节点。int val;val = x;// 链表的头指针// 构造函数等...// 获取链表的第一个节点// 其他方法...// 使用// 假设我们向list中添加了一些节点...// 获取并处理第一个节点= null) {// 对firstNode进行操作在这个例子中，
对单链表中头指针、头结点、首节点的理解
weixin_43223362的博客
04-11 9430
最近看剑指offer关于链表的题发现自己对链表的理解不那么透彻，所以查了很多资料。 下面先说一下自己的理解： 1.头指针存放的是链表第一个节点的地址。 单链表有两种情况：一是包含头结点的，此时，头指针存放的是头结点的地址，而头结点是和其他节点一样，包含数据域和指针域，但头结点的数据域是无意义的，可以为空，也可以为任何数，头结点的指针域包含的是首节点的地址，。 二是不包含头结点，此时，头指针存放的就...
数据结构之双向链表
Blooming death的博客
08-26 421
双向链表 1）、双向链表的构造：head节点、data、next（指向下一个）、pre（指向上一个） 2）、双向链表的添加、遍历、删除、修改的操作思想===>代码实现 a．遍历；方式和单链表一样，只是可以向前查找，向后查找 b．添加(默认添加到双向链表的最后)；先找到双向链表的最后这个节点，temp.next=newHead 最后一 个节点指向新节点，新节点的pre指向我们的最后一个节点，newHead.pre=temp; c．修改：思路和原来的单项链表一样 d．删除：双向链表可以实现自我删除，直接
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值