双向链表与双向循环链表（删，查）

最新推荐文章于 2024-07-19 23:42:30 发布
最新推荐文章于 2024-07-19 23:42:30 发布
阅读量93 收藏
点赞数
文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71978011/article/details/130753842
版权

一、双向链表

 1.main.c

 

#include"head.h"
int main(int argc, char const *argv[])
{
    double_linklist *L=creat(1);//1头节点  0普通节点
	/*menue();*/
	
    /*datatype e;
    int n;
    printf("输入插入的个数:");
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
    printf("输入头插的字符:");
    scanf(" %c",&e);
    insert_head(L,e);
    }*/

    //尾插
    datatype a;int n;
    printf("输入尾插的个数:");
    scanf(" %d",&n);
     for(int i=0;i<n;i++)
    {
    printf("输入尾插的字符:");
    scanf(" %c",&a);
    input_rear(L,a);
    }
    
    //输出
    printf("输出结果:");
    output(L);

    //头删
    /*delete_head(L);
    output(L);*/

    //尾删
    /*delete_rear(L);
    output(L);*/

    //按位置插入

    /*int pos; datatype f;
    printf("输入按位置插入的位置:");
    scanf("%d",&pos);
    printf("输入插入的值:");
    scanf(" %c",&f);
    input_pos(L,f,pos);
    output(L);*/

    //按位置删除
    /*int pos;
    printf("输入要删除的位置:");
    scanf("%d",&pos);
    delete_pos(L,pos);
    output(L);
    puts("");*/


    //按位置修改
    /*datatype b;int pos;
    printf("输入修改的位置:");
    scanf("%d",&pos);
    printf("输入按位置修改后的值:");
    scanf(" %c",&b);
    revise_pos(L,b,pos);
    output(L);
    puts("");*/

    //按位置查找
    int pos;
    printf("输入要查找的位置:");
    scanf("%d",&pos);
    find_pos(L,pos);
    puts("");

    return 0;
}

 2.text.c

 

#include"head.h"
double_linklist *creat(int flag)
{
    double_linklist *L=(double_linklist *)malloc(sizeof(struct Node));
    if(L==NULL)
  {
    return NULL;
    }
    //成功返回地址
    if(flag==1)
    {
     L->len=0;
    }
    else if(flag==0)
    {
    L->data=0;
    L->next=NULL;
    L->prev=NULL;
	}
    return L;
}

//头插
int insert_head(double_linklist *L,datatype e)
{
    //1,判断是否创建成功
    if(L==NULL)
    {
    return -1;
    }
    //2,创建成功
	double_linklist *s=creat(0);
    if(s==NULL)
    {
    return -1;
    }
     s->data=e;
//指针域
	s->next=L->next;
	s->prev=L;
    if(L->next!=NULL)
    {
    L->next->prev=s;
    }
    L->next=s;
    L->len++;
    return 0;
}

//尾插
int input_rear(double_linklist *L,datatype e)
{
	if(L==NULL)
	{
		printf("尾插失败\n");
		return -1;
	}
	double_linklist *p=L;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	double_linklist *s=creat(0);
	s->data=e;
	p->next=s;
	s->prev=p;
	L->len++;
	return 0;
}
//输出
void output(double_linklist *L)
{
	if(L==NULL||L->next==NULL)
	{
		printf("遍历失败\n");
		return;
	}
	double_linklist *p=L;
	puts("正向遍历:");
	while(p->next!=NULL)
	{
		p=p->next;
		printf(" %c",p->data);
	}
	puts("");
	/*puts("反向遍历:");
	while(p->prev!=NULL)
	{
		printf(" %c",p->data);
		p=p->prev;
	}
	puts("");*/
}

//头部删除
int delete_head(double_linklist *L)
{
	if(L==NULL||L->next==NULL)
	{
		printf("不需要头删\n");
		return -1;
	}
	double_linklist *q=L;
	q=L->next;
	L->next=q->next;
	if(q->next!=NULL)
	{
		q->next->prev=L;
	}
	free(q);
	q=NULL;
	L->len--;
	printf("头删成功\n");
	return 0;
}

//尾部删除
int delete_rear(double_linklist *L)
{
	if(L==NULL||L->next==NULL)
	{
		printf("不需要头尾删\n");
		return -1;
	}
	double_linklist *p=L;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	p->prev->next=NULL;
	free(p);
	p=NULL;
	L->len--;
	printf("尾删成功\n");
	return 0;
}

//按位置插入
int input_pos(double_linklist *L,datatype f,int pos)
{
	if(L==NULL||pos<1||pos>L->len+1)
	{
		printf("按位置插入失败\n");
		return -1;
	}
	double_linklist *p=L;
	for(int i=0;i<pos-1;i++)
	{
		p=p->next;
	}
	double_linklist *s=creat(0);
	s->data=f;
	s->next=p->next;
	s->prev=p;
	if(p->next!=NULL)
	{
		p->next->prev=s;
	}
	p->next=s;
	L->len++;
	return 0;
}

//按位置删除
int delete_pos(double_linklist *L,int pos)
{
	if(L==NULL||L->next==NULL||pos<1||pos>L->len)
	{
		printf("无法删除\n");
		return -1;
	}
	double_linklist *p=L;
	for(int i=0;i<pos-1;i++)//这里要删除pos，找到pos-1就行了
	{
		p=p->next;//现在p在pos-1这里
	}
	double_linklist *q=p->next;//在定义一个q让他成为pos这个位置方便后面转换
	p->next=q->next;
	if(q->next!=NULL)
	{
		q->next->prev=p;
	}
	free(q);
	q=NULL;
	printf("按位置删除成功\n");
}

//按位置修改
int revise_pos(double_linklist *L,datatype b,int pos)
{
	if(L==NULL||L->next==NULL||pos<1||pos>L->len)
	{
		printf("无法修改\n");
		return -1;
	}
	double_linklist *p=L;
	for(int i=0;i<pos;i++)
	{
		p=p->next;
	}
	p->data=b;
	printf("按位置修改成功\n");
	return 0;
}

//按位置查找
int find_pos(double_linklist *L,int pos)
{
	if(L==NULL||L->next==NULL||pos<1||pos>L->len)
	{
		printf("无法查找\n");
		return -1;
	}
	double_linklist *p=L;
	for(int i=0;i<pos;i++)
	{
		p=p->next;
	}
	printf("此位置的数据是:%c",p->data);
	return 0;
}

 3.head.h

 

#ifndef N
#define  N
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef  char  datatype;
typedef struct Node
{
    //数据域
    union
    {
            int len;
            datatype  data;
    };
    struct Node *next;
    struct Node *prev;
    
}double_linklist;

void menue();
double_linklist *creat(int flag);
void output(double_linklist *L);

int insert_head(double_linklist *L,datatype e);
int input_rear(double_linklist *L,datatype e);

int delete_head(double_linklist *L);
int delete_rear(double_linklist *L);

int input_pos(double_linklist *L,datatype f,int pos);
int delete_pos(double_linklist *L,int pos);

int revise_pos(double_linklist *L,datatype b,int pos);
int find_pos(double_linklist *L,int pos);

#endif

二、双向循环链表

1.main.c

#include"head.h"
int main(int argc, char const *argv[])
{
   loop_double_linklist *L=creat(1);//1头节点  0普通节点
	/*menue();*/

    //头插
    /*int n;datatype e;
    printf("输入头插几个元素:");
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
    printf("输入要头插的元素:");
    scanf("%f",&e);
    insert_head(L,e);
    }
    puts("");
    output(L);*/
    puts("");

    //尾插
    int n;datatype a;
     printf("输入尾插几个元素:");
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
    printf("输入要尾插的元素:");
    scanf("%f",&a);
    insert_rear(L,a);
    }
    puts("");
    output(L);
    puts("");

    //头删
    /*delete_head(L);
    puts("");
    output(L);
    puts("");*/

    //尾删
    delete_rear(L);
    puts("");
    output(L);
    puts("");

2.text.c

#include"head.h"
/*void menue()
{
	puts("****************");
	puts("1.双向循环链表头插");//永远在头结点后面插入
	puts("2.双向循环链表遍历");
	puts("3.双向循环链表尾插");
	puts("");
	puts("4.单项链表头删");
	puts("5.单项链表尾删");
	puts("");
	puts("0.退出整个程序:");
	puts("");
}*/
loop_double_linklist *creat(int flag)
{
    loop_double_linklist *L=(loop_double_linklist *)malloc(sizeof(struct Node));
    if(L==NULL)
  {
    return NULL;
    }
    //成功返回地址
    //成功之后初始化
    if(flag==1)//头节点，需要让len为0
    {
     L->len=0;
     L->next=L;//双向需要让自己的next和prev都指向自己
     L->prev=L;
    }
    else if(flag==0)//普通节点，就是数据域为0
    {
    L->data=0;
    L->next=NULL;//普通节点都指向NULL，后面还要指向
    L->prev=NULL;
    }
    return L;
}

//双向循环头插
int insert_head(loop_double_linklist *L,datatype e)
{
        if(L==NULL)
        {
            printf("不需要头插\n");
            return -1;
        }
        loop_double_linklist *s=creat(0);
        if(s==NULL)
        {
            return -1;
        }
        s->data=e;
        s->next=L->next;
        s->prev=L;
        L->next->prev=s;
        L->next=s;
        L->len++;
        return 0;
}

//输出
void output(loop_double_linklist *L)
{
    puts("正向输出");
    loop_double_linklist *p=L;
    while(p->next!=L)
    {
            p=p->next;
            printf("%.1f\t",p->data);
    }
    puts("\n逆向输出");
    while(p->prev!=L->prev)
    {
        printf("%.1f\t",p->data);
        p=p->prev;
    }
    puts("");
}

//尾插
int insert_rear(loop_double_linklist *L,datatype a)
{
    if(L==NULL)
    {
        printf("尾插失败\n");
        return -1;
    }
    loop_double_linklist *p=L->prev;
    loop_double_linklist *s=creat(0);
    if(s==NULL)
    {
        printf("s创建失败\n");
        return -1;
    }
    s->data=a;
    s->prev=p;
    s->next=L;
    L->prev=s;
    p->next=s;
    return 0;
}

//头删
int delete_head(loop_double_linklist *L)
{
    if(L==NULL||L->next==NULL)
    {
        printf("无法头删\n");
        return -1;
    }
    loop_double_linklist *p=L->next;
    L->next=p->next;
    p->next->prev=L;
    free(p);
    p=NULL;
    printf("头删成功\n");
    return 0;
    }

//尾删
int delete_rear(loop_double_linklist *L)
{
    if(L==NULL||L->next==NULL)
    {
        printf("无法尾删\n");
        return -1;
    }
    loop_double_linklist *p=L->prev;
    p->prev->next=L;
    L->prev=p->prev;
    free(p);
    p=NULL;
    printf("尾删成功\n");
    return 0;
}

3.head.h

#ifndef N
#define  N
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef  float datatype;
typedef struct Node
{
    //数据域
    union
    {
            int len;
            datatype  data;
    };
    struct Node *next;
    struct Node *prev;
    
}loop_double_linklist;

void menue();
loop_double_linklist *creat(int flag);
void output(loop_double_linklist *L);

int insert_head(loop_double_linklist *L,datatype e);
int insert_rear(loop_double_linklist *L,datatype a);

int delete_head(loop_double_linklist *L);
int delete_rear(loop_double_linklist *L);


#endif

 

m0_71978011
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言中双向链表和双向循环链表详解
08-30
本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言中，双向链表是一种数据结构，具有前驱...
循环链表和双向链表.ppt
09-20
循环链表的插入和删除操作与单链表类似，但需要注意的是，由于没有明确的尾部标志，因此在遍历时需使用条件如`curr.next() != head`来避免无限循环。 双向链表则更进一步，每个链表节点不仅包含一个指向后继节点的...
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
09-20
双向循环链表是一种特殊的链式存储结构，它允许我们在链表的两个方向上进行遍历，这对于执行增删改查操作非常有用。下面我们将详细探讨这个系统的设计与实现。 首先，我们要理解双向循环链表的基本概念。双向循环...
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
在JavaScript中，数据结构是构建复杂程序的基础，其中双向链表和双向循环链表是两种重要的线性数据结构。本文将深入探讨这两种链表的实现原理，并通过代码示例进行详细解析。 首先，双向链表（Doubly Linked List）...
深入解析C++的循环链表与双向链表设计的API实现
09-02
在C++编程中，循环链表和双向链表是两种重要的数据结构，它们在处理动态数据集合时提供了灵活且高效的方式。循环链表是单链表的一种变体，它的最后一个节点指向链表的第一个节点，形成了一个逻辑上的环。双向链表则...
数据结构第32节 无锁编程
hummhumm的专栏
07-17 832
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
常见排序算法总结
mydaily_的博客
07-16 783
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1880
栈超超超详解
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 230
1%29%5D。
数据结构——栈
weixin_45942515的博客
07-19 169
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
《数据结构》预备
U2396573637的博客
07-19 470
位段的声明和结构体是类似的，有两个不同：1.位段的成员必须是int、unsigned int、 signed int，在C99中位段成员也可以选择其它类型。2.位段的成员后边有一个冒号和一个数字。int _b:5;int _c:10;int _d:30;A就是一个位段类型。那位段A所占内存的大小是多少呢？
数据结构(5.2_3)——二叉树的存储结构
最新发布
m0_65240792的博客
07-19 162
1%29%5D1。
数据结构(4.4)——求next数组
m0_65240792的博客
07-14 375
next[1]都无脑写0next[2]都无脑写1其他next:在不匹配的位置前边，划一条分界线，模式串一步一步往后退，直到分界线之前"能对上"，或模式串能完全跨过分界线为止，此时j指向哪儿，next数组值就是多少ababaa的next数组//求next[1]??????->??????/i=1->i=2ababaa-> ababaa //j=0,第一个字符匹配失败，只能匹配下一个子串，++i，++jnext[1]=0;//求next[2]a?????->a??????//i=2。
数据结构（队列）
2401_83968713的博客
07-19 452
这么看好像两者的差别不大，但是我们在单链表结构中可以稍作改造，直接定义两个结点（头结点，尾结点）指向原链表的队头和队尾，那么在队尾入数据时就不用遍历链表，直接让尾结点->next 等于新结点，时间复杂度就变成 O(1)了。概念：只允许在⼀端进⾏插⼊数据操作，在另⼀端进⾏删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)⼊队列操作的时间复杂度为 O(1) ,进行出队列操作的时间复杂度为 O(n);⼊队列：进⾏插⼊操作的⼀端称为队尾。出队列：进⾏删除操作的⼀端称为队头。
数据结构_排序
m0_73620971的博客
07-19 638
1、希尔排序是对直接插入排序的优化。2、直接选择排序效率不高，很少使用；堆排序效率高。3、快速排序综合性能和使用场景都是比较好的。4、归并排序更多是在解决磁盘中的外排序问题。
数据结构初阶（C语言）-顺序表
xiuwoaiailixiya的博客
07-15 1043
在进行顺序表的介绍之前，我们先来了解下什么是线性表：线性表是n个具有相同特性的数据元素的有限序列。线性表是⼀种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。
《数据结构：C语言实现双链表》
2401_83305953的博客
07-19 115
带头链表中的头结点，实际为“哨兵位”，哨兵位结点补存储任何有效元素，只是站在这里“放哨的”虽然有这么多的链表的结构，但我们实际中最常用的还是两种结构：单链表和双向带头循环链表.
数据结构：顺序表
2302_81442125的博客
07-19 145
数据结构是计算机存储、组织数据的方式。使用数据结构会大大提高程序运行的效率。
数据结构——排序
2301_79431343的博客
07-15 2780
int key;}redtype;int len;}sqlist;
循环链表与双向链表详解：基本操作与应用实例
本资源是一份关于数据结构与算法的第五讲，主要涵盖循环链表和双向链表的概念、特征以及基本运算。内容分为以下几个部分： 1. 带头结点的链表： - 头结点的引入是为了方便处理，它存储链表相关信息，如表中结点...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值