数据结构DAY5-双向链表

最新推荐文章于 2024-10-10 20:50:55 发布
最新推荐文章于 2024-10-10 20:50:55 发布
阅读量94 收藏
点赞数
文章标签： c语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/designesb/article/details/129627948
版权
作业
双向链表按位置删除
双向链表按位置修改
双向链表按位置查找

main.c

#include "head.h"

int main(int argc, const char *argv[])
{
    Doublelink L = create_head();

    // 头插
    int n;
    datetype e;
    printf("请输入要头插入元素的个数：");
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        printf("请输入要插入的值：");
        scanf(" %c", &e);
        insert_head(L, e);
    }

    // 输出
    Out(L);

    // 尾插
    printf("\n请输入要尾插入元素的个数：");
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        printf("请输入要插入的值：");
        scanf(" %c", &e);
        insert_rear(L, e);
    }
    printf("\n尾插后的值\n");
    Out(L);

    // 头删:永远删除头节点
    delete_head(L);
    delete_head(L);
    printf("\n头删后的值\n");
    Out(L);

    // 尾删：永远删除尾节点
    delete_rear(L);
    delete_rear(L);
    printf("\n尾删后的值\n");
    Out(L);

    //按位置插入
    int pos;
    printf("\n请输入要插入的位置：");
    scanf("%d",&pos);
    printf("请输入要插入值：");
    scanf(" %c",&e);
    insert_by_pos(L,pos,e);
    printf("\n按位置插入后的值\n");
    Out(L);

//按位置删除
    printf("\n请输入要删除的位置：");
    scanf("%d",&pos);
    deletet_by_pos(L,pos);
    printf("\n按位置删除后的值\n");
    Out(L);
    printf("\n");

    //按位置修改
    printf("请输入要修改的位置：");
    scanf("%d",&pos);
    printf("请输入要修改的值：");
    scanf(" %c",&e);
    revamp_by_pos(L,pos,e);
    printf("\n按位置修改后的值\n");
    Out(L);

    //按位置查找
    printf("请输入想要查找值的下标：");
    scanf("%d",&pos);
    find_by_pos(L,pos);
   



    return 0;
}

test.c

#include "head.h"

Doublelink create_head()
{
    Doublelink L = (Doublelink)malloc(sizeof(struct Node));
    if (L == NULL)
    {
        return NULL;
    }
    // L节点的数据域
    L->len = 0;
    // L后继指针域
    L->next = NULL;
    // L前驱指针域
    L->prev = NULL;

    return L;
}

// 创建普通节点
Doublelink create_node()
{
    Doublelink p = (Doublelink)malloc(sizeof(struct Node));
    if (p == NULL)
    {
        return NULL;
    }
    // L节点的数据域
    p->date = 0;
    // L后继指针域
    p->next = NULL;
    // L前驱指针域
    p->prev = NULL;

    return p;
}

// 头插
int insert_head(Doublelink L, datetype e)
{
    // 判断头节点是否存储
    if (L == NULL)
    {
        return -1;
    }

    // 创建新节点
    Doublelink p = create_node();
    if (p == NULL)
        return -1;
    // p的数据域
    p->date = e;
    // p的指针域
    p->next = L->next;
    p->prev = L;
    if (L->next != NULL)
    {
        L->next->prev = p;
    }

    L->next = p;
    L->len++;
}

// 输出
void Out(Doublelink L)
{

    Doublelink p = L;

    if(0==L->len)
    {
        printf("长度为0\n");
        return 0;
    }
    printf("正向结果是：\n");
    while (p->next)
    {
        p = p->next;
        printf("%c\t", p->date);
    }

    printf("\n逆向结果是：\n");

 

    while (p->prev->prev)
    {
        printf("%c\t", p->date);
        p = p->prev;
    }
}

// 尾插
int insert_rear(Doublelink L, datetype e)
{
    // 判断头节点是否存在
    if (L == NULL)
    {
        printf("插入失败\n");
        return -1;
    }

    // 找到尾部
    Doublelink p = L;

    while (p->next)
    {
        p = p->next;
    }

    // 在p后面插入新节点
    Doublelink s = create_node();

    if (s == NULL)
    {
        return -1;
    }

    // s的数据域
    s->date = e;

    // s的指针域
    s->next = p->next;
    s->prev = p;
    p->next = s;

    L->len++;

    return 0;
}

// 头删
int delete_head(Doublelink L)
{
    // 判断头节点是否存在
    // 判断链表是否为空
    if (L == NULL || L->len == 0)
    {
        printf("删除失败\n");
        return -1;
    }

    Doublelink p = L->next;
    L->next = p->next;
    if (p->next != NULL)
    {
        p->next->prev = L;
    }

    free(p);
    p = NULL;

    L->len--;

    return 0;
}

// 尾删
int delete_rear(Doublelink L)
{
    // 判断头节点是否存在
    // 判断链表是否为空
    if (L == NULL || L->len == 0)
    {
        printf("删除失败\n");
        return -1;
    }

    Doublelink p = L;
    // 循环到最后一位
    while (p->next)
    {
        p = p->next;
    }

    // 删除p节点
    p->prev->next = NULL;
    free(p);
    p = NULL;

    L->len--;

    return 0;
}

// 按位置插入
int insert_by_pos(Doublelink L, int pos, datetype e)
{
    if (L == NULL || pos < 1 || pos > L->len + 1)
    {
        return -1;
    }

    Doublelink p = L;

    for (int i = 0; i < pos - 1; i++)
    {
        p = p->next;
    }

    Doublelink s = create_node();

    if (s == NULL)
    {
        return -1;
    }

    s->date = e;

    s->next = p->next;
    s->prev = p;
    if (p->next != NULL)
    {
        p->next->prev = s;
    }
    p->next = s;
    L->len++;

    return 0;
}

int deletet_by_pos(Doublelink L, int pos)
{
    if (L == NULL || L->len == 0 || pos < 1 || pos > L->len)
    {
        printf("插入失败\n");
        return -1;
    }

    Doublelink p = L;

    for (int i = 0; i < pos - 1; i++)
    {
        p = p->next;
    }

    Doublelink q = p->next;

    p->next = q->next;
    q->prev = p;

    free(q);
    q = NULL;
    L->len--;

    return 0;
}

int revamp_by_pos(Doublelink L, int pos, datetype e)
{
    if (L == NULL || pos < 1 || pos > L->len + 1)
    {
        printf("修改失败\n");
        return -1;
    }

    Doublelink p = L;

    for (int i = 0; i < pos - 1; i++)
    {
        p = p->next;
    }

    p->next->date = e;

    return 0;
}

int find_by_pos(Doublelink L,int pos)
{
    if(L==NULL || pos<1 || pos>L->len)
    {
        printf("查找失败\n");
        return -1;
    }

    Doublelink p=L;

    for(int i=0;i<pos;i++)
    {
        p=p->next;
    }



    printf("%d下标对应的值是%c\n",pos,p->date);

    return 0;
}

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

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

typedef char datetype;

typedef struct Node
{
    // 数据域
    union
    {
        int len;       // 头节点的数据域
        datetype date; // 其他节点的数据元素
    };

    // 后继指针域
    struct Node *next;

    // 前驱指针域
    struct Node *prev;

} *Doublelink;

Doublelink create_head();
Doublelink create_node();
int insert_head(Doublelink L, datetype e);
void Out(Doublelink L);
int insert_rear(Doublelink L, datetype e);
int delete_head(Doublelink L);
int delete_rear(Doublelink L);
int insert_by_pos(Doublelink L,int pos,datetype e);
int revamp_by_pos(Doublelink L, int pos, datetype e);
int find_by_pos(Doublelink L,int pos);

#include "test.c"
#endif

作业
单向循环链表尾插
单向循环链表头删
单向循环链表尾删
单向循环链表遍历

main.c

#include "head.h"

int main(int argc,const char * argv[])
{
    //创建头节点
    LoopLink L=create_head();

    //头插
    int n;
    datetype e;

    printf("请输入要插入的个数：");
    scanf("%d",&n);
    
    for(int i=0;i<n;i++)
    {
        printf("请输入要插入的值：");
        scanf("%f",&e);
        insert_head(L,e); 
    }
    printf("头插后的结果：\n");
    Out(L);
    

    //尾插
    printf("\n请输入要插入数的个数：\n");
    scanf("%d",&n);
    
    for(int i=0;i<n;i++)
    {
        printf("请输入要插入的值：");
        scanf("%f",&e);
        insert_rear(L,e);
    }
    printf("尾插后的结果：\n");
    Out(L);

    //头删
    delete_head(L);
    delete_head(L);
    printf("\n头删后的结果：\n");
    Out(L);

    //尾删
    delete_rear(L);
    delete_rear(L);
    printf("\n尾删后的结果：\n");
    Out(L);
    
    return 0;
}

test.c

#include "head.h"

//创建头节点
LoopLink create_head()
{
    LoopLink L=(LoopLink)malloc(sizeof(struct Node));
    if(L==NULL)
    {
        return NULL;
    }

    L->len=0;
    L->next=L;

    return L;
}

//创建普通节点
LoopLink create_node()
{
    LoopLink p=(LoopLink)malloc(sizeof(struct Node));
    if(p==NULL)
    {
        return NULL;
    }

    p->date=0;
    p->next=NULL;

     return p;

}

 //头插
int insert_head(LoopLink L,datetype e)
{
    //1.判断头节点是否存在
    if(L==NULL)
    {
        printf("插入失败\n");
        return -1;
    }

    //2.创建新的节点
    LoopLink p=create_node();
    if(p==NULL)
    {
        return -1;
    }

    //3.p的数据域
    p->date=e;

    //4.p的指针域
    p->next=L->next;

    L->next=p;
    L->len++;

      return 0;

}

//输出
void Out(LoopLink L)
{
    LoopLink p=L;

    while(p->next!=L)
    {
        p=p->next;
        printf("%.2f\t",p->date);
    }
}

//尾插
int insert_rear(LoopLink L,datetype e)
{
    //1.判断头节点是否存在
    if(L==NULL)
    {
        printf("插入失败\n");
        return -1;
    }

    LoopLink p=L;
    while(p->next!=L)
    {
        p=p->next;
    }
    //2.创建新的节点
    LoopLink s=create_node();
    if(s==NULL)
    {
        return -1;
    }

    //3.p的数据域
    s->date=e;

    //4.p的指针域
    p->next=s;
    s->next=L;
    L->len++;
}
/*
//头删
int delete_head(LoopLink L)
{
    if(L==NULL || L->len==0)
    {
        printf("删除失败\n");
        return -1;
    }

    LoopLink p=L->next;

    L->next=p->next;
    free(p);
    p==NULL;
    L->len--;

    return 0;
}
*/
int delete_rear(LoopLink L)
{
    if(L==NULL || L->len==0)
    {
        printf("删除失败\n");
        return -1;
    }

    LoopLink p=L->next;

    while(p->next->next!=L)
    {
        p=p->next;
        printf("1");
    }

    LoopLink q=p;

    q=p->next;
    p->next=L;
    free(q);
    q==NULL;
    L->len--;

    return 0;
}

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

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


typedef float datetype;

typedef struct Node
{
    // 数据域
    union
    {
        int len;       
        datetype date; 
    };

    // 指针域
    struct Node *next;
} *LoopLink;

LoopLink create_head();
void Out(LoopLink L);
LoopLink create_node();
int insert_rear(LoopLink L,datetype e);
int delete_head(LoopLink L);
int delete_rear(LoopLink L);




#include "test.c"
#endif
Bear-ear
关注
双链表(DoubleLinkList)数据结构的基本操作实现详解，重磅来袭！结构复杂但高效～
HenryBlog
08-20 1214
目录一、前言二、整体框架设计三、函数实现1. createDBLSTNode2. doubleListInit3. doubleListPrint4. doubleListDestory5. doubleListEmpty6. doubleListSize7. doubleListPushBack8. doubleListPushFront9. doubleListInsert10. doubleListErase11. doubleListPopBack12. doubleListPopFront13.
双向链表类DoubleLink，提供addFirst，addEnd，delete功能
第十七签
08-17 880
package test; public class DoubleLink { private Node first; private Node end; /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub DoubleLink
实验二 线性表综合实验（双链表）
i273627658的博客
10-07 356
一．实验目的         巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相关知识来解决具体问题。 二.  实验内容 1.建立一个由n个学生成绩的顺序表，n的大小由自己确定，每一个学生的成绩信息由自己确定，实现数据的对表进行插入、删除、查找等操作。分别输出结果。 双链表 源代码 #include
Single Link List in Python
Xcq007的博客
08-25 428
Single Link List class Node(object): '''this is a node''' def __init__(self, elem): self.elem = elem self.next = None class SingleLinkList(object): '''this is a Singly ...
双向链表（DoubleLinkList）
Cdreamfly的博客
07-06 816
双向链表 有关链表的知识可以点击我上篇文章这里就不再赘述LinkedList 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 双向循环链表的可以点击我这篇文章这里就不再赘述DoubleLoopLinkList 添加 头添加 void addFirst(const T &e) { //新建一个节点让它前驱指向头，后继指向头的后
【嵌入式学习】数据结构day01.25---双向链表
m0_60905006的博客
01-25 367
** function: 创建结点* @return*/return p;/** function: 头插* @return*/head=s;elsehead=s;/** function: 尾插* @return*/head=s;p->next=s;s->prev=p;/** function: 头删* @return*/free(head);head=NULL;else。
数据结构-C语言代码 day 3-双向链表
yydslty的博客
05-03 1420
1.双向链表的定义 上一节学习了单链表。今天学习双链表。 单向链表特点：   1.我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的.   2.只能从头遍历到尾或者从尾遍历到头(一般从头到尾) 双向链表特点   1.每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难一些   2.相对于单向链表, 必然占用内存空间更大一些.   3.既可以从头遍历到尾, 又可以从尾遍历到头 双向链表的定义:   双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指
数据结构day2--双向链表
weixin_69286552的博客
04-05 714
函数中，用结点结构体定义一个指针P，大小为表头结构体的大小，P的前驱与后继指针都指向空，数据为输入函数的参数。
数据结构与算法day07-双向链表应用案例
深耕java的博客
12-02 593
使用带head头的双向链表实现-水浒传排行榜管理 单链表的缺点： 1.单链表，查找的方向只能是一个方向，而双向链表可以 向前或向后查找 2.单链表不能自我删除，需要靠辅助节点(指针)，而双向 链表，则不用辅助指针，所以前面我们单链表删节点， 总是找到temp，temp是待删除节点的前一个接点 3.示意图帮助理解删除 ...
嵌入式学习-线性表Day05-双向链表
Xiaomo1536的博客
10-10 460
双向链表//双向链表的节点定义//数据域//指向下一个节点的指针 next 下一个//指向前一个节点的指针 prior 先前的//将双向链表的头指针和尾指针封装到一个节点体里//思想上有点像学的链式队列//指向双向链表的头指针//指向双向链表的尾指针int len;//用来保存当前双向链表的长度操作函数1）创建一个空的双向链表2）双向链表中间插入。
数据结构小练习-线性表（下）
06-25
数据结构是计算机科学中的核心概念，它涉及到如何高效地存储和组织数据，以便进行各种操作。线性表作为数据结构的基础类型，是我们理解和学习数据结构的起点。在本练习中，我们将聚焦线性表的下半部分，探讨其特性和...
数据结构课程设计-------双链表实现个人通讯录
x1432553805的博客
06-27 4400
一、实训目的 通过课程设计，学会运用数据结构知识，针对具体应用，自己设计合理数据结构，确定存储结构，并能设计具体操作算法，选择使用具体语言进行实现。掌握 C++较复杂程序的组织和设计过程，调试技巧。学习解决实际问题的能力。二、实训环境 VC++6.0 环境用C++语言实现。三、课程设计题目李刚是一爱折腾的人，当然爱折腾的人均有梦想，他想当中国的盖次呢。可不，现在个人好友信息多了，复杂了，他想制作一...
数据结构(Java)——Day10(双向链表，栈)
LengchenAl的博客
11-24 738
数据结构(Java)——Day10(双向链表，栈)
2024年网安最新嵌入式学习DAY21 --- 数据结构（双向链表、栈、队列）_队列、栈
2401_84302761的博客
05-01 69
/栈顶元素的下标，初始值：-1，表示没有元素。Int count;//当前队列的元素个数。Int iFront;Int iRear;第三步：main.c。
数据结构学习——双向链表
YiHeboy的博客
07-05 919
双向循环链表的创建及增删改查
【最新华为OD机试E卷-支持在线评测】补种未成活胡杨(100分)多语言题解-(Python/C/JavaScript/Java/Cpp)
春秋招笔试突围
10-10 165
🍭 大家好这里是，一枚热爱算法的程序员💻 ACM金牌🏅️团队 ｜ 大厂实习经历 ｜ 多年算法竞赛经历✨ 本系列打算持续跟新的多语言AC题解🧩 大部分包含PythonCJavascriptJavaCpp多语言代码。
C语言 | Leetcode C语言题解之第466题统计重复个数
m0_59237910的博客
10-09 1076
C语言 | Leetcode C语言题解之第466题统计重复个数
tinyarray-1.2.3-cp36-cp36m-win_amd64.whl
最新发布
10-14
tinyarray-1.2.3-cp36-cp36m-win_amd64.whl
minepy-1.2.6-pp38-pypy38_pp73-win_amd64.whl
10-14
minepy-1.2.6-pp38-pypy38_pp73-win_amd64.whl
数据结构-双向链表前插操作详解
"双向链表的前插操作算法及其在数据结构中的重要性" 在计算机科学中，数据结构是研究如何高效地存储和处理数据的重要领域。清华大学严蔚敏教授的《数据结构》C语言版中详细阐述了各种数据结构及其操作，其中包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值