实例讲解C++ 双链表基本操作

1.概念

　　双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

结构图如下所示:

　　

　　

2.基本操作实例

DoubleList.cpp

#include "stdafx.h"
#include "DoubleList.h"
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
DoubleList::DoubleList()
{
        pDoubleListNode pDouList = NULL;
        // 创建双链表
        CreateDouList(pDouList);
        PrintDouList(pDouList);
        // 打印逆序链表
        PrintDouReverseList(pDouList);
        // 节点后插入节点
        InsertNodeAfter(pDouList);
        PrintDouList(pDouList);
        // 节点前插入节点
        InsertNodeBefore(pDouList);
        PrintDouList(pDouList);
        // 删除节点
        DeleteNode(pDouList);
        PrintDouList(pDouList);
        // 删除链表
        DeleteDouList(pDouList);
        PrintDouList(pDouList);
        system("PAUSE");
}
DoubleList::~DoubleList()
{
}
//创建双向链表
void DoubleList::CreateDouList(pDoubleListNode &head)
{
    char x;          // 定义成char型是用于输入‘q‘时可以退出，其实定义成int也能退出
    pDoubleListNode p, s;
    head = (pDoubleListNode)malloc(sizeof(DoubleListNode));
    head->next = NULL;
    head->prior = NULL;        // 构造头结点p
    p = head;
    printf("\n输入双向链表的元素，每输入一个元素后按回车，输入q表示结束.\n");
    fflush(stdin);   //清空输入缓冲区
    x = getchar();
    while (x != ‘q‘)
    {
        s = (pDoubleListNode)malloc(sizeof(DoubleListNode));
        s->data = x - ‘0‘;  // 得到的是输入字符的ASCII码，减去30H就变成想要的数字
        s->next = NULL;
        s->prior = p;
        p->next = s;
        p = s;
        fflush(stdin);
        x = getchar();
    }
    if (x == ‘q‘)
    {
        printf("双向链表构造完毕!\n");
    }
}
//打印双向链表
void DoubleList::PrintDouList(pDoubleListNode &head)
{
    pDoubleListNode p;
    printf("\n打印出双向链表数据为：\n");
    if (!IsDouListEmpty(head))
    {
        p = head->next;
        while (p)
        {
            printf("%d\n", p->data);
            p = p->next;
        }
    }
}
//逆序打印双向链表
void DoubleList::PrintDouReverseList(pDoubleListNode &head)
{
    pDoubleListNode p;
    printf("\n打印出逆序双向链表数据为：\n");
    if (!IsDouListEmpty(head))
    {
        p = head->next;
        while (p->next)
        {
            p = p->next;
        }
        while (p->prior)
        {
            printf("%d \n", p->data);
            p = p->prior;
        }
    }
}
//求链表长度
int DoubleList::GetDouListLength(pDoubleListNode &head)
{
    int length = 0;
    if (head == NULL)
    {
        printf("链表不存在，请先初始化!\n");
    }
    else
    {
        pDoubleListNode p = head->next;
        while (p)
        {
            length++;
            p = p->next;
        }
    }
    return length;
}
//判断链表是否为空
bool DoubleList::IsDouListEmpty(pDoubleListNode &head)
{
    if (head == NULL)
    {
        printf("链表不存在，请先初始化!\n");
        return true;
    }
    else if (head->next == NULL)
    {
        printf("链表为空!\n");
        return true;
    }

    return false;
}
//把双向链表置空
void DoubleList::ClearDouList(pDoubleListNode &head)
{
    if (head == NULL)
    {
        printf("链表不存在，请先初始化!\n");
    }
    else
    {
        pDoubleListNode p, q;
        p = q = head->next;   //是p、q指向第一个元素
        head->next = NULL;
        while (p)          //逐个释放元素所占内存
        {
            p = p->next;
            free(q);
            q = p;
        }
    }
}
// 删除双向链表
void DoubleList::DeleteDouList(pDoubleListNode &head)
{
    printf("\n删除双向链表\n");
    ClearDouList(head);
    free(head);
    head = NULL;
}
// 在双向链表中第i个位置后面插入元素
void DoubleList::InsertNodeAfter(pDoubleListNode &head)
{
    int  data, pos;
    pDoubleListNode p, s;
    p = head;
    int i = 0;
    printf("\n在双向链表中第i个位置后面插入元素\n");
    printf("请输入要插入的元素和位置:\n");
    scanf_s("%d%d", &data, &pos, 100);
    if (head == NULL)
    {
        printf("链表不存在，请先初始化!\n");
    }
    else if (head->next == NULL)
    {
        printf("链表为空，插入第一个元素!\n");
        s = (pDoubleListNode)malloc(sizeof(DoubleListNode));
        s->data = data;
        s->prior = NULL;
        s->next = NULL;
        head->next = s;        // 将新结点插入head后
    }
    else if (pos<1 || pos>GetDouListLength(head) + 1)
    {
        printf("插入位置错误!\n");
    }
    else
    {
        while (i < pos)
        {
            p = p->next;
            i++;
        }
        if (i == GetDouListLength(head))      //如果在最后一个元素后面插入data
        {
            s = (pDoubleListNode)malloc(sizeof(DoubleListNode));
            s->data = data;
            s->next = NULL;
            s->prior = p;
            p->next = s;
        }
        else
        {
            s = (pDoubleListNode)malloc(sizeof(DoubleListNode));
            s->data = data;
            s->next = p->next;
            p->next->prior = s;
            p->next = s;
            s->prior = p;
        }
    }
}
// 在双向链表中第i个位置前面插入元素
void DoubleList::InsertNodeBefore(pDoubleListNode &head)
{
    int  data, pos;
    pDoubleListNode p, s;
    p = head;
    int i = 0;
    printf("\n在双向链表中第i个位置前面插入元素\n");
    printf("请输入要插入的元素和位置:\n");
    scanf_s("%d%d", &data, &pos, 100);
    if (head == NULL)
    {
        printf("链表不存在，请先初始化!\n");
    }
    else if (head->next == NULL)
    {
        printf("链表为空，插入第一个元素!\n");
        s = (pDoubleListNode)malloc(sizeof(DoubleListNode));
        s->data = data;
        s->prior = NULL;
        s->next = NULL;
        head->next = s;        // 将新结点插入head后
    }
    else if (pos<1 || pos>GetDouListLength(head) + 1)
    {
        printf("插入位置错误!\n");
    }
    else
    {
        while (i < pos)
        {
            p = p->next;
            i++;
        }
        if (i == 1)      // 如果在第一个元素前面插入data
        {
            s = (pDoubleListNode)malloc(sizeof(DoubleListNode));
            s->data = data;
            head->next = s;        // 将新结点插入head后
            s->prior = head;        // 新结点的前结点指向头结点
            s->next = p;                        // 新结点的后结点指向原head的后结点
            p->prior = s  ;                    // 原第一个结点的前结点指向新结点
        }
        else
        {
            s = (pDoubleListNode)malloc(sizeof(DoubleListNode));
            s->data = data;
            s->prior = p->prior;
            s->next = p;
            p->prior->next = s;
            p->prior = s;
        }
    }
}
//删除双向链表中的第i个元素
void DoubleList::DeleteNode(pDoubleListNode &head)
{
    int pos;
    int i = 0;
    pDoubleListNode p = head;
    printf("\n在双向链表中删除第i个位置的元素\n");
    printf("请输入要删除的位置:");
    scanf_s("%d", &pos, 100);

    if (IsDouListEmpty(head))
    {
        return;
    }
    else if (pos<1 || pos>GetDouListLength(head))
    {
        printf("删除的位置不存在!\n");
    }
    else
    {
        while (i < pos)
        {
            p = p->next;
            i++;
        }
        if (i == GetDouListLength(head))
        {
            p->prior->next = NULL;
            free(p);
        }
        else
        {
            p->prior->next = p->next;
            p->next->prior = p->prior;
            free(p);
        }
    }
}

DoubleList.h

#pragma once
typedef struct DoubleListNode
{
    int data;              //数据
    struct DoubleListNode *prior; //前驱
    struct DoubleListNode *next;  //后继
}DoubleListNode, *pDoubleListNode;
class DoubleList
{
public:
    DoubleList();
    ~DoubleList();
    //初始化双向链表
    void DoubleList::CreateDouList(pDoubleListNode &head);
    //打印双向链表
    void DoubleList::PrintDouList(pDoubleListNode &head);
    //逆序打印双向链表
    void DoubleList::PrintDouReverseList(pDoubleListNode &head);
    //求链表长度
    int DoubleList::GetDouListLength(pDoubleListNode &head);
    //判断链表是否为空
    bool DoubleList::IsDouListEmpty(pDoubleListNode &head);
    //把双向链表置空
    void DoubleList::ClearDouList(pDoubleListNode &head);
    //删除双向链表
    void DoubleList::DeleteDouList(pDoubleListNode &head);
    //在双向链表中第i个位置后面插入元素m
    void DoubleList::InsertNodeAfter(pDoubleListNode &head);
    // 在双向链表中第i个位置前面插入元素
    void DoubleList::InsertNodeBefore(pDoubleListNode &head);
    //删除双向链表中的第i个元素
    void DoubleList::DeleteNode(pDoubleListNode &head);
};

3.对链表插入节点的理解

　　例如在节点i前插入一个新的节点(即上面代码中的InsertNodeBefore函数):

链表结构体为：

typedef struct DoubleListNode

{

int data;              // 数据

struct DoubleListNode *prior; // 前驱

struct DoubleListNode *next;  // 后继

}DoubleListNode, *pDoubleListNode;

假设该链表由五个节点构成,分别为A,B,C,D,E

　　

图中假设了A,B,C,D,E的地址分别为:addressA,addressB,addressC,addressD,addressE。

下面将分析链表的前插的例子:

双链表的前插，下面这是在节点"D"前插入一个新的节点"S"的代码和分析

s = (pDoubleListNode)malloc(sizeof(DoubleListNode));　　//
申请一段内存空间，指针指向首地址为addressS

s->data = data;　　　　 // 给节点S的数据赋值data

s->prior = p->prior;　　// p指向D节点, p->prior表示addressC，将它赋给s->prior,则s->prior里面的值是addressC，从而指向addressC这个地址即节点C，如下图S节点的蓝线

s->next = p;　　　　　  // p是addressD，将它赋给s->next，s->next中的值为addressD，也即s->next指向了D，如下图S节点的红线

p->prior->next = s;　　// p->prior 是addressC，即节点C，所以p->prior->next相当于没插入S之前的addressD，插入S后，将S的首地址即addressS赋给这个位置，所以此时，由C 到D的红线断裂，这个红线目标变成了S，如下图C节点的红线

p->prior = s;　　　　　// 同理，p->prior也指向了S，即p->prior中addressC变成了addressS,
D指向C的蓝线断裂。变成如下图D节点指向S节点的蓝线.

时间： 2024-10-26 05:55:28

实例讲解C++ 双链表基本操作的相关文章

数据结构学习之双链表基本操作

数据结构学习之双链表基本操作 0x1 前言 今天实验课,学习了下双链表的写法,这里记录下. 0x2 正文 题目要求如下: 本实验的双链链表元素的类型为char,完成如下实验要求: (1)初始化单链表h (2)采用尾插法依次插入a.b.c.d.e (3)输出单链表h (4)输出单链表h的长度 (5)判断单链表h是否为空 (6)输出单链表h的第3个元素 (7)输出元素a的逻辑位置 (8)在第4个元素位置上插入元素f (9)输出单链表h (10)删除单链表h的第3个元素 (11)输出单链表h (12)

C++ 双链表基本操作

上一篇博客主要总结了单向链表,这次再总结一下双向链表. 1.概念 双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱.所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点.一般我们都构造双向循环链表. 结构图如下所示: 2.基本操作实例 DoubleList.cpp #include "stdafx.h" #include "DoubleList.h" #include <stdio.h>

双链表基本操作

#include <stdlib.h> #include <iostream> using namespace std; #define null 0 #define MAXSIZE 50 struct strlnode { int data; struct strlnode *plast; struct strlnode *pnext; }; void create(struct strlnode **p, int x) /*创建双链表(表头节点)*/ { struct strl

日常学习随笔-数组、单链表、双链表三种形式实现栈结构的基本操作

一.栈结构 栈(stack)是限制插入和删除只能在一个位置上的表,该位置是 表的末端,叫做栈的顶(Top).对栈的基本操作有push(进栈),pop(出栈),peak(栈顶元素),size(栈容量)等. 栈的核心思想:"先进后出". 二.案例一:数组实现"栈" 1 package com.xfwl.algorithmAnalysis.stack; 2 3 import java.util.Arrays; 4 5 /** 6 * 自定义栈结构(基于数组的形式) 7 *

双链表代码实现和讲解

1.什么是链表 请移步看我前一篇https://www.cnblogs.com/han200113/p/11549338.html 2.双链表和单链表有什么不同?                                双链表相比单链表的date域(节点内容)和next(指向下一个节点)多了一个pre(指向前一个节点) 单链表只能向后或向后查找,而双链表由于有节点pre,可实现向前和向后查找 单链表的删除需要借助前一个节点,双链表可改变自身前后节点的指向实现自我删除(详情看代码部分) 3.

双链表的基本操作

1 #include <stdio.h> 2 #include <stdlib.h> 3 typedef struct line{ 4 struct line * prior; 5 int data; 6 struct line * next; 7 }line; 8 //双链表的创建 9 line* initLine(line * head); 10 //双链表插入元素,add表示插入位置 11 line * insertLine(line * head,int data,int

线性表—双链表

1.基础知识 a.双链表结点的结构:其由前序元素地址,数据域,后继元素地址组成. b.双链表结点的连接方法:先声明该结点,可以在内部也可以利用其特性来表明前序结点和后继结点是什么,之后同时还需要说明"其前序结点的后继地址为该结点"和"其后继结点的前序地址为该结点.(本质:双向) 2.循环双链表的实现 线性表接口LList package com.clarck.datastructure.dlinked; /*** 线性表接口LList,描述线性表抽象数据类型,泛型参数T表示数

链表 基本操作

实验目的 1． 定义单链表的结点类型. 2． 熟悉对单链表的一些基本操作和具体的函数定义. 3． 通过单链表的定义掌握线性表的链式存储结构的特点. 4． 掌握循环链表和双链表的定义和构造方法. 实验内容 该程序的功能是实现单链表的定义和操作.该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数.程序中的单链表(带头结点)结点为结构类型,结点值为整型. /* 定义DataType为int类型 */ typedef int DataType; /* 单链表的结点类型 */ typedef

Java入门系列：实例讲解ArrayList用法

本文通过实例讲解Java中如何使用ArrayList类. Java.util.ArrayList类是一个动态数组类型,也就是说,ArrayList对象既有数组的特征,也有链表的特征.可以随时从链表中添加或删除一个元素.ArrayList实现了List接口. 大家知道,数组是静态的,数组被初始化之后,数组长度就不能再改变了.ArrayList是可以动态改变大小的.那么,什么时候使用Array(数组),什么时候使用ArrayList?答案是:当我们不知道到底有多少个数据元素的时候,就可使用Array