C++双向链表的实现

最新推荐文章于 2022-01-25 08:51:17 发布
最新推荐文章于 2022-01-25 08:51:17 发布
阅读量337 收藏
点赞数
分类专栏： c++ 文章标签： 双向链表 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cvhbfgh/article/details/70241606
版权
#include <iostream>
#include <assert.h>
using namespace std;
typedef int DataType;
// 首先要明白一个链表的组成，链表又结点连接起来构成，我们定义出一个结点的结构体，每一个结点都有自己的next域，pre 域，以及自身的数据。
struct Node
{
Node( const DataType& data = DataType())
:_next(NULL)
, _pre(NULL)
, _data(data)
{}

Node *_next;
Node *_pre;
DataType _data;
};
// 创建链表结构体的时候，要清楚，一个链表会有自己的头指针，尾指针，还有链表的结点数。我们把链表的头,尾指针都定义为Node*类型。
class List
{
public:
List()//空链表的构造函数
:_pHead(NULL)
, _pTail(NULL)
, _size(0)
{}
Node *_pHead;
Node *_pTail;
size_t _size;
List(size_t n, const DataType & data = DataType())//明确给出构造n个结点，并且每个结点的值为默认值
:_pHead(NULL)
, _pTail(NULL)
, _size(0)
{
/*_pHead = _pTail = new Node(data);//我们可以用这样的方式来构造出一条链表
for (size_t idx = 0; idx < n - 1; idx++)
{
Node*pCur = new Node(data);
_pTail->_next = pCur;
pCur->_pre = _pTail;
_pTail = pCur;
}*/
for (size_t idx = 0; idx < n; idx++)//直接用尾插法创建链表
{
PushBack(data);
}

}
bool Empty()const//判断链表是否为空，因为后面的好多地方都要用到这些代码，为了提高代码的复用率，直接封装一个函数。
{
return (NULL == _pHead);
}
void PushBack(const DataType &data)
{
Node* pNode = new Node(data);
if (Empty())
{
_pHead = _pTail = pNode;

}
else
{
_pTail->_next = pNode;
pNode->_pre = _pTail;
_pTail = pNode;
}
_size++;

}
void PopBack(const DataType& data)
{
if (Empty())
{
assert(false);
return;
}
else if (_pHead=_pTail)//只有一个结点；
{
delete _pHead;
_pHead = _pTail = NULL;
   
}
else
{
_pTail = _pTail->_pre;
delete _pTail->_next;
_pTail->_next = NULL;
}
--_size;
}
void PushFront(const DataType& data)
{
Node*pNode = new Node(data);
if (Empty())
{
_pHead = _pTail = pNode;

}
else
{
pNode->_next = _pHead;
_pHead->_pre = pNode;
_pHead = _pHead->_pre;
}
_size++;
}
void PopFront()
{
if (Empty())
{
assert(false);
return;
}
else if (_size == 1)
{
delete _pHead;
_pHead = _pTail = NULL;
}
else
{
_pHead = _pHead->_next;
delete _pHead->_pre;
_pHead->_pre = NULL;
}
_size--;
}
Node*find(const DataType &data)
{
Node * pCur = _pHead;
while (pCur)
{
if (pCur->_data = data)
return pCur;
pCur = pCur->_next;
}
return NULL;
}
size_t Size()const
{
return _size;
}

DataType& Front()
{
return _pHead->_data;
}

const DataType& Front()const
{
return _pHead->_data;
}

DataType& Back()
{
return _pTail->_data;
}

const DataType& Back()const
{
return _pTail->_data;
}
void print_List()
{
Node*phead = _pHead;
while (phead){
cout << phead->_data << "->" << endl;
phead = phead->_next;
}
}
void insert(Node* pos, DataType x)
{
assert(pos);//防止pos为空指针  
if (Empty())
{
return;
}
else
{
Node* pCur = _pHead;
if (_pHead == pos)
{
PushFront(x);
}
else
{
while (pCur)
{
if (pCur == pos)
{
Node* tmp = new Node[sizeof(Node)];
tmp->_data = pCur->_data;
tmp->_next = pCur->_next;
tmp->_pre = pCur;
pCur->_data = x;
pCur->_next = tmp;
return;//insert成功后不要忘了直接返回结束函数  
}
pCur = pCur->_next;
}
cout << "没有找到这个数字" << endl;
}
}
}

void erase(Node* pos)//删除指定位置的结点  
{
assert(pos);
if (Empty())
{
return;
}
else
{
if (pos == _pHead)
{
PopFront();
}
else
{
Node* del = _pHead->_next;
Node* pre = _pHead;
while (del)
{
if (del == pos)
{
if (del->_next != NULL)
{
pre->_next = del->_next;
del->_next->_pre = pre;
delete del;
del = NULL;
}
else
{
delete del;
pre->_next = NULL;
}
return;
}
del = del->_next;
pre = pre->_next;
}
}
}
}

};
【C++】双向链表
Sunny的博客
03-05 1230
逆序建立一个双向链表，该链表从第二个结点至表尾递增有序，将第一个结点删除并插入到适当位置，使整个链表仍然递增有序。
c++ 双向链表
qq_42972267的博客
01-20 1102
#include &amp;lt;iostream&amp;gt; using std::cout; using std::endl; struct Node { int data; struct Node * next; struct Node * pre; }; 一、创建双向链表 Node * createList() { Node * head = new Node; if (NULL == ...
双向链表(C++实现)
webcenterol
07-06 128
数据结构是学习C/C++，继指针后的最大难关之一。这一关的核心是链表。链表是使用最广泛的数据结构，可以说它是你学习计算机进入中级水平的敲门砖！ 本文提供完整的双向链表代码，虽然只有区区几页，确值得你把每一行都深刻在心中！希望初学者化一周时间(当然你得已经可以无困难的理解指针)，把它滚瓜烂熟，达到能给别人讲的地步！此代码来自VC5带的SDK的DirectX的例子，在VCSAMPLES\SDK\DIR...
C++双向链表
sinat_27990067的博客
01-25 783
最早开始接触C++大概是在07年，真正开始学是在12年。那时候给我留下的印象就是普通数组是静态的，动态数组创建贼麻烦，当时比较常用的实现方法是用链表。链表的原理很简单，但是实现起来也挺复杂的。后来又学习了Python，发现数组好简单而且很灵活。时隔多年，再次用C++写插件，对于数据结构的认识还停留在多年前。为了实现自建类型的动态数组结构，第一想到的还是链表。参照网上的例子自己写了一个完整的链表类，放在这里留个记录。现在的C++已经丰富了很多特性，其中vector就可以很轻松的实现。其实内部逻辑应该都是一样的
C++双向链表实现简单通讯录
08-19
C++双向链表实现简单通讯录 在本文中，我们将详细介绍C++双向链表实现简单通讯录的实现方法。我们将从头开始，了解C++双向链表的基本概念，然后逐步实现一个简单的通讯录系统。 首先，让我们了解一下C++双向链表...
C++的双向链表实现
04-15
**C++的双向链表实现** 在C++中，双向链表是一种数据结构，它包含节点，每个节点都有指向其前一个节点和后一个节点的指针。这使得在链表中的导航比单链表更加灵活，因为可以向前或向后移动。双向链表在许多算法和...
C++ 实现双向链表的实例
12-31
双向链表C++ 的实现   本文是通过C++ 的知识实现数据结构中的双向链表，这里不多说 了，代码注释很清楚， 实现代码： //double LinkList implement with C++ template #include using namespace std; /*template...
c++双向链表操作示例(创建双向链、双向链表中查找数据、插入数据等)
12-25
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表...
双向链表C++
alanmian的博客
11-06 3503
双向链表，顾名思义，一条可双向进行的就叫双向链表。那怎么搞？也就是有前驱跟后继，有些时候有人不明白什么是前驱跟后继啊，浅显的讲讲，前驱就是当前结点指向上一个结点的箭头，那么上一个结点就是当前结点的前驱，后继就是当前结点的前一个结点，从上一个结点指向当前结点就叫后继，也就是说上个结点作为头，那当前结点作为尾，头的后继不就是尾嘛。 然后有头尾指针，双向嘛。头指针运动，尾指针也运动，所以这里要多存个尾指针。那说了这么多，先来构造给双向链表吧。 定义结构体老掉牙的东西了 思路！： 1.刚前面说了有前驱跟后继，那么
C++实现双向链表
weixin_34248258的博客
03-20 124
List.h////////////////////////////////////////////////////////////////////////////////////// ///////这里建立两个类，一个节点类和一个List类，与单链表不同的是双向链表的节点要多一 //////个前驱指针,相应的，双向链表函数实现要与单链表实现有所差异 typed...
用C++实现的双向链表
gaoshanliushui911的专栏
10-11 485
//list.h双向链表类#include#includeusing namespace std;templateclass list{protected: //节点结构体 struct Node { T item; Node* next; Node* prev; };public: //构造函数，链表初始化list() {length=0;head=NULL;tail=NULL;}//返
C++ 双向链表
qts5418814524的博客
10-31 391
链表相信大家都不陌生，它是一种线性表。链表存储是很麻烦的，但是它也有好处，例如它可以插入或删除数据，能够释放空间，这些是数组做不到的。下面是双向链表代码。 首先一些准备： struct Node{ int data; Node *pre,*next; }*r,*p,*s; 接下来就是最基本的建立双向链表和给双向链表赋值： void creat(Node *head){ int x; cin>>x; r=head; while(x!=-1){ p=new
双向链表C++实现
weixin_44844149的博客
06-09 344
在设计链表增删操作的方法时，要注意增删位置在链表中的位置，就只有三种情况，head位置，tail位置和中间位置，不同位置对指针的连接方式会有不同，一般都要用if进行判断，这些在代码中已经解释的很详细了。除此之外，在首尾进行操作时，也要对节点数量进行判断，也有三种情况，最简单的情形是空链表，其次是单节点，再就是一般的多节点情形，针对不同的情形用if进行判断，并做好指针维护即可，这些在代码中也有详细的...
c++双向链表实现通讯录
最新发布
05-22
以下是使用 C++ 实现双向链表的通讯录的示例代码： ```c++ #include <iostream> #include <string> using namespace std; // 定义联系人结构体 struct Contact { string name; string phone; }; // 定义双向链表节点结构体 struct ListNode { Contact data; ListNode* prev; ListNode* next; ListNode(Contact value): data(value), prev(nullptr), next(nullptr) {} }; // 定义双向链表类 class DoubleLinkedList { private: ListNode* head; ListNode* tail; int size; public: DoubleLinkedList(): head(nullptr), tail(nullptr), size(0) {} ~DoubleLinkedList() { ListNode* p = head; while (p != nullptr) { ListNode* q = p->next; delete p; p = q; } head = tail = nullptr; size = 0; } void append(Contact value) { ListNode* node = new ListNode(value); if (tail == nullptr) { head = tail = node; } else { tail->next = node; node->prev = tail; tail = node; } size++; } void remove(ListNode* node) { if (node == nullptr) return; if (node == head) { head = head->next; if (head != nullptr) { head->prev = nullptr; } else { tail = nullptr; } } else if (node == tail) { tail = tail->prev; if (tail != nullptr) { tail->next = nullptr; } else { head = nullptr; } } else { node->prev->next = node->next; node->next->prev = node->prev; } delete node; size--; } void print() { ListNode* p = head; while (p != nullptr) { cout << "Name: " << p->data.name << ", Phone: " << p->data.phone << endl; p = p->next; } } int getSize() { return size; } }; int main() { DoubleLinkedList contacts; Contact c1 = {"Alice", "123456789"}; Contact c2 = {"Bob", "234567890"}; Contact c3 = {"Charlie", "345678901"}; contacts.append(c1); contacts.append(c2); contacts.append(c3); contacts.print(); cout << "Size: " << contacts.getSize() << endl; // 删除 Bob 的联系方式 ListNode* p = contacts.head; while (p != nullptr) { if (p->data.name == "Bob") { contacts.remove(p); break; } p = p->next; } contacts.print(); cout << "Size: " << contacts.getSize() << endl; return 0; } ``` 上述代码实现了一个基本的双向链表类，其中节点结构体 `ListNode` 包括了联系人结构体 `Contact` 和前驱节点和后继节点指针。在主函数中，我们创建了三个联系人并添加到双向链表中，然后打印出链表中所有联系人的信息。接着，我们使用循环遍历链表，找到名字为 Bob 的联系人并删除它，最后再次打印出链表中剩余的联系人信息和链表大小。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值