数据结构DAY 5【双向链表】

最新推荐文章于 2024-11-15 20:48:32 发布
最新推荐文章于 2024-11-15 20:48:32 发布
阅读量62 收藏
点赞数
文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57580484/article/details/129627647
版权

双向链表：

DS4DList2head.h：

#ifndef _DLINKLIST_
#define _DLINKLIST_ 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int ElemType;
typedef struct DLNode
{
    union
    {
        int length;
        ElemType data;
    };
    struct DLNode *prior;
    struct DLNode *next;
}*DLinkList, DLNode;
//=========================================================================
// 双向链表头结点创建
DLinkList DListCreatHead(void);
// 双向链表其它结点创建
DLNode *DListCreatNode(void);
// 双向链表初始化
DLinkList DListInit(int mode);
// 双向链表的遍历
int DListOutPut(DLinkList pHead);
// 双向链表的释放
DLNode *DListFree(DLinkList pHead);
//=========================================================================
// 双向链表头插
int DListInsertHead(DLinkList pHead, DLNode *pNode);
// 双向链表尾插
int DListInsertTail(DLinkList pHead, DLNode *pNode);
//=========================================================================
// 双向链表头删
int DListDleteHead(DLinkList pHead);
// 双向链表尾删
int DListDleteTail(DLinkList pHead);
//=========================================================================
// 位置输入函数[复用]
int GetIndex(void);
// 元素输入函数[复用]
ElemType GetElem(void);

// 双向链表按位置插入
int DListInsertIndex(DLinkList pHead, int index, ElemType elem);
// 双向链表按位置删除
int DListDeleteIndex(DLinkList pHead, int index);
// 双向链表按位置修改
int DListReviseIndex(DLinkList pHead, int index, ElemType elem);
// 双向链表按位置查找
DLNode *DListSearchIndex(DLinkList pHead, int index);
#endif

DS4DList2.c：

#include "DS4DList2head.h"
int main(int argc, char const *argv[])
{
    #if 1
    {
        DLinkList pHead = DListInit(1);
        #if 0
        {
            // 双向链表头删
            DListDleteHead(pHead);
        }
        #endif
        #if 0
        {
            // 双向链表尾删
            DListDleteTail(pHead);
        }
        #endif
        #if 0
        {
            // input 
            int index = GetIndex();
            ElemType elem = GetElem();

            // 双向链表按位置插入
            DListInsertIndex(pHead, index, elem);
        }
        #endif
        #if 0
        {
            // input 
            int index = GetIndex();

            // 双向链表按位置删除
            DListDeleteIndex(pHead, index);
        }
        #endif
        #if 0
        {
            // input 
            int index = GetIndex();
            ElemType elem = GetElem();

            // 双向链表按位置修改
            DListReviseIndex(pHead, index, elem);
        }
        #endif
        #if 0
        {
            // input 
            int index = GetIndex();

            // 双向链表按位置查找
            DLNode *ret = DListSearchIndex(pHead, index);
            printf("\nFind index %d's value : %d\n", index, ret->data);
        }
        #endif
        #if 1
        {
            
        }
        #endif
        DListOutPut(pHead);
        pHead = DListFree(pHead);
    }
    #endif
    return 0;
}

DS4DList2func.c：

#include "DS4DList2head.h"
//=========================================================================
// 双向链表头结点创建
// 双向链表其它结点创建
// 双向链表初始化
// 双向链表的遍历
// 双向链表的释放
DLinkList DListCreatHead(void)
{
    DLinkList pHead = (DLinkList)malloc(sizeof(DLNode));
    if(NULL == pHead)
    {
        printf("DListCreatHead : Malloc failed exit.\n");
        return NULL;
    }
    pHead->length = 0;
    pHead->prior = NULL;
    pHead->next = NULL;
    return pHead;
}
DLNode *DListCreatNode(void)
{
    DLNode *pNode = (DLNode *)malloc(sizeof(DLNode));
    if(NULL == pNode)
    {
        printf("DListCreatNode : Malloc failed exit.\n");
        return NULL;
    }
    ElemType elem = 0;
    printf("Please input elem : ");
    scanf("%d", &elem);
    pNode->data = elem;
    pNode->prior = NULL;
    pNode->next = NULL;
    return pNode;
}
DLinkList DListInit(int mode)
{
    DLinkList pHead = DListCreatHead();
    if(NULL == pHead)
    {
        printf("DListInit : Head illegal exit.\n");
        return NULL;
    }
    int len = 0;
    printf("Please set the len : ");
    Circle : 
    scanf("%d", &len);
    if(len < 0)
    {
        goto Circle;
    }
    for(int i = 0; i < len; i++)
    {
        printf("Init Node[%d] : \n", i+1);
        DLNode *pNode = DListCreatNode();
        switch (mode)
        {
            case 1 :
                DListInsertTail(pHead, pNode);
                break;
            default:
                DListInsertHead(pHead, pNode);
                break;
        }
    }
    return pHead;
}
int DListOutPut(DLinkList pHead)
{
    if(NULL == pHead)
    {
        printf("DListOutPut : Head illegal exit.\n");
        return -1;
    }
    if(0 == pHead->length)
    {
        printf("DListOutPut : Length zero exit.\n");
        return -2;
    }
    printf("\nDListOutPut : \n");
    DLNode *pFlag = pHead->next;
    for(int i = 0; i < pHead->length; i++, pFlag=pFlag->next)
    {
        printf("Node[%d] : %d\n", i+1, pFlag->data);
    }
    return 0;
}
DLNode *DListFree(DLinkList pHead)
{
    if(NULL == pHead)
    {
        printf("DListFree : Head illegal exit.\n");
        return NULL;
    }
    int len = pHead->length;
    for(int i = 0; i < len; i++)
    {
        DListDleteHead(pHead);
    }
    // free
    free(pHead);
    pHead = NULL;
    return pHead;
}
//=========================================================================
// 双向链表头插
// 双向链表尾插
int DListInsertHead(DLinkList pHead, DLNode *pNode)
{                              
    if(NULL == pHead)
    {
        printf("DListInsertHead : Head illegal exit.\n");
        return -1;
    }
    if(NULL == pNode)
    {
        printf("DListInsertHead : Node illegal exit.\n");
        return -2;
    }
    // insert 4+1
    pNode->prior = pHead;
    pNode->next = pHead->next;
    if(NULL != pHead->next)
    {
        pNode->next->prior = pNode;
    }
    pHead->next = pNode;
    pHead->length++;
    printf("test : %d, %d", pHead->length, pHead->next->data);
    return 0;
}
int DListInsertTail(DLinkList pHead, DLNode *pNode)
{
    if(NULL == pHead)
    {
        printf("DListInsertHead : Head illegal exit.\n");
        return -1;
    }
    if(NULL == pNode)
    {
        printf("DListInsertHead : Node illegal exit.\n");
        return -2;
    }
    // find tail
    DLNode *pTail = pHead;
    for(int i = 0; i < pHead->length; i++, pTail=pTail->next);
    // insert 3+1
    pNode->next = NULL;
    pNode->prior = pTail;
    pTail->next = pNode;
    pHead->length++;
    return 0;
}
//=========================================================================
// 双向链表头删
// 双向链表尾删
int DListDleteHead(DLinkList pHead)
{
    if(NULL == pHead)
    {
        printf("DListDleteHead : Head illegal exit.\n");
        return -1;
    }
    if(0 == pHead->length)
    {
        printf("DListDleteHead : Length zero exit.\n");
        return -2;
    }
    DLNode *pDel = pHead->next;
    // delete
    pHead->next = pDel->next;
    if(NULL != pDel->next)
    {
        pDel->next->prior = pHead;
    }
    pHead->length--;
    // free
    free(pDel);
    pDel = NULL;
}
int DListDleteTail(DLinkList pHead)
{
    if(NULL == pHead)
    {
        printf("DListDleteTail : Head illegal exit.\n");
        return -1;
    }
    if(0 == pHead->length)
    {
        printf("DListDleteTail : Length zero exit.\n");
        return -2;
    }
    DLNode *pTailPrior = pHead;
    // find tail
    for(int i = 1; i < pHead->length; i++, pTailPrior=pTailPrior->next);
    // free
    free(pTailPrior->next);
    // delete
    pTailPrior->next = NULL;
    pHead->length--;
}
//=========================================================================
// 双向链表按位置插入
// 双向链表按位置删除
// 双向链表按位置修改
// 双向链表按位置查找

// 位置输入函数[复用]
int GetIndex(void)
{
    int index = 1;
    printf("GetIndex : Please input index[>=1] : ");
    Circle : 
    scanf("%d", &index);
    if(index < 1)
    {
        goto Circle;
    }
    return index;
}
// 元素输入函数[复用]
ElemType GetElem(void)
{
    ElemType elem = 0;
    printf("Please input your elem : ");
    scanf("%d", &elem);
    return elem;
}

int DListInsertIndex(DLinkList pHead, int index, ElemType elem)
{
    if(NULL == pHead)
    {
        printf("DListInsertIndex : Head illegal exit.\n");
        return -1;
    }
    if(index < 1 || index > pHead->length+1)// [1, len+1]
    {
        printf("DListInsertIndex : Index illegal exit.\n");
        return -2;
    }
    DLNode *pIndexPrior = pHead;
    // find index->prior
    for(int i = 1; i < index; i++, pIndexPrior=pIndexPrior->next);
    // insert
    DLNode *pInsert = (DLNode *)malloc(sizeof(DLNode));
    pInsert->data = elem;
    pInsert->next = pIndexPrior->next;
    pInsert->prior = pIndexPrior;
    pIndexPrior->next = pInsert;
    if(NULL != pInsert->next)
    {
        pInsert->next->prior = pInsert;
    }
    pHead->length++;
    return 0;
}
int DListDeleteIndex(DLinkList pHead, int index)
{
    if(NULL == pHead)
    {
        printf("DListDeleteIndex : Head illegal exit.\n");
        return -1;
    }
    if(0 == pHead->length)
    {
        printf("DListDeleteIndex : Length zero exit.\n");
        return -2;
    }
    if(index < 1 || index > pHead->length)// [1, len]
    {
        printf("DListDeleteIndex : Index illegal exit.\n");
        return -3;
    }
    DLNode *pDeletePrior = pHead;
    // find delete-prior
    for(int i = 1; i < index; i++, pDeletePrior=pDeletePrior->next);
    // delete
    DLNode *pDelete = pDeletePrior->next;
    pDeletePrior->next = pDelete->next;
    if(NULL != pDelete->next)
    {
        pDelete->next->prior = pDeletePrior;
    }
    pHead->length--;
    // free
    free(pDelete);
    pDelete = NULL;
}
int DListReviseIndex(DLinkList pHead, int index, ElemType elem)
{
    if(NULL == pHead)
    {
        printf("DListReviseIndex : Head illegal exit.\n");
        return -1;
    }
    if(0 == pHead->length)
    {
        printf("DListReviseIndex : Length zero exit.\n");
        return -2;
    }
    if(index < 1 || index > pHead->length)// [1, len]
    {
        printf("DListReviseIndex : Index illegal exit.\n");
        return -3;
    }
    DLNode *pRevise = pHead->next;
    // find revise
    for(int i = 1; i < index; i++, pRevise=pRevise->next);
    // revise
    pRevise->data = elem;
    return 0;
}
DLNode *DListSearchIndex(DLinkList pHead, int index)
{
    if(NULL == pHead)
    {
        printf("DListSearchIndex : Head illegal exit.\n");
        return NULL;
    }
    if(0 == pHead->length)
    {
        printf("DListSearchIndex : Length zero exit.\n");
        return NULL;
    }
    if(index < 1 || index > pHead->length)// [1, len]
    {
        printf("DListSearchIndex : Index illegal exit.\n");
        return NULL;
    }
    DLNode *pIndex = pHead->next;
    // find index
    for(int i = 1; i < index; i++, pIndex=pIndex->next);
    // revise
    return pIndex;
}

OutOfMemoryError:
关注
408_数据结构_双链表_Day7
weixin_45880844的博客
03-25 1023
目录双链表_初始头插法新建链表尾插法新建链表从前向后遍历输出从后向前遍历输出双链表_增加在第i个位置插入新结点双链表_删除删除在第i个位置的结点 双链表_初始 因为单链表无法实现从后向前遍历，所以双向链表就增设了一个前驱指针 头插法新建链表 插入第一个结点的时候 DL->next 是NULL,这个时候没有 DL->next->prior #include<stdio.h> #include<stdlib.h> typedef int ElemType; t
04、双向循环链表DLinkList
大王怕我去巡山
12-13 1145
双向循环链表初始化 往里面插入元素 测试插入： DLinkList.h #pragma once typedef int DataType; typedef struct DNode { DataType data; struct DNode* piror; struct DNode* next; }DListNode,*DLinkList; int InitList(DLinkList* head);/*初始化单链表*/ int ListEmpty(DLinkList...
数据结构 day5 单向循环链表 双向链表
weixin_55070858的博客
03-18 471
2:双向链表谁指谁 先后顺序没整明白 只能先复习单项参考单项链表的操作。
数据结构学习——双向链表
YiHeboy的博客
07-05 982
双向循环链表的创建及增删改查
0719|数据结构day5（双向链表+双向循环链表）
Smallxu_的博客
07-19 1161
单向链表的操作（简单排序、按元素插入、按元素修改）； 双链表（双向链表结构体建立、双向链表节点创建、双向链表头插、双向链表尾插、双向链表头删、双向链表尾删、双向链表遍历）；双链表全部代码；双向循环链表（结构体建立、节点创建、头插、尾插、头删、尾删、遍历）；双向循环链表所有代码
数据结构day3（双向链表操作）
weixin_66436813的博客
07-24 418
线性表的链式存储：解决了顺序存储的缺点，插入和删除。注意：用自己结构的指针一般就是 链表。DoubleLInk.h文件。DoubleLInk.c文件。
数据结构 day 5 双链表循环功能
LeeJongSuk_Shin的博客
05-18 68
双向链表循环链表头插。双向链表循环链表头删。双向链表循环链表尾插。双向链表循环链表尾删。
day07（数据结构）双向链表
QR70892的博客
08-21 384
（数据结构）双向链表
数据结构【有头双向链表】
qq_67578580的博客
07-30 1278
注意：这⾥的“带头”跟前⾯我们说的“头结点”是两个概念，实际前⾯的在单链表阶段称呼不严 谨，但是为了同学们更好的理解就直接称为单链表的头结点。带头链表⾥的头结点，实际为“哨兵位”，哨兵位结点不存储任何有效元素，只是站在这⾥“放哨 的”。
数据结构day5（双向循环链表）
Hellomino_的博客
04-21 119
分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。双向链表也叫双链表，是链表的一种，它的每个数据。
数据结构(Java)——Day10(双向链表，栈)
LengchenAl的博客
11-24 768
数据结构(Java)——Day10(双向链表，栈)
2024年网安最新嵌入式学习DAY21 --- 数据结构（双向链表、栈、队列）_队列、栈
2401_84302761的博客
05-01 89
/栈顶元素的下标，初始值：-1，表示没有元素。Int count;//当前队列的元素个数。Int iFront;Int iRear;第三步：main.c。
m数据结构 day10 树（三）线索二叉链表（双向链表）
wulimmya的博客
07-31 2149
二叉树的遍历 traversing binary tree 线性表的遍历很简单，因为元素具有一对一的前驱后继关系，遍历就是从头到尾，最多再来个循环遍历，双向遍历等。但是树的遍历更为复杂，因为一个结点访问后，下一个访问哪一个结点的选择不唯一。 我们喜欢用图的方式来表示树，即把树画成图，这样对我们人类很好理解，但是对于计算机，他只能处理线性序列，只能用循环和判断等方式，所以我们要通过遍历把树的所有结点变成某种意义的线性序列。 遍历是为了把树的所有结点变成某种意义的线性序列，以便计算机进行处理。 就这个次序最重
数据结构-递归函数的调用栈过程
qq_52291558的博客
11-12 240
这道题考察的是递归函数的调用栈过程。
数据结构 ——— 层序遍历链式二叉树
weixin_55341642的博客
11-13 648
利用队列先进先出的性质实现层序遍历链式二叉树
数据结构 -- 二叉搜索树
最新发布
zy1215058242的博客
11-15 481
场景2：商场无人值守车库，入口进场时扫描车牌，记录车牌和入场时间，出口离场时，扫描车牌，查找入场时间，用当前时间减入场时间计算出停车时长，计算出停车费用，缴费后抬杆，车辆离场。场景1：校区无人值守车库，校区车库买了车位的业主才能进小区，那么物业会把买了车位的业主的车牌号录入后台系统，车辆进入时扫描车牌在不在系统中，在就允许进入，不再则不能进入。场景3：统计⼀篇文章中单词出现的次数，读取⼀个单词，查找单词是否存在，不存在这个说明第⼀次出现，（单词，1），单词存在，则++单词对应的次数。
Pandas 数据结构
王小工小工历程
11-15 757
andas是Python数据分析库，其核心数据结构为DataFrame和Series，这两种数据结构不仅提供了高效的数据处理能力，还支持丰富的数据操作功能。
【数据结构】【线性表】单链表4—单链表的建立(附C语言源码)
weixin_58498967的博客
11-12 848
按位序插入，位序说明本身就链表就已经存在，一般是用在某一个单链表的某个位置进行插入，指定结点插入分前插和后插，由于单链表的不可逆性，前插操作需要找到前驱结点，这个过程需要经过类似于按位序插入的遍历结点的过程，比较复杂，而指定结点的后插只需要指定结点，一切顺理成章，操作简单，时间复杂度低。每次我们都将结点插入到头部，相当于一个倒序插入，而每次插入到尾部即为顺序插入，如果插入到中间则是无序，无序的线性表一般来说没有意义，因此我们用的最多的是头部插入和尾部插入，同时尾部插入又是最常用的插入方式。
表的数据结构和常见操作
cocofu的博客
11-11 512
**应用场景**：用于处理或显示所有元素，数组和链表可以简单地线性遍历，树和图则需要特定的遍历算法（如深度优先搜索、广度优先搜索）。- **定义**：链表是一种线性数据结构，其中元素存储在节点中，每个节点包含数据和指向下一个节点的指针。- **定义**：数组是一个简单的线性数据结构，其中元素按顺序存储，每个元素可以通过其索引直接访问。- **定义**：图是一种复杂的数据结构，由节点（顶点）和连接这些节点的边组成。- **适用场景**：需要快速查找、插入和删除的数据集合，如字典和集合。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值