DAY14 数据结构——双向链表各类操作（HQYJ）

最新推荐文章于 2024-07-13 16:00:03 发布
最新推荐文章于 2024-07-13 16:00:03 发布
阅读量92 收藏
点赞数
分类专栏： 华清远见 文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43921012/article/details/129888304
版权

main.c

#include "main.h"

int main(int argc, char const *argv[])
{
    int n;
    printf("请输入数据元素的个数：");
    scanf("%d",&n);
    datatype e;
    Doublelink L = Creat_Head();
#if 0

    for (size_t i = 0; i < n; i++)
    {
        printf("请输入第%ld个字符串：",i+1);
        scanf("%s",e);
        Insert_Head(L,e);
    }

#else

    for (size_t i = 0; i < n; i++)
    {
        printf("请输入第%ld个字符串：",i+1);
        scanf("%s",e);
        Insert_Rear(L,e);
    }

#endif

    Outputlink(L);
    
    //双向链表头删
    printf("\n<-----------------双向链表头删----------------->\n\n");
    Delete_Head(L);
    Outputlink(L);

    //双向链表头删
    printf("\n<-----------------双向链表尾删----------------->\n\n");
    Delete_Rear(L);
    Outputlink(L);

    //双向链表按位置插入
    printf("\n<-----------------双向链表按位置插入----------------->\n\n");
    int pos;
    printf("请输入插入的位置：");
    scanf("%d",&pos);
    printf("请输入插入的字符串：");
    scanf("%s",e);
    Insert_Position(L,pos,e);
    Outputlink(L);

    //双向链表按位置插入
    printf("\n<-----------------双向链表按位置修改----------------->\n\n");
    printf("请输入修改的位置：");
    scanf("%d",&pos);
    printf("请输入修改的字符串：");
    scanf("%s",e);
    Updata_Position(L,pos,e);
    Outputlink(L);

    //双向链表按位置删除
    printf("\n<-----------------双向链表按位置删除----------------->\n\n");
    printf("请输入删除的位置：");
    scanf("%d",&pos);
    Delete_Position(L,pos);
    Outputlink(L);

    //双向链表按位置查找
    printf("\n<-----------------双向链表按位置查找----------------->\n\n");
    printf("请输入查找的位置：");
    scanf("%d",&pos);
    Search_Position(L,pos);
    Outputlink(L);

    printf("\n<-----------------双向链表操作到此结束----------------->\n\n");

    return 0;
}

main.h

#ifndef __MAIN_H
#define __MAIN_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef char datatype[20];

typedef struct Node
{
    //数据域
    union
    {
        int len;    //头结点数据域
        datatype data;  //普通结点数据域
    };
    //指针域
    struct Node *next;  //指向下一个结点的指针
    struct Node *prev;  //指向上一个结点的指针
}*Doublelink;

Doublelink Creat_Head();    //创建头结点
Doublelink Creat_Node();    //创建普通结点
int Insert_Head(Doublelink L,datatype e);//双向链表头插
int Insert_Rear(Doublelink L,datatype e);//双向链表尾插
void Outputlink(Doublelink L);  //双向链表遍历
int Delete_Head(Doublelink L);  //双向链表头删
int Delete_Rear(Doublelink L);  //双向链表尾删
int Insert_Position(Doublelink L,int pos,datatype e);   //双向链表按位置插入
int Updata_Position(Doublelink L,int pos,datatype e);   //双向链表按位置修改
int Delete_Position(Doublelink L,int pos);  //双向链表按位置删除
void Search_Position(Doublelink L,int pos);//双向链表按位置查找


#endif // !__MAIN_H

doublelin.c

#include "main.h"

/**
 * @brief 创建头结点
 * 
 * @return Doublelink 
 */
Doublelink Creat_Head()
{
    Doublelink L = (Doublelink)malloc(sizeof(struct Node));
    if (L == NULL)
        return NULL;
    //数据域
    L->len = 0;     //清空链表长度
    //指针域
    L->next = NULL;
    L->prev = NULL;
    return L;    
}

/**
 * @brief 创建普通结点
 * 
 * @return Doublelink 
 */
Doublelink Creat_Node()
{
    Doublelink p = (Doublelink)malloc(sizeof(struct Node));
    if (p == NULL)
        return NULL;
    //数据域
    strcpy(p->data,"\0");
    //指针域
    p->next = NULL;
    p->prev = NULL;
    return p;    
}

/**
 * @brief 双向链表头插
 * 
 * @param L 
 * @param e     插入的元素值
 * @return int  成功返回0,失败返回-1
 */
int Insert_Head(Doublelink L,datatype e)
{
    //判断链表头结点是否存在
    if (L == NULL)
        return -1;
    Doublelink s = Creat_Node();
    if (s == NULL)
        return -1;
    //指针域
    s->next = L->next;
    if (L->next != NULL)
    {
        L->next->prev = s;
    }
    s->prev = L;
    L->next = s;
    //数据域
    strcpy(s->data,e);
    L->len++;
    return 0;
}

/**
 * @brief 双向遍历输出链表
 * 
 * @param L 
 */
void Outputlink(Doublelink L)
{
    if (L == NULL || L->len == 0)
    {
        printf("\n数据元素不存在，遍历失败!\n");
        return;
    }
    //正向遍历
    Doublelink p = L;
    printf("正向遍历：");
    while (p->next != NULL)
    {
        p = p->next;
        printf("%s\t",p->data);
    }
    printf("\n");

    //逆向遍历
    printf("逆向遍历：");
    while (p != L)
    {
        printf("%s\t",p->data);
        p = p->prev;
    }
    printf("\n");
}

/**
 * @brief   双向链表尾插
 * 
 * @param L 
 * @param e     插入的元素值
 * @return int  成功返回0,失败返回-1
 */
int Insert_Rear(Doublelink L,datatype e)
{
    if (L == NULL)
        return -1;
    Doublelink s = Creat_Node();
    if (s == NULL)
        return -1;
    Doublelink p = L;
    for (size_t i = 1; i <= L->len; i++)
    {
        p = p->next;
    }
    //指针域
    s->prev = p;
    p->next = s;
    //数据域
    strcpy(s->data,e);
    L->len++;
    return 0;
}

/**
 * @brief 双向链表头删
 * 
 * @param L 
 * @return int  成功返回0，失败返回-1 
 */
int Delete_Head(Doublelink L)
{
    //判断链表头结点是否存在
    //判断链表是否为空
    if (L == NULL || L->len == 0)
    {
        printf("\n数据不存在，双向链表头删失败！\n");
        return -1;
    }
    Doublelink q = L->next;
    if (q->next != NULL)
    {
        q->next->prev = L;
    }
    L->next = q->next;
    free(q);
    q = NULL;
    L->len--;
    return 0;
}

/**
 * @brief   双向链表尾删
 * 
 * @param L 
 * @return int  成功返回0,失败返回-1
 */
int Delete_Rear(Doublelink L)
{
    if (L == NULL || L->len == 0)
    {
        printf("\n数据不存在，双向链表尾删失败！\n");
        return -1;
    }
    Doublelink q = L;
    for (size_t i = 1; i <= L->len; i++)
    {
        q = q->next;
    }
    free(q->next);
    q->prev->next = NULL;
    L->len--;
    return 0;
}

/**
 * @brief   链表按位置插入
 * 
 * @param L 
 * @param pos   插入的位置
 * @param e     插入的值
 * @return int  成功返回0,失败返回-1 
 */
int Insert_Position(Doublelink L,int pos,datatype e)
{
    if (L == NULL || pos < 1 || pos > L->len+1)
    {
        printf("\n按位置插入失败\n");
        return -1;
    }
    Doublelink s = Creat_Node();
    if (s == NULL)
        return -1;
    Doublelink p = L;
    for (size_t i = 1; i <= pos-1; i++)
    {
        p = p->next;
    }
    //指针域
    s->next = p->next;
    if (p->next != NULL)
    {
        p->next->prev = s;
    }
    s->prev = p;
    p->next = s;
    //数据域
    strcpy(s->data,e);
    L->len++;
    return 0;

}

/**
 * @brief   双向链表按位置修改
 * 
 * @param L 
 * @param pos   修改的位置
 * @param e     修改后的值
 * @return int  成功返回0,失败返回-1
 */
int Updata_Position(Doublelink L,int pos,datatype e)
{
    if (L == NULL || pos < 1 || pos > L->len)
    {
        printf("\n按位置修改失败\n");
        return -1;
    }
    Doublelink p = L;
    for (size_t i = 1; i <= pos; i++)
    {
        p = p->next;
    }
    strcpy(p->data,e);
    return 0;
}

/**
 * @brief   双向链表按位置删除
 * 
 * @param L 
 * @param pos   删除的位置
 * @return int  成功返回0,失败返回-1
 */
int Delete_Position(Doublelink L,int pos)
{
    //判断头结点是否存在
    //判断链表是否为空
    //判断位置是否合法
    if (L == NULL || L->len == 0 || pos < 1 || pos > L->len)
    {
        printf("\n按位置修改失败\n");
        return -1;
    }
    Doublelink p = L;
    for (size_t i = 1; i <= pos-1; i++)
    {
        p = p->next;
    }
    Doublelink q = p->next;
    p->next = q->next;
    if(q->next != NULL)
        q->next->prev = p;
    free(q);
    q = NULL;
    L->len--;
    return 0;
}

/**
 * @brief   双向链表按位置查找
 * 
 * @param L 
 * @param pos   查找的位置
 */
void Search_Position(Doublelink L,int pos)
{
    //判断头结点是否存在
    //判断链表是否为空
    //判断位置是否合法
    if (L == NULL || L->len == 0 || pos < 1 || pos > L->len)
    {
        printf("\n按位置修改失败\n");
        return;
    }
    Doublelink p = L;
    for (size_t i = 1; i <= pos; i++)
    {
        p = p->next;
    }
    printf("\n该位置上的字符串为：%s\n",p->data);

}

执行结果如下图所示：

 

欲上层楼 再上层楼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现数据结构和双向链表操作
01-21
数据结构 双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef ...
C#数据结构之双向链表(DbLinkList)实例详解
09-03
在C#中，双向链表（Double-Linked List，简称DbLinkList）是一种重要的数据结构，它允许在列表中的每个元素都有两个链接：一个指向前一个元素，另一个指向后一个元素。这种数据结构使得在链表中进行前向和后向遍历变...
数据结构——双向链表
qq_62960549的博客
05-03 5989
1.双链表的定义 双向链表基于单链表。单链表是单向的，有一个头结点，一个尾结点，要访问任何结点，都必须知道头结点，不能逆着进行。而双链表添加了一个指针域，通过两个指针域，分别指向结点的前结点和后结点。这样的话，可以通过双链表的任何结点，访问到它的前结点和后结点。 在双向链表中，结点除含有数据域外，还有两个链域，一个存储直接后继结点的地址，一般称为右链域；一个存储直接前驱结点地址，一般称之为左链域。 双向链表结构示意图： /*随机数的范围*/#define MAX 10e/*节点结构*/ typ
数据结构 —— 双向链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-08 6326
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
Java数据结构与算法——双向链表
★★光亭★★
03-11 6105
Java数据结构与算法——双向链表
数据结构学习——双向链表
weixin_62410421的博客
05-03 5009
文章目录前言——双向链表含义一、双向链表结构（图解）二、 双向链表的实际操作1、 结构2、创建头结点3、打印4、插入5、定位6、删除完整代码运行结果 前言——双向链表含义 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 一、双向链表结构（图解） 二、 双向链表的实际操作 1、 结构 /** * Double linked list of integ
数据结构——双向链表、循环链表
龍弟-idea的博客
11-29 3168
目录 双链表的实现 java中LinkedList实现 链表的复杂度分析 循环链表 双向链表，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null...
数据结构——双向链表（双向连接的图解、双向链表的创建、操作双向链表）
qq_52301431的博客
08-23 4064
举个例子: 假设一个文本编辑用链表来存储文本. 每一行用一个String对象存储在链表的一个节点中. 当编辑器用户向下移动光标时, 链表直接操作到下一个节点即可. 但是当用于将光标向上移动呢?- 我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的. 但是, 在实际开发中, 经常会遇到需要回到上一个节点的情况。- 也就是链表相连的过程是单向的. 实现的原理是上一个链表中有一个指向下一个的引用.- 一个节点既有向前连接的引用, 也有一个向后连接的引用.- 既可以从头遍历到尾, 又可以从尾遍历到头。
数据结构——双向链表操作集（C/C++）
Syclus的博客
01-29 3165
#include<cstdio> #include<iostream> #include<algorithm> using namespace std; typedef struct Lnode{ int data; struct Lnode *prior,*next; }Lnode,*LinkList; LinkList p; LinkList GetElem(LinkList L,int i){ int j=1; p=L->next; while(.
数据结构系列2——双向链表和双向循环链表
喜欢C艹的小白的博客
09-23 4427
引入：双向链表是在原来的单链表基础上增加了一个可以保存某节点的上一个节点的指针域的数据结构，相较于单链表而言，双向链表在查找数据的时候所花费的时间是要小于单链表的，因为其可进可退。其缺点就是增删节点比单链表麻烦，而且在创建节点的时候也需要多申请一个指针存储空间。双向循环链表，顾名思义就是在双向链表的基础上，将尾节点的“right”指针指向头结点，同时头结点的“left”指针指向尾节点，它和双向链表的不同是，其判断节点是否遍历完毕的条件不再是是否为空，而是是否回到了头结点，优点是可以在任意位置插入数据，时间.
数据结构——双向链表（保姆级教程，包学包会）
m0_74459304的博客
05-14 7440
1.双向链表的概念 双向链表就是带头双向循环链表 我们在学完单链表之后，就感觉这个非常简单了，他的主要表现就是拥有头节点，链表永不为空，不需要二级指针；可以通过一个节点找到上一个或者下一个节点；头尾相连呈环状。 他主要结构是由prev、next、data，这三个结构组成，通过prev找到前一个节点，next就不用多说了。
初阶数据结构——线性表——链表——带头双向循环链表
dtxew love c++
10-28 2681
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 ????????源代码已上传至我的码云 ????????博主的微信公众号关注啦，关注我每天学习一道题，点我关注 前言 其中在链表的实现中有很多种实现方法，主要取决于以下几个因素 单向还是双向？ 循环还是不循环？ 带头还是不带头 这几个特征两两组合，就可以看做一种链表的
C语言数据结构 双向链表的建立与基本操作
01-01
C语言数据结构 双向链表的建立与基本操作 双向链表比单链表有更好的灵活性，其大部分操作与线性表相同。下面总结双向链表与单链表之间的不同之处及我在实现过程中所遇到的问题。 1.双向链表的建立 双向链表在初始...
python实现数据结构中双向循环链表操作的示例
12-16
双向循环链表是一种重要的数据结构，它允许我们在链表的两端进行插入和删除操作，同时每个节点都包含指向其前一个和后一个节点的引用，形成一个闭合的循环。在给定的示例中，我们看到了如何用Python实现这种数据结构...
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 673
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 579
递归算法，爬楼梯等解法
二分查找和斐波那契查找
最新发布
weixin_50960004的博客
07-13 178
表面上看，后一调整存在风险，此时只能确定切分点arr[mid]＞target ，“贸然”地将arr[mi]排除在进一步的查找范围之外，似乎可能因遗漏这些元素，而导致本应成功的查找以失败告终。也就是说，无论朝哪个方向深入，都只需做1次元素的大小比较，其二，统一沿两个方向深入所需要执行的比较次数，比如都统一为一次。在有序向量中的查找，遇到重复的元素时会返回秩最大的那个，上述查找无法实现这个功能，因此加以改进。所以这样的话，想进入左半区间，进行一次比较，想进入右半区间，会进行两次比较，右侧比较会多。
数据结构day6链式队列
picians的博客
07-10 558
主程序dequeue(Q);Q=NULL;return 0;源程序free(Q);Q=NULL;H->len=0;Q->head=H;Q->tail=H;return Q;return -1;return new;return;return;=NULL)
Redis 底层数据结构
xsgnzb的专栏
07-09 376
是列表和哈希表底层的实现之一，当只包含数字和短的字符串时，使用这个结构。由压缩列表和节点构成。压缩链表包含字节大小、尾指针偏移量、节点个数、节点列表、结束标识。编码类型包括int16、int32、int64，元素数组里的类型和编码类型相同。是有序集合的底层实现之一，由跳跃表和跳跃表节点组成。当新元素比元素数组里存放的类型比大时，会进行类型升级，重新分配空间和排序。跳跃表和平衡数的区别是，跳跃表查询复杂度平均跟平衡树一样是logn，最差是n²，但是它的实现很简单。上个节点的长度是动态的，分为1字节和5字节。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值