数据结构（四）——双向循环链表、栈

最新推荐文章于 2023-10-22 20:24:23 发布
最新推荐文章于 2023-10-22 20:24:23 发布
阅读量553 收藏 2
点赞数 1
分类专栏： # 嵌入式数据结构 文章标签： 链表 数据结构
原文链接：https://editor.csdn.net/md/?articleId=122920617
版权
本文详细介绍了双向循环链表的定义、创建、插入和遍历操作，并提供了头删法删除节点的练习。此外，还讲解了栈的基本概念，包括顺序栈和链栈的实现，包括入栈、出栈、栈满和栈空的判断。最后，通过一个四则运算器的练习展示了栈在解决实际问题中的应用。
摘要由CSDN通过智能技术生成

文章目录

一、双向循环链表

1.1 概念

在这里插入图片描述

1.2 操作

1.2.1 定义一个结点结构体

#ifndef _DOUBLELIST_H_
#define _DOUBLELIST_H_
#include <stdio.h>
#include <stdlib.h>
typedef int DataType;
//定义结点结构体
typedef struct doublelist
{
    DataType data;
    struct doublelist *front;   //保存前一个结点的地址
    struct doublelist *next;   //保存后一个结点的地址
}doublelist;

1.2.2 创建一个空的双向循环链表

//创建一个空的双向循环链表
doublelist * DoubleListCreate()
{
    doublelist *head = (doublelist *)malloc(sizeof(doublelist));
    head->front = head;
    head->next = head;
    return head;
}

1.2.3 插入数据

在这里插入图片描述

//插入数据
void DoubleListInsert(doublelist *head,DataType value)
{
    doublelist *tmp = (doublelist *)malloc(sizeof(doublelist));
    tmp->front = NULL;
    tmp->next = NULL;
    tmp->data = value;

    tmp->next = head->next;
    tmp->front = head;

    head->next->front = tmp;
    head->next = tmp;
}

1.2.4 遍历链表

//遍历双向循环链表
void DoubleListPrint(doublelist *head)
{
    doublelist *p = head;
    while(p->next != head)
    {
        p = p->next;
        printf("%d ",p->data);
    }
    putchar(10);
}

练习：头删法删除数据

在这里插入图片描述

//头删法删除数据
DataType DoubleListDelete(doublelist *head)
{
    if(head->next == head)
    {
        printf("双向循环链表为空！\n");
        return (DataType)-1;
    }
    doublelist *tmp = head->next;

    head->next = tmp->next;
    tmp->next->front = head;

    DataType value = tmp->data;
    free(tmp);
    tmp = NULL;
    return value;
}

二、栈 （stack）

2.1 概念

栈的性质：后进先出
栈的操作：
入栈（压栈）push
出栈（单栈）pop

2.2 顺序栈 seqstack

2.2.1 定义数据类型

#ifndef _SEQSTACK_H_
#define _SEQSTACK_H_

#include <stdio.h>
#include <stdlib.h>
#define N 32
typedef int DataType;
typedef struct seqstack
{
    DataType data[N];
    int pos;
}seqstack;

#endif

2.2.2 定义结构体

创建栈

//创建一个空的栈
seqstack* SeqStackCreate()
{
    seqstack *s = (seqstack *)malloc(sizeof(seqstack));
    s->pos = -1;
    return s;
}

2.2.3 判断栈是否为满

//判断栈是否为满
int SeqStackIsFull(seqstack *s)
{
    return s->pos == N -1 ? 1 : 0;
}
判断栈是否为空
//判断栈是否为空
int SeqStackIsEmpty(seqstack *s)
{
    return s->pos == -1 ? 1: 0;
}

2.2.4 入栈

//入栈
void SeqStackPush(seqstack *s,DataType value)
{
    if(SeqStackIsFull(s))
    {
        printf("栈满了！\n");
        return;
    }
    s->pos++;
    s->data[s->pos] = value;
    return;
}

2.2.5 出栈

//出栈
DataType SeqStackPop(seqstack *s)
{
    if(SeqStackIsEmpty(s))
    {
        printf("栈为空！\n");
        return (DataType)-1;
    }
    DataType value = s->data[s->pos];
    s->pos--;
    return value;
}

2.3 链栈（链式栈）

在这里插入图片描述

整体代码

mian.c

//main.c
#include "linkstack.h"
int main(int argc, char const *argv[])
{
    stack s;
    InitStack(&s);
    push(&s,100);
    push(&s,200);
    push(&s,300);
    push(&s,400);
    push(&s,500);
    push(&s,600);
    push(&s,700);

    while(!EmptyStack(&s))
    {
        printf("出栈:%d\n",pop(&s));
    }
    return 0;
}

linkstack.c

//linkstack.c
#include "linkstack.h"
//初始化栈信息
void InitStack(stack *s)
{
    s->length = 0;
    s->top = NULL;
}
//入栈
void push(stack *s,DataType value)
{
    if(NULL == s)
    {
        printf("栈空间分配失败，初始化失败！\n");
        return ;
    }
    Node *tmp = (Node *)malloc(sizeof(Node));
    tmp->next = NULL;
    tmp->data = value;

    tmp->next = s->top;
    s->top = tmp;
    s->length++;
}
//获取栈顶元素
DataType GetTop(stack *s)
{
    if(NULL == s)
    {
        return (DataType)-1;
    }
    if(s->top == NULL)
    {
        return (DataType)-1;
    }
    return s->top->data;
}
//出栈
DataType pop(stack *s)
{
    if(NULL == s)
    {
        return (DataType)-1;
    }
    if(s->top == NULL)
    {
        return (DataType)-1;
    } 
    Node *tmp = s->top;
    s->top = tmp->next;
    DataType value = tmp->data;
    free(tmp);
    tmp = NULL;
    s->length--;
    return value;
}
//判断栈是否为空
int EmptyStack(stack *s)
{
    return s->top == NULL ? 1 : 0;
}
//清空栈
int ClearStack(stack *s)
{
    if(NULL == s)
    {
        return (DataType)-1;
    }
    if(s->top == NULL)
    {
        return (DataType)-1;
    }
    Node *tmp = s->top;
    while(tmp)
    {
        s->top = tmp->next;
        free(tmp);
        tmp = s->top;
        s->length--;
    }     
    return 1;
}

练习 四则运算器

在这里插入图片描述

//判断符号的优先级
int Priority(char ch)
{
    switch (ch)
    {
    case '(':
        return 3;
    case '*':
    case '/':
        return 2;
    case '+':
    case '-':
        return 1;
    default:
        return 0;
    }
}
//四则混合计算器
void calculator()
{
    stack s_sum, s_opt;
    InitStack(&s_sum);
    InitStack(&s_opt);
    char opt[128] = {0};
    printf("请输入表达式：\n");
    scanf("%s",opt);
    int i = 0,tmp = 0,num1,num2;
    while(opt[i] != '\0' || EmptyStack(&s_opt) != 1)
    {
        if(opt[i] >= '0' && opt[i] <= '9')   //运算数
        {
            tmp = tmp *10 + opt[i] - '0';
            i++;
            if(opt[i] < '0' || opt[i] > '9')
            {
                push(&s_sum,tmp);
                tmp = 0;
            }
        }
        else   //操作符
        {
            if(EmptyStack(&s_opt) == 1 || Priority(opt[i]) > Priority(GetTop(&s_opt))||
            (GetTop(&s_opt) == '(' && opt[i] != ')'))
            {
                push(&s_opt,opt[i]);
                i++;
                continue;
            }
            if(GetTop(&s_opt) == '(' && opt[i] == ')')
            {
                pop(&s_opt);
                i++;
                continue;
            }
            if(Priority(opt[i]) <= Priority(GetTop(&s_opt)) ||opt[i] == ')' && GetTop(&s_opt)!= '('||
            opt[i] == '\0' && EmptyStack(&s_opt) != 1)
            {
                switch (pop(&s_opt))
                {
                case '+':
                    num1 = pop(&s_sum);
                    num2 = pop(&s_sum);
                    push(&s_sum,num1 + num2);
                    break;
                case '-':
                    num1 = pop(&s_sum);
                    num2 = pop(&s_sum);
                    push(&s_sum,num2 - num1);
                    break;
                case '*':
                    num1 = pop(&s_sum);
                    num2 = pop(&s_sum);
                    push(&s_sum,num1 * num2);
                    break;
                case '/':
                    num1 = pop(&s_sum);
                    num2 = pop(&s_sum);
                    push(&s_sum,num2 / num1);
                    break;               
                default:
                    break;
                }
            }
        }
    }
    printf("%d\n",GetTop(&s_sum));
}
周末不下雨
关注
专栏目录
双向链表实现栈（Java） 2021.12.25
dangzefei的博客
12-25 1607
思路： 1.创建一个节点，节点包含编号，next和pre； 2.根据创建的节点创建双向链表 注意：写遍历栈函数时要创建临时节点来遍历，不然就不是遍历栈，而是出栈了，容易造成空指针异常。 //用双向链表创建栈 class LinkedListStack{ //创建头节点 private Node head = new Node(-1); //创建top节点指向最后一个节点 private Node top ...
数据结构--栈的双向带头循环链表实现
qq_35297945的博客
01-10 784
1 链表实现栈的示意图 使用双向带头循环链表来表示栈，表头和表尾均可表示为栈顶，这里以表头为栈顶为例。 进行入栈操作（头插）： 进行出栈操作（头删）： 2 链表实现栈 2.1 头文件及其定义 #include<stdio.h> #include<stdlib.h> typedef int STDataType; typedef struct LstkNode { STDataType data; struct ListNode* prev; struct ListNod
PHP实现双向链表、栈
weixin_33985679的博客
07-08 88
前期写过一个PHP实现单向链表、实现排序单向链表的一篇文章，传送门：http://www.cnblogs.com/yydcdut/p/3777760.html。双向链表写过了，再拿出来提一提：http://www.cnblogs.com/yydcdut/p/3782661.html。 这次再来分享一下实现双向链表和栈的实现。代码虽然是以前写的了，但是发现PHP写的这些代码很容易看懂！ 双向链表...
基于双向链表实现的栈
Gee_Zer的博客
08-15 4074
看了LinkedList的源码，明白了LinkedList底层使用的是双向链表，一直想找个机会实现一下双向链表，今天写到力扣的每日一题20.有效的括号，正好此题需要使用到栈，所以借此机会来自己实现一下基于双向链表实现的栈，实现栈之前要了解以下知识 1.什么是双向链表 双向链表是指一个节点有一个数据域，两个指针域，一个指针域指向上一个节点，一个指针域指向下一个节点，现在将指向上一个节点的指针域命名为pre，将指向下一个节点的指针域命名为next，节点命名为node，一个合格的双向链表如下图所示 中间的nod
用双向链表实现一个栈
weixin_30887919的博客
06-18 457
前面我们已经造好了一个轮子——双向链表，那么我们可以利用这个轮子做一个栈。 入栈：我们采用链表的头插 获得栈顶的元素：把头部元素拷贝到用户数据区 出栈：先把头部的元素拷贝到用户数据区，然后删除这个节点 好的，看一下头文件吧。 #pragma once #include "dlist.h" struct stack_info { struct dlist_info *d...
数据结构——双向循环链表（C语言实现）
最新发布
GDYJLXQ的博客
10-22 374
双向循环链表：结构复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势。
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3300
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
数据结构手把手教学——双向循环链表
Sanjay_Wu的博客
12-28 1362
文章不空谈理论，完全采用手把手教学，并有综合示例练习题，看完这篇，你绝对能掌握数据结构双向循环链表。
数据结构【Golang实现】(四)——双向循环链表
脑袋装水的博客
03-13 818
《Go语言》实现双向循环链表
数据结构——双向循环链表
wry_sunny_的博客
03-15 709
双向循环链表是一种链式存储结构，它的最后一个结点指向头结点，形成一个环。因此，从循环链表中的任何一个结点出发都能找到任何其他结点。双向循环链表的操作和双向链表的操作基本一致，差别仅仅在于算法中的循环条件有所不同。双向循环链表的头结点的前驱指向最后一个结点，尾结点的后继指向头结点。 注意：双向循环链表中无其他结点，只有头结点时 ，头结点的前驱和后继度指向自身。 1、双向循环链表的存储结构 t...
双向循环链表-栈-队列 (list大杂烩~会模版就好咯)
weixin_30256901的博客
10-15 115
#include <iostream> using namespace std; //#define DEBUG 1 #ifdef DEBUG #include <cstdio> int III = 0, iii; #define FUN_IN for(iii = 0; iii < III; ++iii) \ printf("\t"); \...
数据结构4--双向链表，栈
m0_52774518的博客
10-09 322
一、双向链表的增删改查 代码示例： public class DoubleLinkedListDemo { public static void main(String[] args) { System.out.println("双向链表的测试"); //先创建节点 HeroNode1 hero1 =new HeroNode1(1,"Jack","aaa"); HeroNode1 hero2 =new HeroNode1(2,"Ma
双向链表与栈
weixin_62728271的博客
01-16 339
一、双向链表 1、定义：一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。 2、操作 is_empty() 链表是否为空 length() 链表长度 travel() 遍历链表 add(item) 链表头部添加 append(item) 链表尾部添加 insert(pos, item) 指定位置添加 remove(item) 删除节点 search(item)
双向链表实现栈和队列
热门推荐
ws13575291650的博客
02-05 1万+
双向链表实现栈和队列前言1. 双向链表2. 栈 --》 双向链表 首部加 首部出 O(1)3. 队列 --》 双向链表 首部加 尾部出 O(1) 前言 栈 --》 双向链表 首部加 首部出 O(1) 队列 --》 双向链表 首部加 尾部出 O(1) 1. 双向链表 public static class Node<T> { public T value; public Node<T> last; public Node<T> next; publi
双链表&栈
Krive~Irving
05-21 1141
双链表的实现，添加、删除、查找节点操作； 栈的实现：入栈、出栈、查找栈顶元素操作； 栈的算法实例：最小栈，逆波兰表达式，括号匹配，栈的压入，弹出序列
栈--双向循环链表实现
m0_60178310的博客
08-18 664
代码： #include <stdio.h> #include <stdlib.h> #include <stdbool.h> /* 栈 用双向循环链表实现栈 栈：是通过对线性表的插入删除操作在同一端完成（头添加，头删除 或者 尾添加，尾删除） 栈的特点： 先进先出 操作的一端叫栈顶，另一端叫栈底 栈的功能: 1.创建栈 stack 【C语言就是一个栈指针，相当于链表的头或者尾指针】 2.判断栈是否为空 isEmpty 【一.
双链表与栈
qq_64743318的博客
11-28 573
双链表与栈
c语言之————有头循环双链表实现栈存储
long123bin的专栏
07-22 659
1、链表的实现 dlist.h
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值