链表（自学笔记）__ 要坚持啊^_^

最新推荐文章于 2022-07-23 09:21:42 发布
最新推荐文章于 2022-07-23 09:21:42 发布
阅读量104 收藏
点赞数
分类专栏： 学习笔记 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/my_269/article/details/117390267
版权

一、链表的介绍

  • 链表是数据结构之一，其中的数据呈线性排列。
  • 在链表中，数据的添加和删除都较为方便， 但是访问比较耗费时间。
  • 每一个结点都包含了数据域和指针域（指向下一个结点的指针）。
  • 链表的结构是链式的，但是内存不是连续的（如下图）
  • 因为数据都是分散存储的，所以如果想要访问数据，只能从第1个数据开始，顺着指针的指向一一往下访问（这便是顺序访问）
  • 除了单向链表还有双向链表和循环链表，各有优劣

 

二、一个单向链表的基本功能

一）、增加数据

第一种：直接将数据加在链表尾部

思路：

①遍历链表普通遍历（使用while）
1、将head赋值给可动指针temp
2、先判断是否达到尾结点，即temp.next==null
3、若达到尾结点则break；否则，移动当前结点temp，即temp=temp.next
4、当退出循环时，temp的位置为尾结点

②向结点添加数据

不考虑编号排序（add）
1、先找到尾结点
2、将尾结点的next指向将要添加的新节点,即temp.next=newHeroNode

第二种：根据编号，先排序再添加数据

①遍历链表，找到插入数据的位置

考虑编号排序时的遍历
1、会有三种情况
①要添加的编号本来就应该在尾结点
②要添加的编号本来就已经存在，不添加
③要添加的编号在两个数据之间
2、介于第二种情况，需要新声明一个布尔变量flag，用来判断编号是否存在
3、判断适合插入的位置的条件：if(temp.next.no > newHeroNode.no)。

②向结点添加数据

考虑编号排序（addByOrder）
1、先遍历，找到需要插入的编号的前一个结点，作为此时的temp
2、将当前结点的下一个结点指向前一个结点的下一个结点，即newHeroNode.next=temp.next
3、将前一个结点的下一个结点指向当前结点，即temp.next=newHeroNode

思路图解：参考《我的第一本算法书》

二）、删除数据

1、思路

①遍历（需要判断链表是否为空），根据结点编号no，找到待删除结点的前一个结点

② 用一个布尔变量flag来标记是否找到该数据

③若找到，修改结点的指针域，temp.next = temp.next.next;

2、图解

三）、查找数据

就是简单的遍历加打印数据，但要注意此时的temp不是等于head，而是head.next

四）、修改数据

1、思路

①遍历，通过newHeroNode.no来找到原结点HeroNode.no的位置（这里的temp=head.next , 并且也需要一个flag来标记是否需要修改）

②根据no来修改其他数值

  •      temp.name = newHeroNode.name;
  •             temp.nickname = newHeroNode.nickname;

三、创建一个链表

1、定义HeroNode，每一个对象都是一个结点

内容：①数据域：编号no，名字name，昵称nickname

           ②指针域：HeroNode next;

2、创建一个对象，用来处理链表（增删查改）

          ①初始化头结点

          ②按照前面的功能思路，写各种方法，用于处理链表

四、代码实现

1、定义HeroNode

class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;

    public HeroNode getNext() {
        return 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 void add(HeroNode heroNode) {
        HeroNode temp = head;
        while (true) {
            if (null == temp.next) {//达到尾结点
                break;
            }
            temp = temp.next;
        }
        temp.next = heroNode;
    }

  • 按顺序添加数据

    public void addByOrder(HeroNode heroNode) {
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (null == temp.next) {
                break;
            }
            if (heroNode.no < temp.next.no) {
                break;
            } else if (heroNode.no == temp.next.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.println("该编码已经存在，不可添加");
        } else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    ②删除数据

  • public void del(int no) {
        HeroNode temp = head;
        boolean flag = false;
        if (isEmpty()) {
            return;
        }
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.printf("待删除的结点%d不存在", no);
        }
    }

    ③查找数据

    public void showlist() {
        if (isEmpty()) {
            return;
        }
        HeroNode temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

    ④修改数据

    public void update(HeroNode newHeroNode) {
        //判断是否为空
        if (isEmpty()) {
            return;
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.no == newHeroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
            System.out.println("没有找到" + newHeroNode.no + "号的数据");
        }
    }

    ⑤主方法测试

    public class SingleLinkedListDemo {
    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 list = new SingleLinkedList();
        list.add(hero1);
        list.add(hero2);
        list.add(hero3);
        list.add(hero4);
        list.showlist();
        System.out.println("===========");
        list.del(1);
        list.del(3);
        list.del(4);
        list.showlist();
        System.out.println("============");
        list.addByOrder(hero4);
        list.addByOrder(hero1);
        list.showlist();
        System.out.println("============");
        HeroNode newHeroHode = new HeroNode(3, "林冲匆", "豹子");
        list.update(newHeroHode);
        list.showlist();
    }
}

    ⑥完整代码

    package link;

public class SingleLinkedListDemo {
    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 list = new SingleLinkedList();
        list.add(hero1);
        list.add(hero2);
        list.add(hero3);
        list.add(hero4);
        list.showlist();
        System.out.println("===========");
        list.del(1);
        list.del(3);
        list.del(4);
        list.showlist();
        System.out.println("============");
        list.addByOrder(hero4);
        list.addByOrder(hero1);
        list.showlist();
        System.out.println("============");
        HeroNode newHeroHode = new HeroNode(3, "林冲匆", "豹子");
        list.update(newHeroHode);
        list.showlist();
    }
}

class SingleLinkedList {
    //初始化一个头结点
    private HeroNode head = new HeroNode(0, " ", " ");
    public void add(HeroNode heroNode) {
        HeroNode temp = head;
        while (true) {
            if (null == temp.next) {//达到尾结点
                break;
            }
            temp = temp.next;
        }
        temp.next = heroNode;
    }

    public void addByOrder(HeroNode heroNode) {
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (null == temp.next) {
                break;
            }
            if (heroNode.no < temp.next.no) {
                break;
            } else if (heroNode.no == temp.next.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.println("该编码已经存在，不可添加");
        } else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //根据no的编号来修改除了no以外的其他的结点信息
    public void update(HeroNode newHeroNode) {
        //判断是否为空
        if (isEmpty()) {
            return;
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.no == newHeroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
            System.out.println("没有找到" + newHeroNode.no + "号的数据");
        }
    }

    public void del(int no) {
        HeroNode temp = head;
        boolean flag = false;
        if (isEmpty()) {
            return;
        }
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.printf("待删除的结点%d不存在", no);
        }
    }

    public void showlist() {
        if (isEmpty()) {
            return;
        }
        HeroNode temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }


    public boolean isEmpty() {
        if (null == head.next) {
            System.out.println("链表为空");
            return true;
        } else {
            return false;
        }
    }


}

class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;

    public HeroNode getNext() {
        return 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 + '\'' +
                '}';
    }


}

    五、运行结果

kaneki ken❥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sss.rar_sss_双向链表_链表_链表 插入
09-14
1.双向链表的初始化 2.双向链表的尾插法建立 3.双向链表插入结点 4.双向链表删除结点 5.双向链表遍历链表 6.双向链表按不同的属性查找节点 7.双指针查找节点
变量和链表透彻的解释，禁不住记录下来
xiabo852105的专栏
07-03 1806
p=p->next 到底表达了什么意思？ ->是一个整体，它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“->”. 举个例子： struct Data {    int a,b,c; };              /*定义结构
1.（3）数据结构之链表的创建和遍历（有图有注释）
爱打羽毛球的程序员
07-23 3696
数据结构之链表的创建和遍历（有图有注释）快速看懂创建和遍历过程
链表—学习笔记
qq_40114716的博客
03-05 591
知识点： 链表： 通过指针串联在一起的线性结构，每个节点包含指针域和数据域。 链表的定义及调用方式： //定义 struct ListNode { int val; // 节点存储的元素 ListNode *next； // 指向下一个节点的指针 ListNode(int x) : val (x), next(NULL) {} // 节点的构造函数 }; //构造初始化节点 ListNode* head = new ListNode(5); 类型：单链表（每个节点指向.
C语言学习笔记(十三) －链表 Chain
陆讯
03-17 1608
动态申请链表/* 动态申请链表 数组:静态存储，有序的数据集合，数据顺序能够映射物理地址，查找快，插入删除效率低 链表:动态存储，插入删除效率高 */#include <stdio.h> #include <stdlib.h> typedef struct node { int i; //保存节点的值,数值域 struct node *p;//记录下一个节点的地
链表学习笔记
weixin_55286304的博客
08-11 95
结构体的定义形式： struct list_node { int data ; //数据域，用于存储数据 }; //记得加上分号 链表的定义形式 struct list_node { int data ; //数据域，用于存储数据 struct list_node *next ; //指针，可以用来访问节点数据，也可以遍历，指向下一个节点 }; //记得加上分号 1.链表和数组 demo1.c #include <stdio.h> struct Text {
graph_DFS.zip_C语言单向链表_linux 链表_链表_链表 linux
09-24
简易链表linux下实现单向链表的C语言实现程序，有详尽的链表操作函数，可以作为C语言学习的参考代码
链表辅助函数_链表辅助函数_
09-30
链表的辅助函数，帮助初学者理解链表，使用数组实现。
用VC编写单链表(数据结构).rar_VC 链表_单链表_数据结构 链表_链表
09-21
用VC编写的单链表 是数据结构中线性表中的一种
lianbiao.rar_链表_链表 合并 排序
09-20
链表，实现创建一个链表，删除一个结点，合并两个链表，打印，排序等功能
单链表的学习心得
u011010440的博客
11-30 8411
（1） ADT typedef int ElemType typedef struct Node{ ElemType data; struct Node * next; }Node; typedef struct Node* linkList; (2) int initList(linkList *L) int initList(linkList *L) { (*L) = (linkList)m...
链表第一篇
qq_25355771的博客
04-17 273
链表第一篇1.介绍1.1头节点 1.介绍 列表是以节点的方式进行存储的 每一个节点包括data域, next域 链表的各个节点不一定是连续存放的 链表分为带头节点的链表和不带头结点的链表，根据实际情况来确定 1.1头节点 不存放具体数据的节点 作用就是表示的单链表的头 next域指向下一个节点 节点名称 指向节点 head next域 代码： package Package01; import com.sun.xml.internal.bind.v2.runtime.unmar
链表学习笔记整理（c）
噗噗bug博客
08-23 310
问题? 假如:做一个班级信息管理系统，统计班级学生的信息，而我们事先不知道班级人数，或者知道人数，但是中间人员可能发生变化:比如有新同学加入，有同学请假，又或者我们需要统计班级的平均成绩等等 又假如:要做一个类似QQ、飞秋类似的通信软件，其中有一个功能，类似用户上下线检测:有新的用户上线、下线实时更新显示，可以实时查询在线状态、按姓名排序等以上问题如何使用学过的C语言知识处理呢? 使用数组远远不能达到用户要求 因为：数组必须实现确定大小，不能实现动态申请、释放；且创建的数据也不一定是相同类型的...
链表基础知识总结
热门推荐
u012531536的专栏
05-02 17万+
链表和数组作为算法中的两个基本数据结构，在程序设计过程中经常用到。尽管两种结构都可以用来存储一系列的数据，但又各有各的特点。数组的优势，在于可以方便的遍历查找需要的数据。在查询数组指定位置（如查询数组中的第4个数据）的操作中，只需要进行1次操作即可，时间复杂度为O(1)。但是，这种时间上的便利性，是因为数组在内存中占用了连续的空间，在进行类似的查找或者遍历时，本质是指针在内存中的定向偏移。然而，当...
剑指offer-链表学习笔记
qq_44653420的博客
05-01 670
剑指offer-链表学习笔记 一、链表概述  链表是一种动态的数据结构，在创建链表时，无需知道链表的长度，当插入一个节点时，我们只需要为新的节点分配内存，然后调整指针的指向来确保新节点被连接到链表中。内存分配不是在创建链表时一次性完成的，而是每添加一个节点分配一次内存。由于没有闲置的内存，链表的空间效率比数组高。链表节点定义如下： struct ListNode { int m_nValue; ListNode* m_pNext; }; 向链表中插入一个节点： void AddToTai
销毁单向链表 bool Destroy_LinkedList(first)
最新发布
06-01
这个函数的作用是销毁一个单向链表，其中 `first` 是链表的头节点指针。 函数的实现可以采用循环方式，具体步骤如下： 1. 定义一个临时指针变量 `current`，将其初始化为头节点指针 `first`。 2. 循环遍历链表，当...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值