数据结构篇：链表

已于 2022-08-11 11:08:22 修改
阅读量634 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 算法
于 2022-08-11 11:07:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41402069/article/details/126280865
版权

一、链表相关概念

1. 线性表、数组和链表
  • 线性表
    • 又称顺序表。线性表中的每一个数据称为一个元素，每个元素有且只有一个前驱元素。除了最后一个元素，每个元素有且仅有一个直接后继元素。
    • 数据元素之间的关系是一对一的关系。
  • 数组
    • 线性表的一种顺序存储方式。数组的内存是连续分配的，并且是静态分配的，即在使用数组之前需要分配固定大小的空间。
    • 可以通过索引直接得到数组中的元素，获取数组中元素的时间复杂度为O(1)
  • 链表
    • 线性表的一种链式存储结构。链表的内存不连续分配，并且是动态分配。
    • 链表通过一个指向下一个元素地址的引用将链表中的元素串起来。
2. 链表的分类
  • 单向链表
  • 双向链表
  • 单向循环链表
  • 双向循环链表

二、单向链表

1. 单向链表的组成
  • 单链表中的元素由数据域和Next指针域组成，各元素通过Next指针域连接。
  • 每个元素都存在后继元素(链尾除外)

单向链表

2. 单向链表的插入

单向链表的删除

3. 单向链表的删除

单向链表的删除

4. 单线链表的实现
/**
 * 单链表
 */
public class SingleLinkedList {

    // 头结点
    public SingleNode head;
    // 链表长度
    public int length;

    // 构造函数
    SingleLinkedList() {
        this.head = new SingleNode(null);
    }

    // 链表判空
    public boolean isEmpty() {
        return length == 0;
    }

    // 链表的长度
    public int length() {
        return length;
    }

    // 链表的新增（新增在链表尾部）
    public boolean add(int value) {
        SingleNode node = new SingleNode(value);
        SingleNode temp = head;
        while (null != temp.next) {
            temp = temp.next;
        }
        temp.next = node;
        length++;
        return true;
    }

    // 链表的新增(指定新增位置)
    public boolean addAt(int i, int value) {
        if (length < i){
            return false;
        }
        SingleNode node = new SingleNode(value);
        SingleNode temp = head;
        // 找到指定位置的前一个位置
        for (int k = 0; k < i - 1; k++) {
            temp = temp.next;
        }
        node.next = temp.next;
        temp.next = node;
        length++;
        return true;
    }

    // 链表的删除(指定位置)
    public boolean removeAt(int i) {
        if (length < i){
            return false;
        }
        SingleNode temp = head;
        // 找到待删除位置的前一个位置
        for (int k = 0; k < i - 1; k++){
            temp = temp.next;
        }
        temp.next = temp.next.next;
        length--;
        return true;
    }

    // 链表的删除(删除指定元素)
    public boolean remove(int value) {
        SingleNode temp = head;
        // 找到待删除位置的前一个位置
        while (null != temp.next){
            if (temp.next.value.equals(value)){
                temp.next = temp.next.next;
                length--;
                return true;
            }
            temp = temp.next;
        }
        return false;
    }

    // 链表的查找
    public SingleNode find(int i){
        if (i > length){
            return null;
        }
        SingleNode temp = head;
        for (int k = 0; k < i; k++){
            temp = temp.next;
        }
        return temp;
    }

    // 链表的更新
    public boolean update(int i, int value){
        if (i > length){
            return false;
        }
        SingleNode temp = head;
        for (int k = 0; k < i; k++){
            temp = temp.next;
        }
        temp.value = value;
        return true;
    }

    public void print(){
        SingleNode temp = head;
        while (null != temp.next){
            temp = temp.next;
            System.out.println(temp.value);
        }
    }

    public static class SingleNode {
        // 数据域
        Integer value;
        // 指针域
        SingleNode next;

        SingleNode(Integer value){
            this.value = value;
        }
    }

    // 测试类
    public static void main(String[] args){
        SingleLinkedList list = new SingleLinkedList();
        list.add(3);
        list.add(2);
        list.add(4);
        list.addAt(3, 5);
        list.remove(7);
        list.removeAt(5);
        list.remove(3);
        list.removeAt(1);
        SingleNode singleNode = list.find(1);
        list.update(2, 6);
        list.print();
    }

}

三、双向链表

1. 双向链表的组成
  • 双链表的元素由数据域、Prev指针域和Next指针域组成，各元素通过Prev指针域和Next指针域链接。
  • 每个元素都存在前驱元素和后继元素(链头没有前驱，链尾没有后继)

双向链表的组成

2. 双向链表的插入

双向链表的插入

3. 双向链表的删除

双向链表的删除

4. 双向链表的实现
/**
 * 双链表
 */
public class DoubleLinkedList {

    // 头结点
    public DoubleNode head;
    // 链表长度
    public int length;

    DoubleLinkedList() {
        this.head = new DoubleNode(null);
    }

    public boolean isEmpty() {
        return length == 0;
    }

    public int length() {
        return length;
    }

    // 新增元素(默认放置尾部)
    public boolean add(int value) {
        DoubleNode node = new DoubleNode(value);
        DoubleNode temp = head;
        while (null != temp.next) {
            temp = temp.next;
        }
        temp.next = node;
        node.pre = temp;
        length++;
        return true;
    }

    // 新增元素(指定新增位置)
    public boolean addAt(int i, int value) {
        if (i > length){
            return false;
        }
        // 找到新增位置的前一个位置
        DoubleNode node = new DoubleNode(value);
        DoubleNode temp = head;
        for (int k = 0; k < i - 1; k++){
            temp = temp.next;
        }
        node.next = temp.next;
        temp.next.pre = node;
        node.pre = temp;
        temp.next = node;
        length++;
        return true;
    }

    // 删除元素(指定位置)
    public boolean removeAt(int i){
        if (i > length){
            return false;
        }
        // 查找待删除的位置
        DoubleNode temp = head;
        for (int k = 0; k < i; k++){
            temp = temp.next;
        }
        temp.pre.next = temp.next;
        temp.next.pre = temp.pre;
        length--;
        return true;
    }

    // 删除元素
    public boolean remove(int value){
        DoubleNode temp = head;
        // 查找待删除的位置
        while (null != temp.next){
            temp = temp.next;
            if (temp.value == value){
                temp.pre.next = temp.next;
                temp.next.pre = temp.pre;
                length--;
                return true;
            }
        }
        return false;
    }

    // 链表的查找
    public DoubleNode find(int i){
        if (i > length){
            return null;
        }
        DoubleNode temp = head;
        for (int k = 0; k < i; k++){
            temp = temp.next;
        }
        return temp;
    }

    // 链表的更新
    public boolean update(int i, int value){
        if (i > length){
            return false;
        }
        DoubleNode temp = head;
        for (int k = 0; k < i; k++){
            temp = temp.next;
        }
        temp.value = value;
        return true;
    }

    public void print(){
        DoubleNode temp = head;
        while (null != temp.next){
            temp = temp.next;
            System.out.println(temp.value);
        }
    }

    public static class DoubleNode {
        // 数据域
        Integer value;
        // 前指针域
        DoubleNode pre;
        // 后指针域
        DoubleNode next;

        DoubleNode(Integer value){
            this.value = value;
        }
    }

    // 测试类
    public static void main(String[] args){
        DoubleLinkedList list = new DoubleLinkedList();
        list.add(3);
        list.add(2);
        list.add(4);
        list.addAt(3, 5);
        list.remove(7);
        list.removeAt(5);
        list.remove(3);
        list.removeAt(1);
        DoubleNode singleNode = list.find(1);
        list.update(2, 6);
        list.print();
    }

}

四、单向循环链表

1. 单向循环链表的组成
  • 单链表中的元素由数据域和Next指针域组成，各元素通过Next指针域连接。
  • 每个元素都存在后继元素(包括链尾)

单向循环链表

2. 单向循环链表的插入

单向循环链表的插入

3. 单向循环链表的删除

单向循环链表的删除

4. 单向循环链表的实现
/**
 * 单向循环链表
 */
public class SingleCycleLinkedList {

    // 头结点
    public SingleCyleNode head;
    // 尾结点
    public SingleCyleNode tail;
    // 链表长度
    public int length;

    SingleCycleLinkedList(){
        this.head = new SingleCyleNode(null);
        this.tail = new SingleCyleNode(null);
        head.next = tail;
        tail.next = head;
    }

    public boolean isEmpty(){
        return length == 0;
    }

    public int length(){
        return length;
    }

    // 链表的新增（新增在链表尾部）
    public boolean add(int value) {
        SingleCyleNode node = new SingleCyleNode(value);
        SingleCyleNode temp = head;
        while (tail != temp.next) {
            temp = temp.next;
        }
        temp.next = node;
        node.next = tail;
        length++;
        return true;
    }

    // 链表的新增(指定新增位置)
    public boolean addAt(int i, int value) {
        if (length < i){
            return false;
        }
        SingleCyleNode node = new SingleCyleNode(value);
        SingleCyleNode temp = head;
        // 找到指定位置的前一个位置
        for (int k = 0; k < i - 1; k++) {
            temp = temp.next;
        }
        node.next = temp.next;
        temp.next = node;
        length++;
        return true;
    }

    // 链表的删除(指定位置)
    public boolean removeAt(int i) {
        if (length < i){
            return false;
        }
        SingleCyleNode temp = head;
        // 找到待删除位置的前一个位置
        for (int k = 0; k < i - 1; k++){
            temp = temp.next;
        }
        temp.next = temp.next.next;
        length--;
        return true;
    }

    // 链表的删除(删除指定元素)
    public boolean remove(int value) {
        SingleCyleNode temp = head;
        // 找到待删除位置的前一个位置
        while (tail != temp.next){
            if (temp.next.value == value){
                temp.next = temp.next.next;
                length--;
                return true;
            }
            temp = temp.next;
        }
        return false;
    }

    // 链表的查找
    public SingleCyleNode find(int i){
        if (i > length){
            return null;
        }
        SingleCyleNode temp = head;
        for (int k = 0; k < i; k++){
            temp = temp.next;
        }
        return temp;
    }

    // 链表的更新
    public boolean update(int i, int value){
        if (i > length){
            return false;
        }
        SingleCyleNode temp = head;
        for (int k = 0; k < i; k++){
            temp = temp.next;
        }
        temp.value = value;
        return true;
    }

    public void print(){
        SingleCyleNode temp = head;
        while (tail != temp.next){
            temp = temp.next;
            System.out.println(temp.value);
        }
    }

    public static class SingleCyleNode {
        // 数据域
        Integer value;
        // 指针域
        SingleCyleNode next;

        SingleCyleNode(Integer value){
            this.value = value;
        }
    }

    // 测试类
    public static void main(String[] args){
        SingleCycleLinkedList list = new SingleCycleLinkedList();
        list.add(3);
        list.add(2);
        list.add(4);
        list.addAt(3, 5);
        list.remove(7);
        list.removeAt(5);
        list.remove(3);
        list.removeAt(1);
        SingleCyleNode singleNode = list.find(1);
        list.update(2, 6);
        list.print();
    }

}

五、双向循环链表

1. 双向循环链表的组成
  • 双链表的元素由数据域、Prev指针域和Next指针域组成，各元素通过Prev指针域和Next指针域链接。
  • 每个元素都存在前驱元素和后继元素(包括链头和链尾)

双向循环链表

2. 双向循环链表的插入

双向循环链表的插入

3. 双向循环链表的删除

双向循环链表的删除

4. 双向循环链表的实现
/**
 * 双向循环链表
 */
public class DoubleCycleLinkedList {

    // 头结点
    public DoubleCycleNode head;
    // 尾结点
    public DoubleCycleNode tail;
    // 链表长度
    public int length;

    DoubleCycleLinkedList(){
        this.head = new DoubleCycleNode(null);
        this.tail = new DoubleCycleNode(null);
        head.next = tail;
        head.pre = tail;
        tail.next = head;
        tail.pre = head;
    }

    // 链表的新增（新增在链表尾部）
    public boolean add(int value) {
        DoubleCycleNode node = new DoubleCycleNode(value);
        DoubleCycleNode temp = head;
        while (tail != temp.next) {
            temp = temp.next;
        }
        temp.next = node;
        node.pre = temp;
        tail.pre = node;
        node.next = tail;
        length++;
        return true;
    }

    // 链表的新增(指定新增位置)
    public boolean addAt(int i, int value) {
        if (length < i){
            return false;
        }
        DoubleCycleNode node = new DoubleCycleNode(value);
        DoubleCycleNode temp = head;
        // 找到指定位置的前一个位置
        for (int k = 0; k < i - 1; k++) {
            temp = temp.next;
        }
        node.next = temp.next;
        temp.next = node;
        length++;
        return true;
    }

    // 链表的删除(指定位置)
    public boolean removeAt(int i) {
        if (length < i){
            return false;
        }
        DoubleCycleNode temp = head;
        // 找到待删除位置的前一个位置
        for (int k = 0; k < i - 1; k++){
            temp = temp.next;
        }
        temp.next = temp.next.next;
        length--;
        return true;
    }

    // 链表的删除(删除指定元素)
    public boolean remove(int value) {
        DoubleCycleNode temp = head;
        // 找到待删除位置的前一个位置
        while (tail != temp.next){
            if (temp.next.value == value){
                temp.next = temp.next.next;
                length--;
                return true;
            }
            temp = temp.next;
        }
        return false;
    }

    // 链表的查找
    public DoubleCycleNode find(int i){
        if (i > length){
            return null;
        }
        DoubleCycleNode temp = head;
        for (int k = 0; k < i; k++){
            temp = temp.next;
        }
        return temp;
    }

    // 链表的更新
    public boolean update(int i, int value){
        if (i > length){
            return false;
        }
        DoubleCycleNode temp = head;
        for (int k = 0; k < i; k++){
            temp = temp.next;
        }
        temp.value = value;
        return true;
    }

    public void print(){
        DoubleCycleNode temp = head;
        while (tail != temp.next){
            temp = temp.next;
            System.out.println(temp.value);
        }
    }

    public static class DoubleCycleNode{
        // 数据域
        Integer value;
        // 前指针域
        DoubleCycleNode pre;
        // 后指针域
        DoubleCycleNode next;

        DoubleCycleNode(Integer value){
            this.value = value;
        }
    }

    // 测试类
    public static void main(String[] args){
        DoubleCycleLinkedList list = new DoubleCycleLinkedList();
        list.add(3);
        list.add(2);
        list.add(4);
        list.addAt(3, 5);
        list.remove(7);
        list.removeAt(5);
        list.remove(3);
        list.removeAt(1);
        DoubleCycleNode singleNode = list.find(1);
        list.update(2, 6);
        list.print();
    }

}
爱打羽球的程序猿
关注
专栏目录
go链表(头指针和尾指针)
lljxk2008的博客
02-14 2818
要求: 创建一个空链表, 可以从头部插入任意数据, 也可以从尾部插入, 再遍历出来 分析: 首先肯定是需要一个链表型的结构体          再用一个结构体分别指向链表的头和尾两个节点          向链表添加元素时, 动态修改两个指针的指向          主要弄清楚二者的关系就好理解了, 关系如下图: 上面是结构体链表 /*创建链表结构体, 用于表示实际链表上的节点*...
swift代码-Swift数据结构: 链表(Linked List)
07-14
链表是一种重要的数据结构，它的实现方式与数组不同，它不连续存储元素，而是通过节点之间的引用链接来存储。本篇文章将深入探讨Swift中的链表（Linked List）及其相关知识点。 ### 链表的基本概念 链表由一系列...
【数据结构】单链表的头节点与尾节点
m0_74195174的博客
04-20 1615
头节点和尾节点在单链表中的作用主要体现在简化链表操作和提高代码的可读性和可维护性。它们使得链表的插入、删除和遍历等操作更加高效和一致。然而，并不是所有的单链表实现都会使用头节点，这取决于具体的应用场景和需求。在某些情况下，为了节省内存空间或简化数据结构，可能会选择不使用头节点。这篇文章到这里就结束了如果觉得这篇博客对你有用的话，别忘记三连哦。我是豌豆射手^，让我们我们下次再见。
数据结构——链表
最新发布
2301_80373479的博客
08-13 2025
轻松无痛玩转链表
链表逆置-将给定单向链表逆置，即表头置为表尾，表尾置为表头
Mr.Xiwen博客
03-25 2125
本题要求实现一个函数，将给定单向链表逆置，即表头置为表尾，表尾置为表头。链表结点定义如下： struct ListNode { int data; struct ListNode *next; }; 函数接口定义： struct ListNode *reverse( struct ListNode *head ); 其中head是用户传入的链表的头指针；函数reverse将链表head逆置，并返回结果链表的头指针。 裁判测试程序样例： #include <stdi
带表头表尾的单链表（1）
C_cai_niao的博客
12-06 1053
带表头表尾的单链表（1） 在单链表之前增加一个节点，称为表头节点。表头节点不存放单链表的数据元素，它或者为空，或者用于存放实现算法所需的辅助数据。 初始化 在尾部添加第一个元素 在尾部添加第二个元素 ...
带表头表尾的单链表（2）
C_cai_niao的博客
12-07 445
1 节点类型定义 typedef struct node { struct node* next; int element; }S_NODE; 2 表头表尾类型定义 typedef struct { struct node* top; struct node* last; int num; }S_LIST; 3 链表初始化 void InitList(S_LIST** list) {...
数据结构：图解链表，用链表实现栈的Pop和Push(c语言版)
06-06
本篇文章主要讲解如何利用链表这种数据结构来实现栈这一抽象数据类型，并通过C语言来具体实现栈的两个核心操作——Push（入栈）和Pop（出栈）。链表是一种线性数据结构，其元素不是存储在连续的内存位置中，而是通过...
Java数据结构篇-链表与数组实现栈.pptx.pptx
12-19
在这个话题中，我们将重点关注两种常见的数据结构——链表和数组，并探讨它们如何被用来实现栈这一特定的抽象数据类型。 栈是一种线性数据结构，遵循后进先出（LIFO）的原则，意味着最后进入的元素最先被移出。栈的...
链表尾添加
taw19960426的博客
05-22 560
#include <stdio.h> #include <stdlib.h> //节点结构体 struct Node { int a; struct Node *pNext; } ; //链表的头尾指针 struct Node *g_pHead=NULL; struct Node *g_pEnd=NULL; //创建链表，在链表中增加一个数据（尾添加） vo...
数据结构与算法——链表(头插法，尾插法，循环链表）
weixin_68773927的博客
10-23 2546
注意：由于循环链表没有NULL指针，故涉及遍历操作时，其终止条件就不再像非循环链表那样判断p或p-->next是否为空，而是判断它们是否等于头指针）循环链表：是一种头尾相接的链表（即:表中最后一个结点的指针域指向头结点，整个链表形成一个环状）初始时，r同L均指向头节点，每读入一个数据元素则申请一个新结点，将新结点插入到尾部结点后，r指向新结点。从一个空表L开始，将新结点逐个插入到链表的尾部，尾指针r指向链表的为节点。循环链表的写发与单链表类似 只需改变循环条件。例如：带尾指针循环链表的合并。
链表的头插法和尾插法
m0_53611007的博客
01-12 357
链表是一种非常常见的数据结构，是必须掌握的 链表每一个节点在内存中分布并不是线性的是随机的，是通过数据结构中的next将下一节点与当前节点产生联系，进而连成一个串的，类似下图 菱形代表所存位置的内存值，方块代表每一个链表节点 public class ListNode { public int val;//当前节点的值 public ListNode next;//记录下一节点 //下面三个函数是java的构造函数，方便快速赋值 public ListNode
单链表的创建、插入、删除；创建采用两种不同的方式：一种是从表头到表尾，另一种是从表尾到表头！
chneli609161072的专栏
04-01 941
#include "stdio.h" #include "stdlib.h" typedef int ElemType; ////////////////////////////////////////////////////////////////////////// typedef struct LNode { ElemType data;          //数据域
链表 ,头插法,尾插法
周杰伦
07-31 603
数据的分类： 1、物理结构：数据所在内存的表现（顺序结构、链式结构） 顺序结构：数据之间紧挨在一起 链式结构：不挨在一起 2、逻辑结构：数据之间的联系（散列，线性，树形，图形） 散列：节点之间毫无联系 线性：节点之间存在1:1的联系（每一个节点只有一个直接前驱和一个直接 后驱） 通过物理区来表现线表： 1、顺序线性表 2、链式...
带尾指针的循环链表
Tsoor_h的博客
07-09 305
带尾指针的循环链表以及循环链表的合并
上机题
studyingvs的专栏
03-23 754
#include #include typedef struct node{ int data; struct node *left; struct node *right;}node;void print(node *p){ if(p!=NULL) {  print(p->left);  printf("%d/n",p->data);  print(p->right); }}void main(
TableView之表头、表尾，区头、区尾！
BeanGo的博客
11-15 1871
一、UITableView的UITableViewStyle　　样式分为UITableViewStylePlain和UITableViewStyleGrouped两种；　　plain样式下区头和区尾是悬浮的（即拖动表的时候区头和区尾不会消失，一直显示在界面上）；　　grouped样式区头和区尾是随表一起滑动的。静态的tableview需要分区时（XIB）样式只能是Grouped二、表头和表尾　　通过
线性表-链式存储(头插与尾插)
让你爱上电路设计
05-10 1480
线性表-链式存储(头插与尾插)
数据结构基础：链表详解
"这篇资料主要介绍了数据结构中的链表类型，包括循环链表、双向链表，以及链表在数据结构中的应用，并提到了栈和队列的操作特性。此外，资料还强调了数据结构和算法在构建程序中的核心地位，并简述了程序从简单到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值