数据结构之双链表

最新推荐文章于 2023-06-29 17:39:02 发布

SF_WJ

最新推荐文章于 2023-06-29 17:39:02 发布

阅读量127

点赞数

分类专栏：数据结构文章标签： c++ c 数据结构双链表

本文链接：https://blog.csdn.net/Wj_12345_/article/details/100903542

版权

数据结构专栏收录该内容

19 篇文章 1 订阅

订阅专栏

单链表中每个结点除了存储自身数据之外,还存储了下一个结点的地址,因此可以轻松访问下一个结点,以及后面的后继结点,但是如果想访问前面的结点就不行了,再也回不去了.例如删除结点p时,要先找到它的前一个结点q然后才能删掉p结点,单向链表只能往后走,不能向前走,如果需要向前,怎么办?

可以在单链表的基础上给每个元素附加两个指针域,一个存储前一个元素的地址,一个存储下一个的地址,这种链表称为双向链表.

其结构体定义:

typedef struct _LinkNode{
    int data;
    struct _LinkNode *next;//下一个结点的指针域
    struct _LinkNode *prev;//上一个结点的指针域
}LinkNode,LinkList         //LinkList为指向结构体LNode的指针类型

双向链表的初始化:

typedef struct _DoubleLinkNode{
    int data;
    struct _DoubleLinkNode *next;//下一个结点的指针域
    struct _DoubleLinkNode *prev;//上一个结点的指针域
}DbLinkNode,DbLinkList;         //LinkList为指向结构体LNode的指针类型
//构造一个空的双向链表L
bool DbInit_List(DbLinkList* &L){
    L=new DbLinkNode;    //生成新结点作为头结点,用有指针L指向头结点
    if(!L)return false;  //生成结点失败
    L->next=NULL;        //头结点的next指针域置空
    L->prev=NULL;        //头结点的prev指针域置空
    L->data=-1;
    return true;
}

双向链表前插法:

bool DbListInsert_front(DbLinkList* &L,DbLinkNode *node){
	if(!L||!node)return false;
	//1.只有头结点
	if(L->next==NULL){
		node->next=NULL;
		node->prev=L;		//新结点prev指针指向头结点
		L->next=node;		//头结点next指针指向新结点
	}else{
		L->next->prev=node; //第二个结点的prev指向新结点
		node->next=L->next; //新结点next指针指向第二个结点
		node->prev=L;		//新结点prev指针指向头结点
		L->next=node;		//头结点next指针指向新结点,完成插入
	}
	return true;
}

双向链表的遍历输出:

void DbLink_Print(DbLinkList* &L){
	DbLinkNode *p=NULL;
	if(!L){
		cout<<"链表为空"<<endl;
		return;
	}
	p=L;
	while(p->next){
		cout<<p->next->data<<"\t";
		p=p->next;
	}
    cout<<endl;
	//逆向打印
	while(p){
		cout<<p->data<<"\t";
		p=p->prev;
	}
	cout<<endl;
}

双向链表尾插法:

bool DbListInsert_back(DbLinkList* &L,DbLinkNode *node){
	if(!L||!node)return false;
	DbLinkNode *last;
	last=L;
	while(last->next){
		last=last->next;
	}
	node->next=NULL;
	node->prev=last;
	last->next=node;
	return true;
}

//双向链表的遍历输出
void DbLink_Print(DbLinkList* &L){
	DbLinkNode *p=NULL;
	if(!L){
		cout<<"链表为空"<<endl;
		return;
	}
	p=L;
	while(p->next){
		cout<<p->next->data<<"\t";
		p=p->next;
	}
	cout<<endl;
	//逆向打印
	while(p){
		cout<<p->data<<"\t";
		p=p->prev;
	}
	cout<<endl;
}

指定位置插入:

bool DbLink_Insert(DbLinkList* &L,int i,int &e){
	if(!L||!L->next)return false;
	if(i<1)return false;
	int j=0;
	DbLinkList *p,*s;
	p=L;
	while(p&&j<i){
		p=p->next;
		j++;
	}
	if(!p||j>i){
		cout<<"不存在结点"<<endl;
		return false;
	}
	cout<<"p:"<<p<<endl;
	s=new DbLinkNode;
	s->data=e;
	s->next=p;
	s->prev=p->prev;
	p->prev->next=s;
	p->prev=s;
	return true;
}

源代码:

#include<iostream>
#include<string>
using namespace std;
typedef struct _DoubleLinkNode{
    int data;
    struct _DoubleLinkNode *next;//下一个结点的指针域
    struct _DoubleLinkNode *prev;//上一个结点的指针域
}DbLinkNode,DbLinkList;       //LinkList为指向结构体LNode的指针类型
//1.构造一个空的双向链表L
bool DbList_Init(DbLinkList* &L){
    L=new DbLinkNode;    //生成新结点作为头结点,用有指针L指向头结点
    if(!L)return false;  //生成结点失败
    L->next=NULL;        //头结点的next指针域置空
    L->prev=NULL;        //头结点的prev指针域置空
    L->data=-1;
    return true;
}
//2.双链表的前插法
bool DbListInsert_front(DbLinkList* &L,DbLinkNode *node){
	if(!L||!node)return false;
	//1.只有头结点
	/*
	if(L->next==NULL){
		node->next=NULL;
		node->prev=L;		//新结点prev指针指向头结点
		L->next=node;		//头结点next指针指向新结点
	}else{
		L->next->prev=node; //第二个结点的prev指向新结点
		node->next=L->next; //新结点next指针指向第二个结点
		node->prev=L;		//新结点prev指针指向头结点
		L->next=node;		//头结点next指针指向新结点,完成插入
	}
	*/
	//简化成下面
	if(L->next)L->next->prev=node;
	node->next=L->next; //新结点next指针指向第二个结点
	node->prev=L;		//新结点prev指针指向头结点
	L->next=node;		//头结点next指针指向新结点,完成插入
	return true;
}
//3.双链表的尾插法
bool DbListInsert_back(DbLinkList* &L,DbLinkNode *node){
	if(!L||!node)return false;
	DbLinkNode *last;
	last=L;
	while(last->next){
		last=last->next;
	}
	node->next=NULL;
	node->prev=last;
	last->next=node;
	return true;
}
//4.双向链表的遍历输出
void DbLink_Print(DbLinkList* &L){
	DbLinkNode *p=NULL;
	if(!L){
		cout<<"链表为空"<<endl;
		return;
	}
	p=L;
	while(p->next){
		cout<<p->next->data<<"\t";
		p=p->next;
	}
	cout<<endl;
	//逆向打印
	while(p){
		cout<<p->data<<"\t";
		p=p->prev;
	}
	cout<<endl;
}
//5.指定位置插入
bool DbLink_Insert(DbLinkList* &L,int i,int &e){
	if(!L||!L->next)return false;
	if(i<1)return false;
	int j=0;
	DbLinkList *p,*s;
	p=L;
	while(p&&j<i){
		p=p->next;
		j++;
	}
	if(!p||j>i){
		cout<<"不存在结点"<<endl;
		return false;
	}
	cout<<"p:"<<p<<endl;
	s=new DbLinkNode;
	s->data=e;
	s->next=p;
	s->prev=p->prev;
	p->prev->next=s;
	p->prev=s;
	return true;
}
//6.任意位置删除
bool DbLink_Delete(DbLinkList* &L,int i){
	DbLinkList *p;
	int index=0;
	if(!L||!L->next){
		cout<<"双向链表为空"<<endl;
		return false;
	}
	if(i<1)return false;
	p=L;
	while(p&&index<i){
		p=p->next;
		index++;
	}
	if(!p||index>i)return false;
	p->next->prev=p->prev;
	p->prev->next=p->next;
	delete p;
	return true;
}
//6.双链表销毁
void DbLink_Destory(DbLinkList* &L){
	DbLinkList *p=L;
	cout<<"销毁链表"<<endl;
	while(p){
		L=L->next;
		cout<<"删除元素"<<p->data<<endl;
		delete p;
		p=L;
	}
}
int main(void){
	DbLinkList *L=NULL;
	DbLinkNode *s=NULL;
	//1.初始化一个空的双向链表
	DbList_Init(L);
	//2.使用前插法插入数据
	int n;
	cout<<"前插法创建单链表"<<endl;
	cout<<"请输入元素个数n:";
	cin>>n;
	cout<<"\n请依次输入n个元素:"<<endl;
	while(n>0){
		s=new DbLinkNode;
		cin>>s->data;
		DbListInsert_front(L,s);
		n--;
	}
	//DbLink_Print(L);
	//3.使用尾插法插入数据
	cout<<"尾插法创建单链表"<<endl;
	cout<<"请输入元素个数n:";
	cin>>n;
	cout<<"\n请依次输入n个元素:"<<endl;
	while(n>0){
		s=new DbLinkNode;
		cin>>s->data;
		DbListInsert_back(L,s);
		n--;
	}
	//4.双链表的输出
	DbLink_Print(L);
	//5.任意位置插入元素
	for(int j=0;j<3;j++){
		int i,x;
		cout<<"请输入插入的位置和元素(用空格隔开)";
		cin>>i>>x;
		if(DbLink_Insert(L,i,x)){
			cout<<"插入成功"<<endl;
		}else{
			cout<<"插入s失败"<<endl;
		}
		DbLink_Print(L);
	}
	//删除
	DbLink_Delete(L,1);
	DbLink_Print(L);
	//销毁
	DbLink_Destory(L);
	system("pause");
	return 0;
}