线程结构——链表

于 2023-07-27 10:19:14 发布
阅读量153 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shouhu010/article/details/131951728
版权

C++中的链表是一种非常常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

链表结构包括单向链表、双向链表和循环链表；

1.单向链表

单向链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针；

1.1 定义

//单向链表结构
class Node 
{
public:
    int data;
    Node* next;
};

//单向链表类
class LinkedList {
public:
    LinkedList() 
    {
        head = nullptr;
    }
private:
    Node* head;
};

1.2 初始化

对于定义的单向链表类，可以通过构造函数定义元素为空的链表，也可以通过initialize来初始化包含一个元素的链表；

示例

	LinkedList() 
    {
        head = nullptr;
    }
  
    void initialize(int value) 
    {
        head = new Node();
        head->data = value;
        head->next = nullptr;
    }

1.3 获取链表的长度

获取链表的长度，即计算链表中包含多少个元素，通过遍历其中的元素计算

	int length() 
    {
        int count = 0;
        Node* current = head;
        while (current != nullptr) {
            count++;
            current = current->next;
        }
        return count;
    }

1.4 插入元素 && 元素追加

插入元素

根据元素插入的位置和元素来进行元素的插入操作

示例

	void insertNode(int index, int value) 
    {
    	// 判断是否满足插入条件
        if (index < 0 || index > length()) {
            return;
        } else if (index == 0) {    //首元素
            Node* newNode = new Node();
            newNode->data = value;
            newNode->next = head;
            head = newNode;
        } else {
            Node* prevNode = getNode(index - 1);   //根据下标获取元素的方法
            Node* newNode = new Node();
            newNode->data = value;
            newNode->next = prevNode->next;
            prevNode->next = newNode;
        }
    }

元素追加

元素的追加，将元素插入到元素的末尾

	void append(int value) 
    {
        Node* newNode = new Node();
        newNode->data = value;
        newNode->next = nullptr;

        if (head == nullptr) {
            head = newNode;
        } else {
            Node* current = head;
            while (current->next != nullptr) {
                current = current->next;
            }
            current->next = newNode;
        }
    }

1.5 删除元素 && 清空 && 判断是否为空

删除元素

根据下标对元素进行删除

	void deleteNode(int index) 
    {
        if (index < 0 || index >= length()) {
            return;
        } else if (index == 0) {
            Node* temp = head;
            head = head->next;
            delete temp;
        } else {
            Node* prevNode = getNode(index - 1);
            Node* currentNode = prevNode->next;
            prevNode->next = currentNode->next;
            delete currentNode;
        }
    }

清空链表

清空链表中的元素

	void clear() 
	{
        Node* current = head;
        while (current != nullptr) {
            Node* next = current->next;
            delete current;
            current = next;
        }
        head = nullptr;
    }

判断链表是否为空

	bool isEmpty() 
	{
        return (head == nullptr);
    }

1.6 根据下标获取元素

根据链表的下标，来获取该位置的元素

	Node* getNode(int index) 
    {
        if (index < 0 || index >= length()) {
            return nullptr;
        } else {
            Node* current = head;
            int i = 0;
            while (i < index) {
                current = current->next;
                i++;
            }
            return current;
        }
    }

1.7 链表数据元素的打印

	void printList() 
    {
        Node* current = head;
        while (current != nullptr) {
            std::cout << current->data << " ";
            current = current->next;
        }
        std::cout << std::endl;
    }

1.8 应用场景

数据缓存：单向链表可以用作缓存数据结构，新的数据可以插入到链表的头部，而旧的数据可以从尾部移除，以限制缓存大小并保持最近使用的数据在链表的头部。

队列和栈的实现：单向链表可以用来实现队列和栈这两种常见的数据结构。在队列中，数据从尾部插入（入队），从头部删除（出队）。在栈中，数据只在链表的头部插入和删除，模拟了后进先出（LIFO）的行为。

2.双向链表

双向链表与单向链表不同之处在于每个节点除了指向下一个节点的指针外，还包含指向前一个节点的指针，这使得双向链表可以在前后两个方向上遍历和操作节点。

2.1 定义

双向链表这里使用了模板

template<typename T>
class Node {
public:
    T data;
    Node<T>* prev;
    Node<T>* next;
};


template<typename T>
class DoublyLinkedList {
public:
    DoublyLinkedList() {
        head = nullptr;
    }
private:
    Node<T>* head;    
};

2.2 初始化

	void initialize(const T& value) 
	{
        head = new Node<T>();
        head->data = value;
        head->prev = nullptr;
        head->next = nullptr;
    }

2.3 获取链表的长度

	int length() 
    {
        int count = 0;
        Node<T>* current = head;
        while (current != nullptr) {
            count++;
            current = current->next;
        }
        return count;
    }

2.4 插入元素 && 元素追加

插入元素

	void insertNode(int index, const T& value) 
    {
        if (index < 0 || index > length()) {
            return;
        } else if (index == 0) {
            Node<T>* newNode = new Node<T>();
            newNode->data = value;
            newNode->prev = nullptr;
            newNode->next = head;

            if (head != nullptr) {
                head->prev = newNode;
            }
            head = newNode;
        } else {
            Node<T>* prevNode = getNode(index - 1);
            Node<T>* nextNode = prevNode->next;
            Node<T>* newNode = new Node<T>();
            newNode->data = value;
            newNode->prev = prevNode;
            newNode->next = nextNode;

            prevNode->next = newNode;
            if (nextNode != nullptr) {
                nextNode->prev = newNode;
            }
        }
    }

元素追加

	void append(const T& value) 
    {
        Node<T>* newNode = new Node<T>();
        newNode->data = value;
        newNode->prev = nullptr;
        newNode->next = nullptr;

        if (head == nullptr) {
            head = newNode;
        } else {
            Node<T>* current = head;
            while (current->next != nullptr) {
                current = current->next;
            }
            current->next = newNode;
            newNode->prev = current;
        }
    }

2.5 删除元素 && 清空 && 判断是否为空

删除元素

	void deleteNode(int index) 
    {
        if (index < 0 || index >= length()) {
            return;
        } else if (index == 0) {
            Node<T>* temp = head;
            head = head->next;
            if (head != nullptr) {
                head->prev = nullptr;
            }
            delete temp;
        } else {
            Node<T>* currNode = getNode(index);
            if (currNode == nullptr) {
                return;
            }
            Node<T>* prevNode = currNode->prev;
            Node<T>* nextNode = currNode->next;

            prevNode->next = nextNode;
            if (nextNode != nullptr) {
                nextNode->prev = prevNode;
            }
            delete currNode;
        }
    }

清空

	void clear() 
    {
        Node<T>* current = head;
        while (current != nullptr) {
            Node<T>* next = current->next;
            delete current;
            current = next;
        }
        head = nullptr;
    }

判断链表是否为空

	bool isEmpty() 
    {
        return (head == nullptr);
    }

2.6 根据下标来获取元素

	Node<T>* getNode(int index) 
    {
        if (index < 0 || index >= length()) {
            return nullptr;
        } else {
            Node<T>* current = head;
            int i = 0;
            while (i < index) {
                current = current->next;
                i++;
            }
            return current;
        }
    }

2.7 链表数据元素的打印

双向链表支持正向输出和反向输出


    void printListForward(Node<T>* first) 
    {
        Node<T>* current = first;
        while (current != nullptr) {
            std::cout << current->data << " ";
            current = current->next;
        }
        std::cout << std::endl;
    }

    void printListBackward(Node<T>* last) 
    {
        Node<T>* current = last;
        while (current != nullptr) {
            std::cout << current->data << " ";
            current = current->prev;
        }
        std::cout << std::endl;
    }

2.8 应用的场景

实现链表或双端队列：双向链表天然支持在链表头和链表尾高效地插入和删除元素，使其适用于实现链表或双端队列（deque）等数据结构。

实现LRU缓存算法：LRU（Least Recently Used）缓存算法中，当缓存已满时，最近最少使用的元素会被淘汰。双向链表可以方便地记录元素的访问顺序，并且在需要淘汰元素时，可以快速删除链表尾部的节点。

实现迭代器：双向链表的双向遍历特性使其非常适合用于实现迭代器。迭代器可以用于遍历容器中的元素，而双向链表可以提供前向和后向的遍历方式。

3.循环链表

循环链表是一种特殊类型的链表，其中链表的最后一个节点指向第一个节点，形成一个循环。与普通链表不同，循环链表没有一个明确的末尾节点，可以通过任何一个节点遍历整个链表。

3.1 定义

template<typename T>
class Node {
public:
    T data;
    Node<T>* next;
};

template<typename T>
class CircularLinkedList {
public:
    CircularLinkedList() {
        head = nullptr;
    }
private:
    Node<T>* head;    
};

3.2 初始化

	void initialize(const T& value) 
    {
        head = new Node<T>;
        head->data = value;
        head->next = head;
    }

3.3 获取链表的长度

	int length() 
    {
        if (head == nullptr) {
            return 0;
        } else {
            int count = 1;
            Node<T>* current = head->next;
            while (current != head) {
                count++;
                current = current->next;
            }
            return count;
        }
    }

3.4 插入元素 && 元素追加

插入元素

	void insertNode(int index, const T& value) 
    {
        Node<T>* newNode = new Node<T>();
        newNode->data = value;

        if (isEmpty() || index <= 0) {
            head = newNode;
            head->next = head;
        } else {
            Node<T>* prevNode = getNode(index - 1);
            if (prevNode == nullptr) {
                delete newNode;
                return;
            }
            newNode->next = prevNode->next;
            prevNode->next = newNode;
        }
    }

元素追加

	void append(const T& value) 
	{
        Node<T>* newNode = new Node<T>;
        newNode->data = value;
        newNode->next = head;

        if (head == nullptr) {
            head = newNode;
            newNode->next = head;
        } else {
            Node<T>* current = head;
            while (current->next != head) {
                current = current->next;
            }
            current->next = newNode;
        }
    }

3.5 删除元素 && 清空 && 判断是否为空

删除元素

	void deleteNode(int index) 
    {
        if (isEmpty() || index < 0) {
            return;
        } else if (index == 0) {
            Node<T>* currNode = head;
            if (head->next == head) {
                head = nullptr;
            } else {
                Node<T>* lastNode = head;
                while (lastNode->next != head) {
                    lastNode = lastNode->next;
                }
                lastNode->next = head->next;
                head = head->next;
            }
            delete currNode;
        } else {
            Node<T>* prevNode = getNode(index - 1);
            if (prevNode == nullptr || prevNode->next == head) {
                return;
            }
            Node<T>* currNode = prevNode->next;
            prevNode->next = currNode->next;
            delete currNode;
        }
    }

清空

	void clear() {
        Node<T>* current = head;
        while (current != nullptr && current->next != head) {
            Node<T>* next = current->next;
            delete current;
            current = next;
        }
        head = nullptr;
    }

判断是否为空

	bool isEmpty() 
	{
        return (head == nullptr);
    }

3.6 根据下标来获取元素

	Node<T>* getNode(int index) 
	{
        if (index < 0 || index >= length()) {
            return nullptr;
        } else {
            Node<T>* current = head;
            int i = 0;
            while (i < index) {
                current = current->next;
                i++;
            }
            return current;
        }
    }

3.7 链表元素的打印

	void printCircularLinkedList(Node<T>* head) 
    {
        if (head == nullptr) {
            return; // 空链表
        }

        Node<T>* current = head;
        do {
            std::cout << current->data << " ";
            current = current->next;
        } while (current != head);

        std::cout << std::endl;
    }

3.8 应用场景

环形缓冲区（Circular Buffer）：环形缓冲区是一种常用的高效数据存储结构，常用于实现循环队列。在环形缓冲区中，最后一个元素的下一个位置是第一个元素，形成一个循环。循环链表提供了一种有效的数据结构来实现环形缓冲区。

循环播放列表：在音乐播放器或视频播放器中，可以使用循环链表来实现循环播放列表。每个歌曲或视频可以用链表节点表示，通过调整节点的顺序，可以实现循环播放功能。

青山覆白雪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程安全链表操作的C程序
12-04
C实现的多线程（pthread）安全链表数据结构 包括member, insert, delete, traverse基本操作 编译时需要链接pthread库，如 gcc -O3 SortList2.c -lpthread
线程的数据结构
曾梦想仗剑走天涯
12-26 7794
除非显式地声明，否则，你可以假设以下讨论的内容既适合用户模式的线程，也适用于内核模式的线程。在系统级别上，Windows线程是由一个线程块执行体（ETHREAD）来表示的，如图6.7所示。ETHREAD块和它所指向的结构都位于系统地址空间中，唯一的例外是线程环境快（TEB），它位于进程地址空间中。而且，Windows子系统进程（Csrss）为Windows进程中创建的每个线程维护了一个平行结构
多线程的那点儿事（之多线程数据结构）
hgcghhgg的博客
11-14 226
多线程的那点儿事（之多线程数据结构）
Windows中进程和线程数据结构(下)
maomao171314的专栏
11-26 777
2 执行体层的进程和线程对象 执行体层进程对象的数据结构EPROCESS，第一部分 Pcb : KPROCESS 内嵌结构体 ProcessLock : 一个推锁(push lock)对象，用于保护EPROCESS中的数据成员 CreateTime : 进程的创建时间 ExitTime : 进程的退出时间 RundownProtect : 进程的停止保护锁。当一个进程到最后被销毁时，它要等到所有其他进程和线程以及释放了此锁，才可继续进行 UniqueProcessId : 进程的唯一编号.
(21)[进程与线程] 进程链表和线程链表
最新发布
qq_50332504的博客
08-11 370
本章包含几个小实验，DebugPort置零，进程断链、线程断链......一切的一切都不能使得进程真正藏起来
数据结构课程设计——客运订票系统
02-11
在这个订票系统中，可能用到的数据结构包括数组、链表、栈、队列、树（如二叉树或AVL树）和哈希表。例如，数组可以用于存储车站信息，链表则适合动态管理票务库存，而哈希表可以高效地进行座位查找和预订。 2. **栈...
数据结构——队列的实现
10-26
3. 链式队列：使用链表作为底层数据结构，灵活且易于扩展。 4. 双端队列（Deque）：允许在队头和队尾同时进行入队和出队操作，提高了效率。 5. 阻塞队列：在多线程环境中，当队列为空时，出队操作会阻塞直到有元素...
《C语言深度解析》第9、10章——位操作 /c标准IO、网络编程/线程/链表
06-12
本课程主要讲解以下内容：1. 位操作（位运算）2. c语言的标准IO函数3.标准IO与文件IO、常见标准IO函数有哪些、fopen/...多线程、网络编程、数据库、数据结构、顺序表、链表、单链表、双链表、队列/栈、Linux内核链表
数据结构课设——队列程序.doc
10-03
5. **性能优化**：为了进一步提高效率，可以考虑使用多线程或异步I/O，使得CPU在等待数据处理时可以执行其他任务。 在实施过程中，学生需要进行以下步骤： 1. **算法设计**：首先，需要设计一个有效的队列操作算法...
数据结构——简单例子的程序（C语言实现）
02-01
队列是一种先进先出（FIFO）的数据结构，广泛应用于任务调度、缓冲区管理和多线程通信。 以上是对压缩包中各源代码文件的初步解读，每个文件都对应了数据结构的一个重要方面。对于初学者来说，通过阅读和理解这些...
c语言实现多线程下的链表队列
热门推荐
judwenwen2009的专栏
12-23 1万+
项目中需要一个链表，线程A进行入队操作，线程B进行查询出队操作，同时不希望线程B在队列为空时阻塞，降低cpu负载，因此考虑用pthread_cond_wait进行实现： 主要实现功能： 1）出队和入队的加锁 2）当有元素入队时唤醒线程B 3）队列为空时线程B进入休眠
多线程编程 -- 线程安全的链表
u201012980的专栏
07-31 1万+
互斥量Mutex互斥量本质上是一把锁，在访问共享资源钱对互斥量进行加锁，访问完成之后释放互斥量的锁。 pthread_mutex_t , 使用之前，必须首先对初始化对互斥量进行加锁，调用pthread_mutex_lock 如果互斥量已经上锁，则线程将阻塞知道互斥量被解锁如果不希望被阻塞，它可以使用pthread_mutex_trylock 尝试对互斥量进行加锁。如果互斥量处于未锁住状态， 那
EThread的线程链表
Sunny_wwc的专栏
06-24 3268
【提示】能加驱动进内核，就没必要弄EXE了，所以我个人觉得没啥实际用途，仅供观看Windows会给每一个进程建立一个EPROCESS结构，给每一个线程建立ETHREAD结构，EPROCESS结构第一个成员是KPROCESS结构，ETHREAD结构第一个成员是KTHREAD结构。每个进程的线程的ETHREAD结构都会按下图所示链接起来：<img style="margin: 2px;" title=
《算法基础》——3.7　多线程链表
weixin_33895695的博客
05-02 327
本节书摘来自华章计算机《算法基础》一书中的第3章，第3.7节，作者：（美）罗德·斯蒂芬斯（Rod Stephens）著，更多章节内容可以访问云栖社区“华章计算机”公众号查看 3.7　多线程链表 在一个单向链表中，一个单元格会有到下一个单元格的链接。在一个双向链表里，每个单元格都有到前一个单元格和到后一个单元格的链接。双向链表使用两种链接，以提供两种不同的...
多线程读写链表 pthread
weixin_33829657的博客
09-22 642
2019独角兽企业重金招聘Python工程师标准>>> ...
生产者消费者-线程-链表-队列实现
he_0123的专栏
01-04 608
生产者消费者-线程-链表-队列实现链表实现#include<stdio.h> #include<pthread.h> #include<stdlib.h> #include<unistd.h>pthread_mutex_t lock; pthread_cond_t cond; struct node { int iValue; struct node *next; }*head =
数据结构课程设计.docx
06-18
"数据结构课程设计，关注链表操作，实现航空订票系统的查询、订票和退票功能。" 本课程设计主要针对航空订票系统，利用数据结构中的链表来存储和管理航线信息、订票和退票业务。在系统中，数据结构的设计至关重要，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值