C++双向链表

最新推荐文章于 2024-06-15 09:00:00 发布
最新推荐文章于 2024-06-15 09:00:00 发布
阅读量688 收藏 2
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/king13059595870/article/details/103321847
版权

C++双向链表

双向链表顾名思义就是每个结点具有两个指针，一个指向前一个结点，一个指向后一个结点，我们不必拘束与单链表的创建遍历操作等，这样大大减少了使用中存在的效率问题。

在单链表中，我们有一个数据域还有一个指针域，数据域用来存储相关数据，而指针域负责链表之间的“联系”，双向链表具有两个指针域，一个负责向后连接，一个负责向前连接。

//单链表结构
template<class T>
struct List{
    T data;
    struct List* next;
};
//双向链表结构
template<class T>
struct DNode{
	public:
		T value;
		DNode *prev;
		DNode *next;
};

同单链表一样，对双向链表的操作也有创建，插入，遍历，删除，销毁。

双向链表的创建

struct DNode{
	public:
		T value;
		DNode *prev;
		DNode *next;
	public:
		DNode(){
		}
		DNode(T t,DNode *prev,DNode *next){
			this->value=t;
			this->prev=prev;
			this->next=next;
		}
};

在创建双向链表的时候，我们需要初始化的有两个指针。同单链表一样，我们需要一个头指针来标志链表的信息。因此我们可以写出该函数的定义：运用构造函数创建双向链表

双向链表具体操作：

template<class T>
class DoubleCircleList{
	public:
		DoubleCircleList();  //构造函数 创建链表 
		~DoubleCircleList();  //析构函数 销毁链表 	
		int size();	//长度 
		int is_empty();//判断是否为空 
		T get(int index); //返回index值的位置 
		T get_first();//返回第一个位置 
		T get_last();//返回最后一个位置 
		int insert(int index,T t);//在index位置后插入数值 
		int insert_first(T t);//在头插入 
		int append_last(T t);//在尾插入 
		int Delete(int index);//删除index值 
		int Delete_first();//删除头结点 
		int Delete_last();//删除尾结点 
	private:
		int count;
		DNode<T>* phead;
		DNode<T>* get_node(int index);
};

1.计算链表的长度

template<class T>
DoubleCircleList<T>::DoubleCircleList():count(0){
	//创建“表头 ，注意：表头没有存储数据！ 
	phead=new DNode<T>();
	phead->prev=phead->next=phead;
	//设置链表计数为0
	//cout=0; 
}

2.销毁链表

//析构函数   销毁链表
template<class T>
DoubleCircleList<T>::~DoubleCircleList(){
	DNode<T>* ptmp;   
	DNode<T>* pnode=phead->next;	
	while(pnode!=phead){	//一直循环往后找 
		ptmp=pnode;	//
		pnode=pnode->next;
		delete ptmp;
	}
	delete phead;
	phead=NULL;
}

3.计算结点的数目

//返回结点数目
template<class T>
int DoubleCircleList<T>::size(){
	return count;
}

4.判断链表是否为空

template<class T>
int DoubleCircleList<T>::is_empty(){
	return count==0;
}

5.寻找结点位置

template<class T>
DNode<T>* DoubleCircleList<T>::get_node(int index){
	//判断参数有效性
	if(index<0||index>=count){
		cout<<"get node failed! the index in out of bound!"<<endl;
		return NULL;
	} 
	//正向查找 
	if(index<=count/2){
		int i=0;
		DNode<T>* pindex=phead->next;
		while(i++<index){
			pindex=pindex->next;
		}
		return pindex;
	}
	//反向查找
	 int j=0;
	 int rindex=count-index-1;
	 DNode<T>* prindex=phead->prev;
	 while(j++<rindex){
	 	prindex=prindex->prev;
	 }
	 return prindex;
}

6.返回结点位置的值

template<class T>
T DoubleCircleList<T>::get(int index){
	return get_node(index)->value;
}

7.获取第一个结点的值

template<class T>
T DoubleCircleList<T>::get_first(){
	return get_node(0)->value;
}

8.获取最后一个结点的值

template<class T>
T DoubleCircleList<T>::get_last(){
	return get_node(count-1)->value;
}

9.将结点插入index之后

template<class T>
int DoubleCircleList<T>::insert(int index,T t){
	if(index==0)
		return insert_first(t);
	DNode<T>* pindex=get_node(index);
	DNode<T>* pnode=new DNode<T>(t,pindex->prev,pindex);
	pindex->prev->next=pnode;
	pindex->prev=pnode;
	count++;
	return 0;

}

10.结点插入到第一个位置

//将结点插入到第一个结点处
template<class T>
int DoubleCircleList<T>::insert_first(T t){
	DNode<T>* pnode=new DNode<T>(t,phead,phead->next);
	phead->next->prev=pnode;
	phead->next=pnode;
	count++;
	return 0;
}

11.结点插入到最后一个位置

template<class T>
int DoubleCircleList<T>::append_last(T t){
	DNode<T>* pnode=new DNode<T>(t,phead->prev,phead);
	phead->prev->next=pnode;
	phead->prev=pnode;
	count++;
	return 0;
}

12.删除index结点.

template<class T>
int DoubleCircleList<T>::Delete(int index){
	DNode<T>* pindex=get_node(index);
	pindex->next->prev=pindex->prev;
	pindex->prev->next=pindex->next;
	delete pindex;
	count--;
	return 0;
}

13.删除第一个结点

template<class T>
int DoubleCircleList<T>::Delete_first(){
	return Delete(0);
}

14.删除最后一个结点

template<class T>
int DoubleCircleList<T>::Delete_last(){
	return Delete(count-1);
}

完整代码：

//DoubleCircleList.h
#include<iostream>
using namespace std;
template<class T>
struct DNode{
	public:
		T value;
		DNode *prev;
		DNode *next;
	public:
		DNode(){
		}
		DNode(T t,DNode *prev,DNode *next){
			this->value=t;
			this->prev=prev;
			this->next=next;
		}
};
template<class T>
class DoubleCircleList{
	public:
		DoubleCircleList();  //构造函数 创建链表 
		~DoubleCircleList();  //析构函数 销毁链表 	
		int size();	//长度 
		int is_empty();//判断是否为空 
		T get(int index); //返回index值的位置 
		T get_first();//返回第一个位置 
		T get_last();//返回最后一个位置 
		int insert(int index,T t);//在index位置后插入数值 
		int insert_first(T t);//在头插入 
		int append_last(T t);//在尾插入 
		int Delete(int index);//删除index值 
		int Delete_first();//删除头结点 
		int Delete_last();//删除尾结点 
	private:
		int count;
		DNode<T>* phead;
		DNode<T>* get_node(int index);
};
template<class T>
DoubleCircleList<T>::DoubleCircleList():count(0){
	//创建“表头 ，注意：表头没有存储数据！ 
	phead=new DNode<T>();
	phead->prev=phead->next=phead;
	//设置链表计数为0
	//cout=0; 
}
//析构函数 
template<class T>
DoubleCircleList<T>::~DoubleCircleList(){
	DNode<T>* ptmp;   
	DNode<T>* pnode=phead->next;	
	while(pnode!=phead){	//一直循环往后找 
		ptmp=pnode;	//
		pnode=pnode->next;
		delete ptmp;
	}
	delete phead;
	phead=NULL;
}
//返回结点数目
template<class T>
int DoubleCircleList<T>::size(){
	return count;
}
template<class T>
int DoubleCircleList<T>::is_empty(){
	return count==0;
} 
template<class T>
DNode<T>* DoubleCircleList<T>::get_node(int index){
	//判断参数有效性
	if(index<0||index>=count){
		cout<<"get node failed! the index in out of bound!"<<endl;
		return NULL;
	} 
	//正向查找 
	if(index<=count/2){
		int i=0;
		DNode<T>* pindex=phead->next;
		while(i++<index){
			pindex=pindex->next;
		}
		return pindex;
	}
	//反向查找
	 int j=0;
	 int rindex=count-index-1;
	 DNode<T>* prindex=phead->prev;
	 while(j++<rindex){
	 	prindex=prindex->prev;
	 }
	 return prindex;
}
template<class T>
T DoubleCircleList<T>::get(int index){
	return get_node(index)->value;
}
//获取第1个结点值
template<class T>
T DoubleCircleList<T>::get_first(){
	return get_node(0)->value;
} 
//获取最后一个结点值
template<class T>
T DoubleCircleList<T>::get_last(){
	return get_node(count-1)->value;
} 
//将结点插入到index位置之前
template<class T>
int DoubleCircleList<T>::insert(int index,T t){
	if(index==0)
		return insert_first(t);
	DNode<T>* pindex=get_node(index);
	DNode<T>* pnode=new DNode<T>(t,pindex->prev,pindex);
	pindex->prev->next=pnode;
	pindex->prev=pnode;
	count++;
	return 0;

}
//将结点插入到第一个结点处
template<class T>
int DoubleCircleList<T>::insert_first(T t){
	DNode<T>* pnode=new DNode<T>(t,phead,phead->next);
	phead->next->prev=pnode;
	phead->next=pnode;
	count++;
	return 0;
} 
//结点追加到链表末尾
template<class T>
int DoubleCircleList<T>::append_last(T t){
	DNode<T>* pnode=new DNode<T>(t,phead->prev,phead);
	phead->prev->next=pnode;
	phead->prev=pnode;
	count++;
	return 0;
} 
//删除index位置结点
template<class T>
int DoubleCircleList<T>::Delete(int index){
	DNode<T>* pindex=get_node(index);
	pindex->next->prev=pindex->prev;
	pindex->prev->next=pindex->next;
	delete pindex;
	count--;
	return 0;
}
//删除第一个结点
template<class T>
int DoubleCircleList<T>::Delete_first(){
	return Delete(0);
} 
//删除最后一个结点
template<class T>
int DoubleCircleList<T>::Delete_last(){
	return Delete(count-1);
} 

//DoubleCircleList.cpp
#include <iostream>
#include "DoubleCircleList.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
using namespace std;
void int_test()
{
	int iarr[4] = {10, 20, 30, 40};//定义一个数组
 
	cout << "\n开始测试 int数据" << endl;
	// 创建双向链表
	DoubleCircleList<int>* pdlink = new DoubleCircleList<int>();
 
	pdlink->insert(0, 20);        // 将 20 插入到第一个位置
	pdlink->append_last(10);    // 将 10 追加到链表末尾
	pdlink->insert_first(30);    // 将 30 插入到第一个位置
 
	// 双向链表是否为空
	cout << "is_empty()=" << pdlink->is_empty() <<endl;
	// 双向链表的大小
	cout << "size()=" << pdlink->size() <<endl;
 
	// 打印双向链表中的全部数据
	int sz = pdlink->size();
	for (int i=0; i<sz; i++)
		cout << "pdlink("<<i<<")=" << pdlink->get(i) <<endl;
}

int main(int argc, char** argv) {
	int_test();
	return 0;
}

双向循环链表：

#include<stdio.h>  
#include<stdlib.h>  
#include<malloc.h>  
typedef struct DOUBLE_LIST  
{  
    int data;  
    struct DOUBLE_LIST *prev;  
    struct DOUBLE_LIST *next;  
}double_list;  
double_list *createlist()       //创建有n个元素的双向链表 并输入元素  
{  
    double_list *head, *p, *q;  
    int n,x;  
    head = (double_list *)malloc(sizeof(double_list));  
    head->prev = head;  
    head->next = head;  
    p = head;  
    printf("输入要创建双向链表的元素的个数：\n");  
    scanf("%d",&n);  
    for(int i=0;i<n;i++)  
    {  
        scanf("%d", &x);  
        q = (double_list *)malloc(sizeof(double_list));  
        q->data = x;  
        p->next = q;  
        head->prev = q;  
        q->prev = p;  
        q->next = head;  
        p = q;  
    }  
    return head;  
}  
//遍历并且输出这些元素  
void printlist(double_list *head)  
{  
    double_list *p;  
    p = head;  
    p = p->next;  
    while(p!=head)  
    {  
        printf("%d  ", p->data);  
        p = p->next;  
    }  
    printf("\n");  
}  
//得到现在双向链表中的元素的个数  
int lengthlist(double_list *head)  
{  
    double_list *p;  
    p = head;  
    p = p->next;  
    int coun = 0;  
    while(p!=head)  
    {  
        coun++;  
        p = p->next;  
    }  
    return coun;  
}  
//在第i个元素之前插入数据data  
void insertlist_f(double_list *head, int i, int data)  
{  
    double_list *p = head, *q;  
    p = p->next;  
    i--;  
    while(i--)  
        p = p->next;  
    q = (double_list *)malloc(sizeof(double_list));  
    q->data = data;  
    (p->prev)->next = q;  
    q->prev = p->prev;  
    q->next = p;  
    p->prev = q;  
}  
//删除第i个位置的元素  
void deletelist_i(double_list *head, int i)  
{  
    double_list *p = head;  
    p = p->next;  
    i--;  
    while(i--)  
        p = p->next;  
    (p->prev)->next = p->next;  
    (p->next)->prev = p->prev;  
    free(p);  
}  
//删除值为x的元素  
void deletelist_x(double_list *head, int x)  
{  
    double_list *p = head, *q;  
    p = p->next;  
    while(p!=head)  
        if(p->data == x)  
        {  
            q = p->next;  
            (p->prev)->next = p->next;  
            (p->next)->prev = p->prev;  
            free(p);  
            p = q;  
        }  
        else  
            p = p->next;  
}  
//对双向链表进行排序  
void sortlist(double_list *head)  //升序  
{  
    double_list *p = head, *q, *t;  
    p = p->next;  
    for(;p!=head;p=p->next)  
        for(t = p->next;t!=head;t=t->next)  
        {  
            if(p->data > t->data)  
            {  
                int a = p->data;  
                p->data = t->data;  
                t->data = a;  
            }  
        }  
}  
int main()  
{  
    double_list *head;  
    head = createlist();  
    deletelist_x(head, 2);  
    //sortlist(head);  
    printlist(head);  
    insertlist_f(head, 2, 2);  
    printlist(head);  
  
    return 0;  
}

双向链表的遍历来说我只给出了前序遍历的代码，没有写后序遍历的代码，这其实是差不多的，但是因为双向链表可以进行两个方向的遍历，这给我们带来了很大的方便。

King逍灬遥
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向链表的C++实现
11-01
基础数据结构双向链表的C++描述版。实现了双向链表的基本功能。包括拷贝构造函数和IO操作符重载、赋值操作符重载
数据结构-双向链表(c++)超全超详细
热门推荐
Abieai的博客
12-01 1万+
文章目录前言一、双向链表是什么？二、双向链表上的基本操作1.定义双向链表2.初始化双链表3.前插法创建双链表4.尾插法创建双链表5.双向链表的遍历输出6.双链表的指定位置插入7.双链表的按位取值8.双链表的任意位置删除9.双链表的销毁三、全部代码(主函数部分比较凌乱）总结 前言 单链表结点中只有一个指向其后继的指针，使得单链表只能从头结点依次顺序地向后遍历。要访问某个结点的前驱结点（插入，删除操作时），只能从头开始遍历，访问后继结点的时间复杂度为O(1)，访问前驱结点的时间复杂度为O(n)。 提示：以.
双向链表详解及C++实现
最新发布
Weirdo的博客
06-15 416
本文详细介绍了双向链表的基本结构、操作实现以及C++代码示例。双向链表通过引入两个指针（prev和next）来实现对前后节点的访问，从而在插入、删除和遍历等操作上提供了更高的灵活性。在实际应用中，双向链表常用于需要频繁进行节点插入和删除的场景，如LRU（最近最少使用）缓存淘汰算法等。通过掌握双向链表的基本原理和实现方法，读者可以更好地理解和应用这种数据结构。
C++ 数据结构之-双向链表(link_list)
who_I_am__的博客
09-28 1050
双向链表（Doubly Linked List）是一种常见的数据结构，它与单向链表相似，但每个节点有两个指针，一个指向前一个节点（前驱节点），一个指向后一个节点（后继节点）。前向和后向遍历：由于每个节点都有前驱和后继指针，双向链表可以从头节点或尾节点开始，沿着不同的方向遍历整个链表。维护复杂性：因为每个节点有两个指针，所以在插入、删除或修改节点时，需要同时更新相关节点的前驱和后继指针，这增加了链表的维护复杂性。4、bool contains(T t) const // 判断元素t是否在list中。
C++实现双向链表（含迭代器）
m0_51797936的博客
04-30 1624
C++实现双向链表（含迭代器）1.什么是双向链表2.双向链表的C++代码实现(1)数据节点的代码编写(2)迭代器(3)链表初始化(4)获取节点(5)插入和删除节点（6）链表的交换与合并3.完整代码4.简单的测试代码 1.什么是双向链表 这里既然要实现双向链表，就首先要知道双向链表是什么。 双向链表，实际上就是一种储存数据的容器，是属于链表的其中一种。他的特点是：数据储存在不连续的内存空间中，每个数据节点包含 数据、上一个数据节点的指针和下一个数据节点的指针。 缘于他的这种特点，他可以在 O(1)O(1)O(
使用C++实现双链表
qq_58240448的博客
07-01 3093
c++实现的双链表
C++双向链表实现简单通讯录
08-19
C++双向链表实现简单通讯录 在本文中，我们将详细介绍C++双向链表实现简单通讯录的实现方法。我们将从头开始，了解C++双向链表的基本概念，然后逐步实现一个简单的通讯录系统。 首先，让我们了解一下C++双向链表...
c++双向链表操作示例(创建双向链、双向链表中查找数据、插入数据等)
09-04
在C++编程中，双向链表是一种非常重要的数据结构，它允许我们从两个方向遍历元素，即向前和向后。下面将详细讲解如何在C++中操作双向链表，包括创建、查找、插入和删除节点。 首先，我们需要定义双向链表的节点结构...
C++实现双向链表
12-17
在C++编程中，双向链表是一种特殊类型的链表，其中每个节点不仅包含数据，还包含两个指针，分别指向其前一个节点和后一个节点。这种数据结构提供了向前和向后遍历列表的能力，而不仅仅是单向。下面将详细讨论如何在...
C++双向链表程序
09-02
C语言链表程序，内含链表的创建、插入、查找、遍历、删除和释放。 C语言链表程序，内含链表的创建、插入、查找、遍历、删除和释放。
c++双向链表
05-25
c++课程设计的一个小题目，双向链表，该代码存储的node为姓名，电话，年龄。可根据需要进行修改。
C++数据结构--双向链表
海到无边天作岸 山登绝顶我为峰
04-07 2202
测试代码 #include <iostream> #include <iomanip> using namespace std; template <class DataType> struct DulNode { DataType data; DulNode <DataType>*prior,*next; }; template <cla...
C++数据结构之双链表详解
suren_jun的博客
09-16 1183
这里头节点是不存储数据的，且单向链表的操作，双向链表都可以做到，这里讲一下双向链表的特点。如果想看一些基础的增删改查工作，直接查看单链表即可。
双向链表C++
alanmian的博客
11-06 3388
双向链表，顾名思义，一条可双向进行的就叫双向链表。那怎么搞？也就是有前驱跟后继，有些时候有人不明白什么是前驱跟后继啊，浅显的讲讲，前驱就是当前结点指向上一个结点的箭头，那么上一个结点就是当前结点的前驱，后继就是当前结点的前一个结点，从上一个结点指向当前结点就叫后继，也就是说上个结点作为头，那当前结点作为尾，头的后继不就是尾嘛。 然后有头尾指针，双向嘛。头指针运动，尾指针也运动，所以这里要多存个尾指针。那说了这么多，先来构造给双向链表吧。 定义结构体老掉牙的东西了 思路！： 1.刚前面说了有前驱跟后继，那么
C++容器——双向链表（list）
shouhu010的博客
03-15 1003
是一个容器，其结构为双向链表，支持从任何位置插入和删除元素，但不支持快速的随机访问，空间效率较低；与forward_list相比，该容器提供了双向迭代功能；
双向循环链表（C++实现）
st66688的博客
09-22 2794
双向循环链表内容整理
c++ 双向链表
qq_42972267的博客
01-20 1041
#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/c++)
qq_52095705的博客
11-16 2187
前言 数据结构还是得来一手。 一.关于链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。链表通过指针域能把多个元素串联起来。 一般的链表中每个元素只有一个指向下一个元素的指针域，而我们的双向链表却有两个指针域，其中一个指针域指向下一个元素，另一个指针域指向这个元素的上一个元素。 接下来看程序
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、付费专栏及课程。

余额充值