在编码中避免不了使用链表,特别是循环链表,很多同学使用时为了省事直接使用C++ STL库中的链表实现,这样当然很简单也不容易出错,但同时也不可避免的带来了一些问题:
- 是半个黑盒,虽然能看源码,但是经过层层封装的STL源码很少有人愿意去认真看
- 随着C++版本的修改,部分特性可能会改变,可能会引入一些不必要的问题
因此有必要实现一款属于自己的双向链表,这样在有需要的时候就能随时增加自己的特性,让链表更好的服务于其他模块。
在使用C++实现链表时,我们需要实现两个主要的类:1. node节点类 ,2. 链接node节点的类
一般为了实现node的后期扩展,会将node实现成抽象类,后期根据自己需要进行扩展
cpp
class Node {
public:
~Node() = default;
};
然后在通过继承node类来实现自己链表中使用的node节点类
cpp
// 实现保存单个节点的链表
class NodeImpl : public Node {
public:
explicit NodeImpl(uint64_t sequence_number)
: sequence_number_(sequence_number) {}
uint64_t sequence_number() const { return sequence_number_; }
private:
// 节点管理类中需要直接使用成员变量,这里将其声明为友元类
friend class TailList;
// 双向链表要有指向前方和后方的指针
NodeImpl* prev_{};
NodeImpl* next_{};
// 真正保存的数据
const uint64_t sequence_number_;
};
首先,我们看到NodeImpl
类继承自基类Node
,它作为链表中的实际节点实现。每个NodeImpl
对象都包含了一个表示序列号的uint64_t
类型成员变量sequence_number_
,以及两个指向前驱和后继节点的双向指针prev_
和next_
。由于TailList
类需要访问这些私有成员,因此NodeImpl
将TailList
声明为友元类以允许直接操作。
cpp
class TailList {
public:
TailList() : head_(0) {
// 将自己指向自己形成一个最小环
head_.prev_ = &head_;
head_.next_ = &head_;
}
// 如果自己指向自己说明是空的,没有任何节点数据
bool empty() const { return head_.next_ == &head_; }
NodeImpl* oldest() const {
return head_.next_;
}
NodeImpl* newest() const {
return head_.prev_;
}
// new 出一个node节点,并把对应的node放到链表结尾
NodeImpl* New(uint64_t sequence_number) {
auto* node = new NodeImpl(sequence_number);
// 生成一个节点,并将节点插入环装链表的尾部
node->next_ = &head_;
node->prev_ = head_.prev_;
node->prev_->next_ = node;
node->next_->prev_ = node;
return node;
}
// 清理链表中的节点
static void Delete(const NodeImpl* node) {
node->prev_->next_ = node->next_;
node->next_->prev_ = node->prev_;
delete node;
}
private:
// 双向链表的原点,默认不存储任何数据
NodeImpl head_;
};
接下来,TailList
类负责维护整个循环链表的结构。初始化时,它创建一个头节点head_
,该节点的前驱和后继均指向自身,形成一个空链表的"闭环"。通过empty()
函数可以快速检查链表是否为空,只需看head_
的下一个节点是否仍是指向自己即可。
链表提供了oldest()
和newest()
接口,分别用于获取链表中最旧(第一个加入)和最新(最后一个加入)的节点。核心方法New(uint64_t sequence_number)
用于创建新节点并将新节点插入到链表的尾部,即每次新增节点都会成为新的末尾节点。这个方法巧妙地利用双向链表的特点,通过更新新节点及其相邻节点的前后指针来完成插入操作。
同时,Delete(const NodeImpl* node)
静态方法用来安全地从链表中移除指定节点,并释放其内存资源。此方法同样通过调整被删除节点前后节点之间的链接关系,确保链表的连续性不受影响。
cpp
int main(int argc, char* argv[]) {
TailList list;
list.New(1);
list.New(2);
list.New(3);
list.New(3);
list.New(3);
list.New(3);
do {
auto lpNode = list.newest();
std::cout << lpNode->sequence_number() << std::endl;
TailList::Delete(lpNode);
} while (!list.empty());
return 0;
}
最后,在main()
函数中,我们展示了链表的实际应用。程序首先创建了一个TailList
对象,并连续调用New()
方法添加了几个具有不同序列号的节点。然后,通过一个do-while
循环不断地找到链表中的最新节点,输出其序列号,并通过Delete()
方法删除它,直到链表为空为止。
cpp
//
// Created by wangyz38535 on 2024/4/24.
//
#include <iostream>
// 尾插式循环链表
class TailList;
class Node {
public:
~Node() = default;
};
// 实现保存单个节点的链表
class NodeImpl : public Node {
public:
explicit NodeImpl(uint64_t sequence_number)
: sequence_number_(sequence_number) {}
uint64_t sequence_number() const { return sequence_number_; }
private:
// 节点管理类中需要直接使用成员变量,这里将其声明为友元类
friend class TailList;
// 双向链表要有指向前方和后方的指针
NodeImpl* prev_{};
NodeImpl* next_{};
// 真正保存的数据
const uint64_t sequence_number_;
};
class TailList {
public:
TailList() : head_(0) {
// 将自己指向自己形成一个最小环
head_.prev_ = &head_;
head_.next_ = &head_;
}
// 如果自己指向自己说明是空的,没有任何节点数据
bool empty() const { return head_.next_ == &head_; }
NodeImpl* oldest() const {
return head_.next_;
}
NodeImpl* newest() const {
return head_.prev_;
}
// new 出一个node节点,并把对应的node放到链表结尾
NodeImpl* New(uint64_t sequence_number) {
auto* node = new NodeImpl(sequence_number);
// 生成一个节点,并将节点插入环装链表的尾部
node->next_ = &head_;
node->prev_ = head_.prev_;
node->prev_->next_ = node;
node->next_->prev_ = node;
return node;
}
// 清理链表中的节点
static void Delete(const NodeImpl* node) {
node->prev_->next_ = node->next_;
node->next_->prev_ = node->prev_;
delete node;
}
private:
// 双向链表的原点,默认不存储任何数据
NodeImpl head_;
};
int main(int argc, char* argv[]) {
TailList list;
list.New(1);
list.New(2);
list.New(3);
list.New(3);
list.New(3);
list.New(3);
do {
auto lpNode = list.newest();
std::cout << lpNode->sequence_number() << std::endl;
TailList::Delete(lpNode);
} while (!list.empty());
return 0;
}
总结起来,这段代码提供了一个简洁而实用的尾插式循环链表的实现,适用于需要高效进行顺序添加和按最近添加顺序删除元素的场景。通过合理的封装和设计,使得链表的操作既直观又易于维护。