目录
前言
记录下双向链表的表示和实现。
1.双向链表的定义
单链表中只有一个指示直接后继的指针域,由此,从某个结点出发只能顺指针向后寻查其他结点。若要寻查结点的直接前驱,则必须从表头指针出发。换句话说,在单链表中,查找直接后继结点的执行时间为 0(1),而查找直接前驱的执行时间为 0(n)。为克服单链表这种单向性的缺点,可利用双向链表(Double Linked List )。
双向链表是一种链表数据结构,每个节点都有两个指针,一个指向前一个节点,一个指向后一个节点。
2.双向链表的表示和实现
1.定义
typedef int Status;
typedef int ElemType;
// 定义双向链表
typedef struct DNode {
int data; // 数据域
struct DNode * next; // 直接后继
struct DNode * prior;// 直接前驱
}DoubleNode,*DoubleLinkList;
2.初始化
初始化双向链表,前驱节点和后继节点指针置空。
Status initDoubleLinkList(DoubleLinkList &doubleLinkList){
doubleLinkList = new DNode;
if (!doubleLinkList) {
return 0;
}
doubleLinkList->prior = nullptr;
doubleLinkList->next = nullptr;
return 1;
};
3.销毁
//销毁
void destroyDoubleLinkList(DoubleLinkList &doubleLinkList) {
DoubleNode *current = doubleLinkList;
while (current != nullptr) {
DoubleNode *temp = current;
current = current->next;
delete temp;
}
doubleLinkList = nullptr; // 将头指针置为空指针
}
4.清空
void clearDoubleLinkList(DoubleLinkList & doubleLinkList){
DoubleLinkList p = doubleLinkList;
p->next = nullptr;
p->prior = nullptr;
}
5.表长
int doubleLinkListLength(DoubleLinkList &doubleLinkList){
int length = 0;
DoubleNode *p = doubleLinkList->next;
while (p != nullptr) {
++length;
p = p->next;
}
return length;
}
6.获取数据元素
Status getDoubleLinkListElement(DoubleLinkList &doubleLinkList,int position,int * element){
if (position < 1) {
return 0; // 非法位置
}
DoubleNode *p = doubleLinkList;
int j = 0;
while (p != nullptr && j < position - 1) { // 找到指定位置的节点
p = p->next;
++j;
}
if (p == nullptr || j >= doubleLinkListLength(doubleLinkList)) {
return 0; // 未找到指定位置的节点
}
*element = p->next->data; // 将节点的数据域值赋给 element
return 1;
}
7.前驱节点
// 获取双向链表中的第一个与element相同的元素的直接前驱
Status priorDoubleLinkListElement(DoubleLinkList &doubleLinkList,int element,int * priorElement){
DoubleLinkList p = doubleLinkList->next;
while (p) {
if (p->data == element) {//找到第一个数据元素
if (p->prior && p->prior->prior){
* priorElement = p->prior->data;
return 1;
}
}
p = p->next;
}
return 0;
}
8.后继节点
// 获取双向链表中的第一个与element相同的元素的后继节点
Status nextDoubleLinkListElement(DoubleLinkList &doubleLinkList,int element,int * nextElement){
DoubleLinkList p = doubleLinkList;
while (p) {
if (p->data == element) {//找到第一个数据元素
if (p->next) {
* nextElement = p->next->data;
return 1;
}
}
p = p->next;
}
return 0;
}
9.插入
Status insertDoubleLinkList(DoubleLinkList &doubleLinkList,int i,int element){
if (i < 0) {//插入非法
return 0;
}
DoubleLinkList p = doubleLinkList;
int j = 0;
while (p && j < i-1) {//找到要插入的位置的前置节点
p = p->next;
++j;
}
if (!p) {//插入位置非法
return 0;
}
DoubleNode *newNode = new DoubleNode;
if (!newNode) {//内存分配失败
return 0;
}
newNode->data = element;//新节点
newNode->next = p->next;
if (p->next) {
p->next->prior = newNode;
}
p->next = newNode;
newNode->prior = p;
return 1;
}
10.删除
// 从双向链表中删除指定位置的节点
Status deleteDoubleLinkList(DoubleLinkList &doubleLinkList, int position, ElemType *deletedElement) {
if (position < 1 || position > doubleLinkListLength(doubleLinkList)) {// 删除位置非法
return 0;
}
DoubleLinkList p = doubleLinkList;
int j = 0;
while (p->next != nullptr && j < position - 1) {// 找到要删除结点的前一个结点
p = p->next;
++j;
}
if (j < position - 1 || p->next == nullptr) {
return 0; // 删除位置超出范围
}
*deletedElement = p->next->data; // 将要删除的节点的数据存储到 deletedElement 中
DoubleLinkList q = p->next; // 要删除的结点
p->next = q->next; // 前一个结点指向后一个结点
if (q->next) {
q->next->prior = p; // 后一个结点的前驱指向前一个结点
}
delete q; // 释放删除结点的内存
return 1;
}
11.遍历
释放链表指针,调用free函数。
void traverseDoubleLinkList(DoubleLinkList & doubleLinkList){
DoubleLinkList p = doubleLinkList->next;
while (p != nullptr) {
cout<<p->data<<"\t";
p = p->next;
}
cout<<endl;
}
12.完整代码
链表的前驱节点和后继节点均为空指针。
#include <iostream>
using namespace std;
typedef int Status;
typedef int ElemType;
// 定义双向链表
typedef struct DNode {
int data; // 数据域
struct DNode * next; // 直接后继
struct DNode * prior;// 直接前驱
}DoubleNode,*DoubleLinkList;
Status initDoubleLinkList(DoubleLinkList &doubleLinkList){
doubleLinkList = new DNode;
if (!doubleLinkList) {
return 0;
}
doubleLinkList->prior = nullptr;
doubleLinkList->next = nullptr;
return 1;
};
// 获取双向链表中的第一个与element相同的元素的直接前驱
Status priorDoubleLinkListElement(DoubleLinkList &doubleLinkList,int element,int * priorElement){
DoubleLinkList p = doubleLinkList->next;
while (p) {
if (p->data == element) {//找到第一个数据元素
if (p->prior && p->prior->prior){
* priorElement = p->prior->data;
return 1;
}
}
p = p->next;
}
return 0;
}
// 获取双向链表中的第一个与element相同的元素的后继节点
Status nextDoubleLinkListElement(DoubleLinkList &doubleLinkList,int element,int * nextElement){
DoubleLinkList p = doubleLinkList;
while (p) {
if (p->data == element) {//找到第一个数据元素
if (p->next) {
* nextElement = p->next->data;
return 1;
}
}
p = p->next;
}
return 0;
}
Status insertDoubleLinkList(DoubleLinkList &doubleLinkList,int i,int element){
if (i < 0) {//插入非法
return 0;
}
DoubleLinkList p = doubleLinkList;
int j = 0;
while (p && j < i-1) {//找到要插入的位置的前置节点
p = p->next;
++j;
}
if (!p) {//插入位置非法
return 0;
}
DoubleNode *newNode = new DoubleNode;
if (!newNode) {//内存分配失败
return 0;
}
newNode->data = element;//新节点
newNode->next = p->next;
if (p->next) {
p->next->prior = newNode;
}
p->next = newNode;
newNode->prior = p;
return 1;
}
void clearDoubleLinkList(DoubleLinkList & doubleLinkList){
DoubleLinkList p = doubleLinkList;
p->next = nullptr;
p->prior = nullptr;
}
Status doubleLinkListIsEmpty(DoubleLinkList &doubleLinkList){
DoubleLinkList p = doubleLinkList;
return p->next == nullptr && p->prior == nullptr;
}
int doubleLinkListLength(DoubleLinkList &doubleLinkList){
int length = 0;
DoubleNode *p = doubleLinkList->next;
while (p != nullptr) {
++length;
p = p->next;
}
return length;
}
Status getDoubleLinkListElement(DoubleLinkList &doubleLinkList,int position,int * element){
if (position < 1) {
return 0; // 非法位置
}
DoubleNode *p = doubleLinkList;
int j = 0;
while (p != nullptr && j < position - 1) { // 找到指定位置的节点
p = p->next;
++j;
}
if (p == nullptr || j >= doubleLinkListLength(doubleLinkList)) {
return 0; // 未找到指定位置的节点
}
*element = p->next->data; // 将节点的数据域值赋给 element
return 1;
}
// 创建一组测试的双向链表
void createDoubleLinkList(DoubleLinkList &doubleLinkList, int values[], int size) {
DoubleNode *head = new DoubleNode(); // 创建头节点
head->next = nullptr;
head->prior = nullptr;
DoubleNode *p = head; // 当前节点指针指向头节点
for (int i = 0; i < size; ++i) {
DoubleNode *newNode = new DoubleNode(); // 创建新节点
newNode->data = values[i];
newNode->next = nullptr;
p->next = newNode; // 当前节点的后继指针指向新节点
newNode->prior = p; // 新节点的前驱指针指向当前节点
p = newNode; // 当前节点指针指向新节点
}
doubleLinkList = head; // 将头节点赋给双向链表
}
// 从双向链表中删除指定位置的节点
Status deleteDoubleLinkList(DoubleLinkList &doubleLinkList, int position, ElemType *deletedElement) {
if (position < 1 || position > doubleLinkListLength(doubleLinkList)) {// 删除位置非法
return 0;
}
DoubleLinkList p = doubleLinkList;
int j = 0;
while (p->next != nullptr && j < position - 1) {// 找到要删除结点的前一个结点
p = p->next;
++j;
}
if (j < position - 1 || p->next == nullptr) {
return 0; // 删除位置超出范围
}
*deletedElement = p->next->data; // 将要删除的节点的数据存储到 deletedElement 中
DoubleLinkList q = p->next; // 要删除的结点
p->next = q->next; // 前一个结点指向后一个结点
if (q->next) {
q->next->prior = p; // 后一个结点的前驱指向前一个结点
}
delete q; // 释放删除结点的内存
return 1;
}
void traverseDoubleLinkList(DoubleLinkList & doubleLinkList){
DoubleLinkList p = doubleLinkList->next;
while (p != nullptr) {
cout<<p->data<<"\t";
p = p->next;
}
cout<<endl;
}
//销毁
void destroyDoubleLinkList(DoubleLinkList &doubleLinkList) {
DoubleNode *current = doubleLinkList;
while (current != nullptr) {
DoubleNode *temp = current;
current = current->next;
delete temp;
}
doubleLinkList = nullptr; // 将头指针置为空指针
}
void testDoubleLinkList(void){
DoubleLinkList doubleLinkList;
cout<<"\n**********\t双向链表初始化\t**********"<<endl;
if (initDoubleLinkList(doubleLinkList)) {
cout<<"顺序表初始化成功"<<endl;
}
cout<<"\n**********\t双向链表判空和长度计算\t**********"<<endl;
if (doubleLinkListIsEmpty(doubleLinkList)) {
cout<<"双向链表为空,长度为"<<doubleLinkListLength(doubleLinkList)<<endl;
}
cout<<"\n**********\t双向链表插入测试\t**********"<<endl;
for (int i = 1; i <=11 ; i++) {
if (insertDoubleLinkList(doubleLinkList,i, i)) {
cout<<"数据元素"<<i<<"插入成功"<<endl;
}else{
cout<<"数据元素"<<i<<"插入失败"<<endl;
}
}
cout<<"\n**********\t双向链表根据下标获取数据元素测试\t**********"<<endl;
for (int i = 0; i <= 12 ; i++) {
int element;
if (getDoubleLinkListElement(doubleLinkList,i, &element)) {
cout<<"第"<<i<<"个数据元素为"<<element<<endl;
}else{
cout<<"第"<<i<<"个数据元素不存在"<<endl;
}
}
cout<<"插入之后的双向链表"<<endl;
traverseDoubleLinkList(doubleLinkList);
cout<<"\n**********\t双向链表删除测试\t**********"<<endl;
ElemType element;
if (deleteDoubleLinkList(doubleLinkList, 11, &element)){
cout<<"数据元素"<<element<<"删除成功"<<endl;
}
cout<<"删除之后的双向链表"<<endl;
traverseDoubleLinkList(doubleLinkList);
cout<<"\n**********\t双向链表后继节点测试\t**********"<<endl;
int nextArr[3] = {1,8,11};
for (int i = 0; i < 3; i++) {
ElemType nextElement;
if (nextDoubleLinkListElement(doubleLinkList, nextArr[i], &nextElement)) {
cout<<"数据元素"<<nextArr[i]<<"后继节点为:"<<nextElement<<endl;
}else{
cout<<"数据元素"<<nextArr[i]<<"后继节点不存在"<<endl;
}
}
cout<<"\n**********\t双向链表前驱节点测试\t**********"<<endl;
int priorArr[3] = {8,11,1};
for (int i = 0; i < 3; i++) {
ElemType priorElement;
if (priorDoubleLinkListElement(doubleLinkList, priorArr[i], &priorElement)) {
cout<<"数据元素"<<priorArr[i]<<"前驱节点为"<<priorElement<<endl;
}else{
cout<<"数据元素"<<priorArr[i]<<"前驱节点不存在"<<endl;
}
}
cout<<"\n**********\t双向链表销毁\t**********"<<endl;
destroyDoubleLinkList(doubleLinkList);
cout<<"顺序表销毁"<<endl;
}
int main() {
testDoubleLinkList();
return 0;
}