数据结构与算法篇 之单链表与双链表

最新推荐文章于 2022-06-20 15:33:54 发布
最新推荐文章于 2022-06-20 15:33:54 发布
阅读量174 收藏 3
点赞数
分类专栏： 数据结构 文章标签： c链表 c单链表 c双链表 单链表基本操作 双链表基本操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38452632/article/details/102730166
版权

链表的基础操作，增删查插

感觉最重要的画出来，一步一步的分析，不要凭空想象，不要凭空想象，不要凭空想象

单链表：

#include <stdio.h>
#include <stdlib.h>
#define bool int
#define false 0
#define true 1

typedef struct list
{
    int data;
    struct list *next;
}list;

list * init_list()
{
    struct list* head = (list*)malloc(sizeof(list));
    head->next = NULL;
    head->data = -1;
    return head;
}

list * new_node(int data)
{
    struct list* head = (list*)malloc(sizeof(list));
    head->next = NULL;
    head->data = data;
    return head;
}

int get_list_len(list *head)
{
    if(head == NULL || head->next == NULL) return 0;
    int len = 1;
    list *tmp = head->next;
    while(tmp->next)
    {
        len++;
        tmp = tmp->next;
    }
    return len;
}

bool add_tail(list * head,list * p)
{
    if(head == NULL || p == NULL)
    {
        printf("list or new node is null \n");
        return false;
    }

    list *tmp = head;
    while(tmp->next != NULL)
    {
        tmp = tmp->next;
    }
    tmp->next = p;

    return true;
}


bool add_head(list *head,list *p)
{
    if(head == NULL || p == NULL)
    {
        printf("list or new node is null\n");
        return false;
    }
    list *tmp = head;

    p->next = tmp->next;
    tmp->next = p;

    return true;
}

bool search_node(list *head,int data,bool flag)
{
    if(head == NULL) return false;

    list *p = head->next;
    list *tmp = head;
    while(1)
    {
        if(data == p->data)
        {
            printf("%d is in the list\n",data);
            if(flag == true)
            {
                 tmp->next = p->next;
                 p->next = NULL;
                 free(p);
            }
            break;
        }
        if(p->next == NULL)
        {
            if(data == p->data)
            {
                printf("%d is in the list\n",data);
                if(flag == true)
                {
                    tmp->next = p->next;
                    p->next = NULL;
                    free(p);

                 }
            }
            else
            {
               printf("%d is not in the list\n",data);
            }
            break;
        }
        tmp = p;
        p = p->next;
    }

}

bool delete_tail_node(list *head)
{
    if (head == NULL) return false;
    int i = get_list_len(head) - 2;
    struct list *p = head->next;
    for(;i>0;p = p->next,--i);
    p->next->next = NULL;
    p->next = NULL;
    free(p->next);
}

bool delete_head_node(list *head)
{
    if(head == NULL) return false;

    struct list *p = head;
    struct list *tmp = p->next;
    tmp = p->next ;
    p->next = p->next->next;
    tmp->next = NULL;
    free(tmp);

}

bool delete_appoint_node(list *head,int num)
{
    if(head == NULL) return false;

    if(get_list_len(head) < num) return false;

    struct list *p = head->next;
    struct list *tmp = head;
    num--;
    while((p->next != NULL) && --num)
    {
        p = p->next;
    }
    tmp = p->next;
    p->next = p->next->next;
    tmp->next = NULL;

    free(tmp);
}

bool insert_tail_or_head(list *head,unsigned int num,list *new,bool flag)
{
    if (head == NULL || new == NULL)
    {
        printf("head or new is null");
        return false;
    }
    if(get_list_len(head) < num) return false;

    struct list *p = head;
    if(flag == true)
    {
        while(p->next != NULL && num--)
        {
            p = p->next;
        }
    }
    else
    {
        while(p->next != NULL && --num)
        {
            p = p->next;
        }
    }
    new->next = p->next;
    p->next = new;

    return true;
}

bool show_list(list* head)
{
    if(head == NULL) return false;
    struct list *p = head->next;
    int data;

    for ( ;p->next;p = p->next)
    {
        printf("%d",p->data);
        printf("-->");
    }
    printf("%d",p->data);

    printf("\n");
    return true;
}

int main()
{
    struct list* head = init_list();
    int i = 0;
    for (;i < 10;i++)
    {
        add_head(head,new_node(i));
    }
    printf("start...\n");
    show_list(head);
    printf("end...\n");

    int len = get_list_len(head);
    printf("list len %d\n",len);

    delete_tail_node(head);
    show_list(head);

    delete_head_node(head);
    show_list(head);

    delete_appoint_node(head,2);
    show_list(head);

    len = get_list_len(head);
    printf("list len %d\n",len);

    insert_tail_or_head(head,2,new_node(23),true);
    show_list(head);
    search_node(head,4,true);
    show_list(head);
    return 1;
}

双链表：

#include <stdio.h>
#include <stdlib.h>
#define bool int
#define false 0
#define true 1

typedef struct list
{
    int data;
    struct list *next;
    struct list *prev;
}list;

list * init_list()
{
    struct list* head = (list*)malloc(sizeof(list));
    head->next = NULL;
    head->prev = NULL;
    head->data = -1;
    return head;
}

list * new_node(int data)
{
    struct list* head = (list*)malloc(sizeof(list));
    head->next = NULL;
    head->prev = NULL;
    head->data = data;
    return head;
}

int get_list_len(list *head)
{
    if(head == NULL || head->next == NULL) return 0;
    int len = 1;
    list *tmp = head->next;
    while(tmp->next)
    {
        len++;
        tmp = tmp->next;
    }
    return len;
}

bool add_tail(list * head,list * p)
{
    if(head == NULL || p == NULL)
    {
        printf("list or new node is null \n");
        return false;
    }

    list *tmp = head;
    while(tmp->next != NULL)
    {
        tmp = tmp->next;
    }
    tmp->next = p;
    p->prev = tmp;
    return true;
}


bool add_head(list *head,list *p)
{
    if(head == NULL || p == NULL)
    {
        printf("list or new node is null\n");
        return false;
    }
    list *tmp = head;

    if(tmp->next == NULL)
    {
        tmp->next = p;
        p->prev = tmp;
        p->next = NULL;
        return true;
    }
    p->next = tmp->next;
    p->prev = tmp;
    tmp->next->prev = p;
    tmp->next = p;

    return true;
}

bool search_node(list *head,int data,bool flag)
{
    if(head == NULL) return false;

    list *p = head->next;
    while(1)
    {
        if(data == p->data)
        {
            printf("%d is in the list\n",data);
            if(flag == true)
            {
                 p->next->prev = p->prev;
                 p->prev->next = p->next;

                 p->next = NULL;
                 p->prev = NULL;
                 free(p);
            }
            break;
        }
        if(p->next == NULL)
        {
            if(data == p->data)
            {
                printf("%d is in the list\n",data);
                if(flag == true)
                {
                     p->next->prev = p->prev;
                     p->prev->next = p->next;

                     p->next = NULL;
                     p->prev = NULL;
                     free(p);
                 }
            }
            else
            {
               printf("%d is not in the list\n",data);
            }
            break;
        }
        p = p->next;
    }

}

bool delete_tail_node(list *head)
{
    if (head == NULL) return false;

    struct list *p = head->next;
    for(;p->next;p = p->next);
    p->prev->next = NULL;
    p->prev = NULL;
    p->next = NULL;
    free(p);
}

bool delete_head_node(list *head)
{
    if(head == NULL) return false;

    struct list *p = head;
    struct list *tmp = head->next;
    p->next->next->prev = p;
    p->next = p->next->next;
    tmp->next = NULL;
    tmp->prev = NULL;
    free(tmp);

}

bool delete_appoint_node(list *head,int num)
{
    if(head == NULL) return false;

    if(get_list_len(head) < num) return false;

    struct list *p = head->next;
    struct list *tmp = head;
    while((p->next != NULL) && --num)
    {
        p = p->next;
    }
    p->next->prev = p->prev;
    p->prev->next = p->next;

    p->next = NULL;
    p->prev = NULL;
    free(p);
}

bool insert_tail_or_head(list *head,unsigned int num,list *new,bool flag)
{
    if (head == NULL || new == NULL)
    {
        printf("head or new is null");
        return false;
    }
    if(get_list_len(head) < num) return false;

    struct list *p = head;
    if(flag == true)
    {
        while(p->next != NULL && num--)
        {
            p = p->next;
        }
    }
    else
    {
        while(p->next != NULL && --num)
        {
            p = p->next;
        }
    }
    new->next = p->next;
    new->prev = p;
    p->next->prev = new;
    p->next = new;

    return true;
}

bool show_list(list* head)
{
    if(head == NULL) return false;
    struct list *p = head->next;
    int data;

    for ( ;p->next;p = p->next)
    {
        printf("%d",p->data);
        printf("-->");
    }
    printf("%d",p->data);

    printf("\n");
    return true;
}

int main()
{
    struct list* head = init_list();
    int i = 0;
    for (;i < 10;i++)
    {
        add_head(head,new_node(i));
    }
    printf("start...\n");
    show_list(head);
    printf("end...\n");

    int len = get_list_len(head);
    printf("list len %d\n",len);

    delete_tail_node(head);
    delete_head_node(head);
    delete_head_node(head);

    show_list(head);
    delete_appoint_node(head,2);
    show_list(head);

    len = get_list_len(head);
    printf("list len %d\n",len);

    insert_tail_or_head(head,2,new_node(23),false);
    show_list(head);
    search_node(head,2,true);
    show_list(head);
    return 1;
}

 

天才小C
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java数据结构与算法】双向链表
12-21
如若未了解单链表请参考–>单链表点这里 双向链表示意图如下： 分析双向链表的遍历，添加，修改，删除的操作思路 遍历方式和单向链表一样，只是可以向前，也可以向后查找 添加（默认添加到双向链表的最后） 先找到...
剑指offer18：删除链表节点¶
a1272899331的博客
02-06 280
def deleteNode(head_node,del_node): #如果头节点为空，或要删除节点为空 if not head_node or not del_node: return False #要删除的不是尾节点 if del_node.next_node !=None: del_next_node=del_node.ne...
【数据结构与算法】之单链表、双链表、循环链表的基本介绍及其Java代码实现---第三篇
Java学习
10-13 827
博主秋招提前批已拿百度、字节跳动、拼多多、顺丰等公司的offer，可加微信：pcwl_Java一起交流秋招面试经验，可获得博主的秋招简历和复习笔记。 一、链表的基本介绍 链表的定义：链表是一种递归的数据结构，它或者为空(null)，或者是指向一个结点(node)的引用，该结点含有一个泛型的元素和一个指向另一条链表的引用。----Algorithms Fourth Edition...
数据结构与算法分析：单链表，双向链表，环形链表
weixin_46006363的博客
12-23 271
单链表 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 双向链表 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开...
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
C#数据结构与算法揭秘四 双向链表
12-31
双向链表结点的定义与单链表的结点的定义很相似， ，只是双向链表多了一个字段 prev。其实，双向链表更像是一根链条一样，你连我，我连你，不清楚，请看图。 双向链表结点类的实现如下所示 //一个链条的类 public ...
数据结构单链表、双链表的逆置算法.doc
05-07
数据结构单链表、双链表的逆置算法.doc
C#数据结构与算法揭秘三 链表
01-01
什么是链表了，不要求逻辑上相邻的数据元素在物理存储位置上也相邻存储的线性结构称之为链表。举个现实中的例子吧，假如一个公司召开了视频会议的吧，能在北京总公司人看到上海分公司的人，他们就好比是逻辑上相邻的...
126邮箱页 html源码 单页源码 网站后台登陆界面HTML源码.zip
04-23
126邮箱页 html源码 单页源码 网站后台登陆界面HTML源码
武汉开放数据创新大赛——烽火杯文件.zip
04-23
武汉开放数据创新大赛——烽火杯文件
mmexport1713881481676.png
04-23
mmexport1713881481676.png
Digital currency trading platformAdobeXD源码下载设计素材UI设计.xd
最新发布
04-23
Digital currency trading platform landing pageAdobeXD源码下载设计素材UI设计
了解Java及环境搭建
04-23
了解Java及环境搭建
专业实习-三创赛.zip
04-23
专业实习-三创赛
第三届全国大学生服务外包创新创业大赛（智能楼宇能耗管理系统）.zip
04-23
第三届全国大学生服务外包创新创业大赛（智能楼宇能耗管理系统）
allPort Design SystemAdobeXD源码下载设计素材UI设计.xd
04-23
allPort Design SystemAdobeXD源码下载设计素材UI设计
JAVA ssm 实现论坛网站 毕业设计参考demo（内附源码+使用说明）
04-23
系统介绍 本系统根据企业的需求进行设计，具有以下特点：界面友好，采用人机对话方式，操作简单。信息查询灵活、快捷、数据存储安全。实现用户管理功能，主要包括用户登录与注册功能。对用户输入的数据，系统进行严格的数据检查，尽可能排除人为错误。要实现模糊查询功能，允许用户查询一类的文章。系统运行稳定，安全可靠。 操作注意事项 本系统的后台用户名为：mr，密码为：mrsoft 操作流程 （1）通过首页提供的数据可实现搜索数据。 （2）可通过首页的“进入论坛”超链接进入论坛区，此时用户可以浏览文章，并为文章添加评论。 （3）访客可登录系统来发表文章。
数据结构与算法-线性表
09-13
数据结构与算法-线性表是一种用于存储数据的数据结构，它可以按照一定的逻辑顺序来存储和访问数据。线性表的定义是一个有限个相同类型的数据元素的集合，每个数据元素都有一个唯一的前驱和后继。线性表可以用顺序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值