C++ 双向链表

最新推荐文章于 2021-04-30 17:47:16 发布
最新推荐文章于 2021-04-30 17:47:16 发布
阅读量754 收藏 2
点赞数
分类专栏： C++ 文章标签： c++ null insert list delete pointers
  
数据结构是学习C/C++，继指针后的最大难关之一。这一关的核心是链表。链表是使用最广泛的数据结构，可以说它是你学习计算机进入中级水平的敲门砖！

本文提供完整的双向链表代码，虽然只有区区几页，确值得你把每一行都深刻在心中！希望初学者化一周时间(当然你得已经可以无困难的理解指针)，把它滚瓜烂熟，达到能给别人讲的地步！此代码来自VC5带的SDK的DirectX的例子，在 VCSAMPLES\SDK\DIRECTX\INCLUDE和VCSAMPLES\SDK\DIRECTX\CGUTIL

view plaincopy to clipboardprint?//| File:    linklist.h     
#ifndef _LINKLIST_H     
#define _LINKLIST_H     
typedef struct _NODE  
{    
    struct _NODE    *pPrev;    
    struct _NODE    *pNext;    
    void  *pData;    
} NODE,  *LPNODE;    
class CLinkedList {    
private:    
    LPNODE   Find(void  *pData);    
    LPNODE   pHead;    
    LPNODE   pTail;    
    LPNODE   pCurPosition;    
public:    
    CLinkedList();    
    ~CLinkedList();    
    void *GetFirst();    
    void *GetLast();    
    void *GetNext();    
    void *GetNext(void  *pData);    
    void *GetPrev();    
    void *GetPrev(void  *pData);    
    void Add(void  *pData);    
    void Insert(void  *pData);    
    void Insert(void *pData, void  *pBefore);    
    void Append(void  *pData);    
    void Remove();    
    void Remove(void  *pData);    
    void *RemoveFirst();    
    void *RemoveLast();    
};    
#define LinkedList  CLinkedList     
#endif  
//| File:    linklist.h  
#ifndef _LINKLIST_H  
#define _LINKLIST_H  
typedef struct _NODE
{  
	struct _NODE    *pPrev;  
	struct _NODE    *pNext;  
	void  *pData;  
} NODE,  *LPNODE;  
class CLinkedList {  
private:  
	LPNODE   Find(void  *pData);  
	LPNODE   pHead;  
	LPNODE   pTail;  
	LPNODE   pCurPosition;  
public:  
	CLinkedList();  
	~CLinkedList();  
	void *GetFirst();  
	void *GetLast();  
	void *GetNext();  
	void *GetNext(void  *pData);  
	void *GetPrev();  
	void *GetPrev(void  *pData);  
	void Add(void  *pData);  
	void Insert(void  *pData);  
	void Insert(void *pData, void  *pBefore);  
	void Append(void  *pData);  
	void Remove();  
	void Remove(void  *pData);  
	void *RemoveFirst();  
	void *RemoveLast();  
};  
#define LinkedList  CLinkedList  
#endif
 

view plaincopy to clipboardprint?//| File:    linklist.cpp = a doubly linked list.     
#include "linklist.h"     
#define NULL  0L     
CLinkedList::CLinkedList()  // CLinkedList constructor     
{    
    pHead = pTail = pCurPosition = NULL;    
}    
CLinkedList::~CLinkedList()//  CLinkedList destructor - free each node     
{    
    LPNODE  pCur, pNext;    
    pCur = pHead;    
    pHead = pTail = pCurPosition = NULL;    
    // Go thru list and free each node     
    while (pCur != NULL)    
    {    
        pNext = pCur->pNext;    
        delete(pCur);    
        pCur = pNext;    
    }    
}      
//  GetFirst - return app data for first entry in list and make it the current node.     
void  * CLinkedList::GetFirst()    
{    
    pCurPosition = pHead;    
    if (pCurPosition == NULL)    
    {    
        return(NULL);    
    }    
    return(pCurPosition->pData);    
}    
// GetLast - return app data to last entry in list and make it the current node.     
void  * CLinkedList::GetLast()    
{    
    pCurPosition = pTail;    
    if (pCurPosition == NULL)    
    {    
        return(NULL);    
    }    
    return(pCurPosition->pData);    
}    
// GetNext - return next app data entry in list and make it the current node.     
void  * CLinkedList::GetNext()    
{    
    LPNODE  pNext;    
    // check for empty list or already at end of list.     
    if ((pCurPosition == NULL) || (pCurPosition->pNext == NULL))    
    {    
        return(NULL);    
    }    
    pNext = pCurPosition->pNext;    
    pCurPosition = pNext;    
    return(pNext->pData);    
}    
//  GetFirst - return app data that follows a given entry and make it the current node.     
void  * CLinkedList::GetNext(void  *pData)    
{    
    pCurPosition = Find(pData);    
    return(GetNext());    
}    
// GetPrev - return app data for previous entry in list and make it the current node.     
void  * CLinkedList::GetPrev()    
{    
    LPNODE  pPrev;    
    // check for empty list or already at start     
    if ((pCurPosition == NULL) || (pCurPosition->pPrev == NULL))    
    {    
        return(NULL);    
    }    
    pPrev = pCurPosition->pPrev;    
    pCurPosition = pPrev;    
    return(pPrev->pData);    
      
}    
//  GetFirst - return app data that preceeds a given entry and make it the current node.     
void  * CLinkedList::GetPrev(void  *pData)    
{    
    pCurPosition = Find(pData);    
    return(GetPrev());    
}    
//  Add - create a new node and put it at the start of the list and make it the current node.     
void CLinkedList::Add(void  *pData)    
{    
    LPNODE  pNew = new NODE;    
    // setup node and prepare it for its role as the new head of the list     
    pNew->pData = pData;    
    pNew->pNext = pHead;    
    pNew->pPrev = NULL;    
    // The old head of list (if any) should point to new node)     
    if (pHead != NULL)    
        pHead->pPrev = pNew;    
    // Make new node the head and current position     
    pHead = pNew;    
    pCurPosition = pNew;    
    // Check to see if new node is also the tail (ie. only list entry)     
    if (pTail == NULL)    
        pTail = pNew;    
}    
//  Append - create a new node and put it at the end of the list.     
void CLinkedList::Append(void  *pData)    
{    
    LPNODE  pNew = new NODE;    
    // setup node and prepare it for its role as the new tail of the list     
    pNew->pData = pData;    
    pNew->pPrev = pTail;    
    pNew->pNext = NULL;    
    // The old tail of list (if any) should point to new node.     
    if (pTail != NULL)    
        pTail->pNext = pNew;    
    // Make new node the tail     
    pTail = pNew;    
    // Check to see if new node is also the head (ie. only list entry)     
    if (pHead == NULL)    
    {    
        pHead = pNew;    
        pCurPosition = pNew;    
    }    
}    
//  Find - private method to find the node with the specified app data attached to it.     
LPNODE CLinkedList::Find(void  *pData)    
{    
    LPNODE pCur;    
    // go thru list until we reach end or we find the right node.     
    for (pCur=pHead; (pCur != NULL) && (pCur->pData != pData); pCur= pCur->pNext);    
    return(pCur);    
}    
//  Insert - create a new node and put it in front of the current position node and make it the current position.     
void CLinkedList::Insert(void  *pData)    
{    
    LPNODE  pNext, pPrev;    
    LPNODE  pNew = new NODE;    
    pNew->pData = pData;    
    // check to be sure that there is a current node     
    if (pCurPosition != NULL)    
    {    
          
        // get pointers of current position     
        pPrev = pCurPosition->pPrev;    
        pNext = pCurPosition->pNext;    
        // set new nodes pointers for insertion into the list     
        pNew->pPrev = pPrev;    
        pNew->pNext = pCurPosition;    
        // Set the node in front of new node (if any) to point to it     
        if (pPrev != NULL)    
        {    
            pPrev->pNext = pNew;    
            // No node in front -> new node is at head     
        } else {    
            pHead = pNew;    
        }    
        // make new node the current node     
        pCurPosition = pNew;    
        // No current node, just Add to front     
    } else {    
        Add(pData);    
    }    
}    
//  Insert - create a new node and put it in front of the specified node and make it the current position.     
void CLinkedList::Insert(void *pData, void  *pBefore)    
{    
    // simply make the specified node current and insert the new     
    // node.     
    pCurPosition = Find(pBefore);    
    Insert(pData);    
}    
  
//  Remove - remove a specified node from the list.     
//  Note: we do not delete the app data attached to the node!     
void CLinkedList::Remove()    
{    
    LPNODE  pCur, pNext, pPrev;    
    pCur = pCurPosition;    
    if (pCur != NULL)    
    {    
        // save a copy of the links     
        pPrev = pCur->pPrev;    
        pNext = pCur->pNext;    
        // Is there a node ahead of us?     
        if (pPrev != NULL)    
        {    
            // yes -> update it to not point to us.     
            pPrev->pNext = pNext;    
        } else {    
            // no -> update head to not point to us.     
            pHead = pNext;    
            pCurPosition = pNext;    
        }    
        // Is there a node behind us?     
        if (pNext != NULL)    
        {    
            // yes -> update it to not point to us.     
            pNext->pPrev = pPrev;    
            pCurPosition = pNext;    
        } else {    
            // no -> update tail to not point to us.     
            pTail = pPrev;    
            pCurPosition = pPrev;    
        }    
        delete(pCur);    
    }    
}      
//  Remove - remove a specified node from the list.     
//  Note: we do not delete the app data attached to the node!     
void CLinkedList::Remove(void  *pData)    
{    
    pCurPosition = Find(pData);    
    Remove();    
}      
//  RemoveFirst - remove the first node in the list and return the app data associated with it.     
void * CLinkedList::RemoveFirst()    
{    
    LPNODE  pCur, pNext;    
    void  *pData = NULL;    
    pCur = pHead;    
    // is there a node at the head?     
    if (pCur != NULL)    
    {    
        // take first node out of list.     
        pNext = pCur->pNext;    
        pHead = pNext;    
        pCurPosition = pNext;    
        // are there any nodes after us?     
        if (pNext != NULL)    
        {    
            // yes -> make it the new head     
            pNext->pPrev = NULL;    
        } else {    
            // no -> the list is now empty     
            pTail = NULL;    
        }    
        // get app data for node and then delete it     
        pData = pCur->pData;    
        delete(pCur);    
    }    
    return(pData);    
}    
//  RemoveLast - remove the last node in the list and return the app data associated with it.     
void * CLinkedList::RemoveLast()    
{    
    LPNODE  pCur, pPrev;    
    void  *pData = NULL;    
    pCur = pTail;    
    // is there a node at the tail?     
    if (pCur != NULL)    
    {    
        // take last node out of list.     
        pPrev = pCur->pPrev;    
        pTail = pPrev;    
        // are there any nodes ahead of us?     
        if (pPrev != NULL)    
        {    
            // yes -> make it the new tail node     
            pPrev->pNext = NULL;    
        } else {    
            // no -> list is now empty     
            pHead = NULL;    
            pCurPosition = NULL;    
        }    
        // get app data for node and then delete it     
        pData = pCur->pData;    
        delete(pCur);    
    }    
    return(pData);    
}

zhongjiekangping
关注
专栏目录
c++实现双向链表
baidu_37964044的博客
10-21 367
如何实现一个双向链表呢，这就要求每个结点里，有两个指针，一个指向前一个结点，一个指向下一个结点。 实现功能包括尾插，尾删，头插，头删，逆序，查找，插入，打印等等 话不多说直接上代码，里面解释的很详细 #include #include using namespace std; typedef int DataType; struct ListNode { ListNode*_next;
c++ 双向链表
qq_42972267的博客
01-20 1101
#include <iostream> 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++）
Lambo19891027的博客
03-26 114
下面是继续写的数据结构中双向链表的类（还有部分有些问题，待将所有的数据结构实现之后统一测试和修改）（记得未测试哦。） //公元2013年3月17日 //Single List--By Paul #ifndef _DoubleList_ #define _DoubleList_ #include<iostream> using namespace std; templa...
双向链表C++实现
weixin_44844149的博客
06-09 344
在设计链表增删操作的方法时，要注意增删位置在链表中的位置，就只有三种情况，head位置，tail位置和中间位置，不同位置对指针的连接方式会有不同，一般都要用if进行判断，这些在代码中已经解释的很详细了。除此之外，在首尾进行操作时，也要对节点数量进行判断，也有三种情况，最简单的情形是空链表，其次是单节点，再就是一般的多节点情形，针对不同的情形用if进行判断，并做好指针维护即可，这些在代码中也有详细的...
C++实现双向链表（含迭代器）
m0_51797936的博客
04-30 1697
C++实现双向链表（含迭代器）1.什么是双向链表2.双向链表的C++代码实现(1)数据节点的代码编写(2)迭代器(3)链表初始化(4)获取节点(5)插入和删除节点（6）链表的交换与合并3.完整代码4.简单的测试代码 1.什么是双向链表 这里既然要实现双向链表，就首先要知道双向链表是什么。 双向链表，实际上就是一种储存数据的容器，是属于链表的其中一种。他的特点是：数据储存在不连续的内存空间中，每个数据节点包含 数据、上一个数据节点的指针和下一个数据节点的指针。 缘于他的这种特点，他可以在 O(1)O(1)O(
c++双向链表操作示例(创建双向链、双向链表中查找数据、插入数据等)
12-25
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表...
支持类模版的C++双向链表
03-07
在这个“支持类模版的C++双向链表”中，我们将探讨如何利用C++的模板特性来实现一个灵活且高效的双向链表，并应用到实际的排序算法中。这个实现适用于VC 6.0和VS2008等编译器。 首先，类模版是C++中的一种泛型编程...
C++双向链表实现简单通讯录
08-19
C++双向链表实现简单通讯录 在本文中，我们将详细介绍C++双向链表实现简单通讯录的实现方法。我们将从头开始，了解C++双向链表的基本概念，然后逐步实现一个简单的通讯录系统。 首先，让我们了解一下C++双向链表...
C++ 双向链表的实现
studyingEverymonent的博客
10-11 301
list.h#ifndef _LIST_H #define _LIST_Htypedef int DataType;class Node { private: DataType data; public: Node *next;//后驱指针 Node *prior;//前驱指针 Node(DataType val); ~Node(); DataType
双向链表实例（VC++）
04-07
双向链表实例（VC++）。
双向链表的C++实现
11-01
基础数据结构双向链表的C++描述版。实现了双向链表的基本功能。包括拷贝构造函数和IO操作符重载、赋值操作符重载
VC++2012编程演练数据结构《15》双向链表
11-20
VC++2012编程演练数据结构《15》双向链表
用VC++实现的单向和双向链表
04-12
用面向对象的C++语言编写的单向和双向链表，可在VC++ 6。0或更高版本平台下运行，是学习数据结构的很好代码。
C++双向链表的实现
cvhbfgh的博客
04-19 337
#include #include using namespace std; typedef int DataType; // 首先要明白一个链表的组成，链表又结点连接起来构成，我们定义出一个结点的结构体，每一个结点都有自己的next域，pre 域，以及自身的数据。 struct Node { Node( const DataType& data = DataType()) :
C++实现双向链表操作
MilkLeong的博客
02-03 1358
双向链表是在单链表的基础上为每个结点添加一个前趋指针域prior，这样形成的链表可有两个不同的方向。 双向链表一般也可由头指针唯一确定，其每一结点均有： 数据域（data) 左链域（prior)：指向前趋结点. 右链域（next)：指向后继 它是一种既有前趋也有后继的对称结构，它的对称性可表述为： p->prior->next=p->next->prior=p 即：结点*p...
c++编程实现一个双向链表
weixin_44378800的博客
08-25 583
c++编程实现一个双向链表
C++语言实现双向链表
BeiXi's Blog
02-03 1101
这篇文章是关于利用C++模板的方式实现的双向链表以及双向链表的基本操作，在之前的博文C语言实现双向链表中，已经给大家分析了双向链表的结构，并以图示的方式给大家解释了双向链表的基本操作。本篇文章利用C++实现了双向链表的基本操作，其中包括： 双向链表的基本操作C++语言实现 头部插入结点建立链表 尾部插入结点建立链表 实现指定位置插入结点 查找给定数值是否存在 删除指定位置的结点 修改指定位置的...
用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++双向链表尾插法
最新发布
05-29
C++双向链表尾插法的代码如下所示： ```c++ #include using namespace std; //定义双向链表结构体 struct ListNode{ int val; ListNode* prev; ListNode* next; ListNode(int x):val(x),prev(NULL),next(NULL)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值