数据结构之单链表——括号匹配

最新推荐文章于 2023-11-22 22:26:59 发布
最新推荐文章于 2023-11-22 22:26:59 发布
阅读量912 收藏 4
点赞数 1
分类专栏： 单链表-c语言 括号匹配-c++ 数据结构与算法 文章标签： 数据结构 单链表 struct 结构 数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40246263/article/details/78215244
版权

本文是以单链表为数据结构进行括号匹配。
我先大致的说一下我的思路：

首先及建立一个单链表的基础结构，

typedef int ElemType;//自定义数据类型
typedef enum { ERROR = 0, OK = 1 }Status;

typedef struct node {
    ElemType data;
    struct node* next;
}Node, *PtrNode;

typedef struct list {
    PtrNode head;
    int  cursize;
}List;

链表的初始化

Status InitList(List *plist)
{
    if (plist == NULL) return(ERROR);

    plist->head = BuyNode();
    plist->cursize = 0;
    return(OK);
}

清除链表数据

//清除链表数据，使头结点->next=NULL;
Status ClearList(List *plist)
{
    if (plist == NULL) return(ERROR);

    while (plist->head->next != NULL)
    {
        PtrNode p = plist->head->next;
        plist->head->next = p->next;
        free(p);
    }
    return(OK);
}

从链表的头开始插入数据

//头插法添加数据；
Status Insert_head(List *plist, ElemType x)
{
    if (plist == NULL) return(ERROR);

    PtrNode s = BuyNode();
    s->next = plist->head->next;
    plist->head->next = s;
    s->data = x;
    plist->cursize += 1;

    return(OK);
}

从链表的尾部插入数据

//尾插法添加数据；
Status Insert_tail(List *plist, ElemType x)
{
    if (plist == NULL) return(ERROR);

    PtrNode s = BuyNode();
    PtrNode p = plist->head;
    while (p->next != NULL)
    {
        p = p->next;
    }

    p->next = s;
    s->data = x;
    plist->cursize += 1;
    return(OK);
}

输出链表中的数据（在这里我写了两个输出函数（这个主要是为了显示提示信息的））

void Visit(List *ls)
{
    printf("ouput List:");
    PtrNode p = ls->head->next;
    while (p != NULL)
    {
        printf("- %c", p->data);
        p = p->next;
    }

    printf("\noutput list end \n");
}

主体部分大致就是这些，具体的思路与做法：将读到的括号字符按顺序先存在(char *str) str变量中，通过strlen(str)获取str中存储的字符的个数（strlen是库函数在string.h头文件中）然后在以相同的顺序放入链表中，因为在这里我是采用的头插法存储数据所以是将str中的字符倒序存储（保证链表中括号的先后顺序与字符串str中一致），然后通过test函数进行匹配（test是我定义的函数）。

test实现方法：
以s=list->head(头结点)作为初始节点，让s的next->data数据节点与next->next->data进行匹配，匹配成功就将这两个节点删除，返回到初始节点，再进行匹配，如果这两个数据节点的括号不匹配就让 s = s->next;再循环执行让s的next->data数据节点与next->next->data进行匹配，直到s->next->next == NULL结束；如果s->next！= NULL，s->next->next==NULL；就说要么个数不匹配要么括号自身杂乱而不匹配，

void test(List * ls)
{
    printf("testing......\n\
           \r-----------------------------------------\n\
           \r                Test Results             \n\
           \r-----------------------------------------\n");
    int tag = 1;
    while(tag == 1)
    {
        PtrNode s = ls->head;
        if (s->next == NULL) {

            printf("\n****  1.sockets match  ****\n");
            break;
        }
        if (s->next->next == NULL)
        {
            printf("\n****  number not sockets match  ****\n");
            break;
        }
        while (s->next->next != NULL)
        {

            //if (s->next->data == 0x7B)
            if (s->next->data == '{')
            {
                PtrNode p = s->next;
                //if (s->next->next->data == 0x7D)
                 if (s->next->next->data == '}')
                {
                    PtrNode q = s->next->next;
                    s->next = s->next->next->next;
                    ls->cursize -= 2;
                    free(q);
                    q = NULL;
                    free(p);
                    p = NULL;
                    break;
                }
                else
                {
                    s = s->next;
                    continue;
                }
            }

            //else if (s->next->data == 0x28)
            else if (s->next->data == '[')
            {
                PtrNode  p = s->next;

                //if (s->next->next->data == 0x29)
                if (s->next->next->data == ']')
                {
                    PtrNode q = s->next->next;
                    s->next = s->next->next->next;
                    ls->cursize -= 2;
                    free(q);
                    q = NULL;
                    free(p);
                    p = NULL;
                    break;
                }
                else 
                {
                    s = s->next;
                    continue;
                }
            }

            //else if (s->next->data == 0x5B)
            else if (s->next->data == '(')
            {
                PtrNode  p = s->next;

                //if (s->next->next->data == 0x5D)
                if (s->next->next->data == ')')
                {
                    PtrNode q = s->next->next;
                    s->next = s->next->next->next;
                    ls->cursize -= 2;
                    free(q);
                    q = NULL;
                    free(p);
                    p = NULL;
                    break;
                }
                else
                {
                    s = s->next;
                }
            }

            //else if(s->next != NULL){
                //tag = 0;
                //printf("\n----  list data error   ----\n");
                //break;
            //}

            else
            {
                tag = 0;
                printf("socket match error\n");
                break;
            }
        }



    }
    printf("\ntest end\n");
}

下面就是完整的代码（括号匹配——单链表，代码拷贝后可以直接运行）
（对代码有疑问或代码实现如果有错误可以私信或留言，谢谢采纳）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
typedef int ElemType;//自定义数据类型
typedef enum { ERROR = 0, OK = 1 }Status;

typedef struct node {
    ElemType data;
    struct node* next;
}Node, *PtrNode;

typedef struct list {
    PtrNode head;
    int  cursize;
}List;

PtrNode BuyNode()
{
    PtrNode s = (PtrNode)malloc(sizeof(Node));

    if (s == NULL)exit(-1);
    memset(s, 0, sizeof(Node));/* 首次给这片空间赋值，相当于初始化*/
    s->next = NULL;
    return s;
}
/*初始化一个单链表，具有头指针，头结点，头结点->next=NULL;*/
Status InitList(List *plist)
{
    if (plist == NULL) return(ERROR);

    plist->head = BuyNode();
    plist->cursize = 0;
    return(OK);
}


//清除链表数据，使头结点->next=NULL;
Status ClearList(List *plist)
{
    if (plist == NULL) return(ERROR);

    while (plist->head->next != NULL)
    {
        PtrNode p = plist->head->next;
        plist->head->next = p->next;
        free(p);
    }
    return(OK);
}

Status DestroyList(List *plist)
{
    if (plist == NULL) return(ERROR);

    ClearList(plist);
    free(plist->head);
    plist->head = NULL;
    return(OK);
}

//头插法添加数据；
Status Insert_head(List *plist, ElemType x)
{
    if (plist == NULL) return(ERROR);

    PtrNode s = BuyNode();
    s->next = plist->head->next;
    plist->head->next = s;
    s->data = x;
    plist->cursize += 1;

    return(OK);
}

//尾插法添加数据；
Status Insert_tail(List *plist, ElemType x)
{
    if (plist == NULL) return(ERROR);

    PtrNode s = BuyNode();
    PtrNode p = plist->head;
    while (p->next != NULL)
    {
        p = p->next;
    }

    p->next = s;
    s->data = x;
    plist->cursize += 1;
    return(OK);
}

int getlength(List *plist)//获取单链表的长度；
{
    if (plist == NULL)
    {
        system("color 09");
        printf("getlength failed: 链表被摧毁或不存在\n");
        exit(0);
    }

    return(plist->cursize);
}

Status printList(List *plist)//打印整个链表；
{
    if (plist == NULL) return(ERROR);

    PtrNode p = plist->head->next;
    while (p != NULL)
    {
        printf("%d\n", p->data);
        p = p->next;
    }
    return(OK);
}

//获取链表中第i个位置处节点的数据元素；
ElemType getElem(List *plist, int i)
{
    if (plist == NULL) return(ERROR);

    PtrNode p = plist->head->next; //指向第一个有数据的节点
    int val = 1;
    for (; val < i; val++)
    {
        p = p->next;// val=1 p指向第二个。当val=i-1 p指向第i个数据节点
    }
    return(p->data);
}

//删除第一个数据
Status Del_head(List *plist)
{
    if (plist == NULL) return(ERROR);

    PtrNode p = plist->head->next;
    plist->head->next = plist->head->next->next;

    free(p);
    p = NULL;
    return(OK);
}
void test(List * ls)
{
    printf("testing......\n\
           \r-----------------------------------------\n\
           \r                Test Results             \n\
           \r-----------------------------------------\n");
    int tag = 1;
    while(tag == 1)
    {
        PtrNode s = ls->head;
        if (s->next == NULL) {

            printf("\n****  1.sockets match  ****\n");
            break;
        }
        else if (s->next->next == NULL)
        {
            printf("\n****  number not sockets match  ****\n");
            break;
        }
        while (s->next->next != NULL)
        {

            //if (s->next->data == 0x7B)
            if (s->next->data == '{')
            {
                PtrNode p = s->next;
                //if (s->next->next->data == 0x7D)
                 if (s->next->next->data == '}')
                {
                    PtrNode q = s->next->next;
                    s->next = s->next->next->next;
                    ls->cursize -= 2;
                    free(q);
                    q = NULL;
                    free(p);
                    p = NULL;
                    break;
                }
                else
                {
                    s = s->next;
                    continue;
                }
            }

            //else if (s->next->data == 0x28)
            else if (s->next->data == '[')
            {
                PtrNode  p = s->next;

                //if (s->next->next->data == 0x29)
                if (s->next->next->data == ']')
                {
                    PtrNode q = s->next->next;
                    s->next = s->next->next->next;
                    ls->cursize -= 2;
                    free(q);
                    q = NULL;
                    free(p);
                    p = NULL;
                    break;
                }
                else 
                {
                    s = s->next;
                    continue;
                }
            }

            //else if (s->next->data == 0x5B)
            else if (s->next->data == '(')
            {
                PtrNode  p = s->next;

                //if (s->next->next->data == 0x5D)
                if (s->next->next->data == ')')
                {
                    PtrNode q = s->next->next;
                    s->next = s->next->next->next;
                    ls->cursize -= 2;
                    free(q);
                    q = NULL;
                    free(p);
                    p = NULL;
                    break;
                }
                else
                {
                    s = s->next;
                }
            }

            //else if(s->next != NULL){
                //tag = 0;
                //printf("\n----  list data error   ----\n");
                //break;
            //}

            else
            {
                tag = 0;
                printf("socket match error\n");
                break;
            }
        }



    }
    printf("\ntest end\n");
}
/*将str中的字符依次存入链表中*/
void ckeck(char *str, int n, List *xl)
{
    int  i = n-1;
    for (; i>=0; i--)
    {
        Insert_head(xl, str[i]);
    }


}

void Visit(List *ls)
{
    printf("ouput List:");
    PtrNode p = ls->head->next;
    while (p != NULL)
    {
        printf("- %c", p->data);
        p = p->next;
    }

    printf("\noutput list end \n");
}

int main()
{
    List myls;
    InitList(&myls);
    char *str = "{}([])";
    int n = strlen(str);
    printf("n=%d\n", n);
    ckeck(str, n, &myls); 
    test(&myls);
    Visit(&myls);
    printf("\nPoint out:\n\
           \r          !Press any key to exit.....\n");
    getchar();
    //

    return 0;
}

（对代码有疑问或代码实现如果有错误可以私信或留言，联系方式：QQ：1145603081 或邮箱1145603081@qq.com谢谢采纳）

MARY_C
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构——单链表实验
06-15
熟悉单链表的定义，单链表的建立方法及相关基本操作，理解单链表的基本思想，能够根据实际情况选择合适的存储结构。 2.实验内容 1、利用头插法或尾插法建立单链表 2、对已建立的单链表实现插入、删除等基本操作； 3...
运用单链表实现链栈，并实现括号匹配---作业
行走江湖的少侠哥
03-19 763
#include #include #include typedef struct Node { int data; struct Node* pNext; }NODE,*PNODE; typedef struct Stack { PNODE pTop; PNODE pBottom; }STACK,*PSTACK; void init(PSTACK); void push(PS
【数据结构】链表实现括号匹配
weixin_34453968的博客
11-07 997
#pragma once//LinkStack.h #include using namespace std; typedef char DataType; typedef struct node { DataType data; struct node *next; }LStackNode, *LinkStack; void InitStack(LinkStac
数据结构--c++实现括号匹配
qq_45853229的博客
05-11 2733
基本算法 输入一串括号字符串，从左往右扫描，若遇到左括号则入栈，若遇到右括号则从栈顶出栈一个括号(肯定是左括号),然后与其匹配。 代码实现 #include<iostream> #include<string> using namespace std; const int MaxSize=10; struct Stack { char data[MaxSize]; int top; //栈顶指针 /* data */ }; bool init(Stack &
【数据结构--栈的应用--括号匹配】
qq_61719813的博客
05-11 3412
文章目录括号匹配前言例如算法思想栈的定义及其操作括号匹配核心代码完整代码运行测试 括号匹配 前言 括号匹配问题是较为经典的栈的应用了，在Leetcode和数据结构数组时常出现 例如 给定一个字符串，其包含( , ) ,{ , } , [ , ]以及数字，要求判断其括号是否匹配，即： 左括号必须用相同类型的右括号闭合 左括号必须以正确的顺序闭合 实例 1： 输入: "[2 + (1 - 3)] * 4" 输出：1 实例 2： 输入："( ) )" 输出：0 算法思想 当遇到 ‘(’ ，‘[’
数据结构6.1-栈的应用之括号匹配
m0_62035627的博客
05-09 1374
括号匹配是数据结构中比较常见的应用之一，其算法思路如下： ①顺序遍历给定test的每一个字符 ②对于除了括号之外的无关字符直接跳过 ③遇到开括号就压入栈 ④遇到闭括号就弹出当时的栈顶元素与之匹配 ⑤如果匹配成功则继续，如果不匹配则以失败结束 由于括号匹配大部分代码与栈的基础操作相同，下面只展示核心代码： 1.括号匹配 bool bracketMatching(char* paraString, int paraLength) { int i; // 第一步：通过压入‘#’到.
数据结构学习笔记——单链表
12-21
链表（linked list）是一种在物理上非连续，非顺序的数据结构，由若干节点（node）组成 单链表每一个节点又包含两部分，1是存放数据的变量data，2是存放指向下一个结点的指针next 双向链表每一个节点包含三部分，在...
单链表-C++数据结构之单链表实现.zip
最新发布
03-13
链表 单链表_C++数据结构之单链表实现
使用C++实现链表数据结构之单链表.zip
03-13
链表 使用C++实现链表数据结构之单链表
数据结构实验报告——单链表.docx
12-05
数据结构实验报告
用单链表实现判断括号是否匹配（小括号）
03-21
判断括号是否匹配的算法有很多，其中大多是采用栈来实现的，由于用栈实现在各种地方都能找到相应的资源，所以我决定用链表写了一个，只是玩玩。
数据结构（括号匹配与表达式计算）
weixin_60535956的博客
01-30 1906
详细解析括号匹配和表达式计算相关算法
数据结构 括号匹配
qq_74115825的博客
04-24 85
栈结构具有后进先出的特点。括号匹配问题描述：若表达式中包含三种括号：圆括号、方括号和花括号，它们可以相互嵌套。算法思想：检验算法中可设置一个栈，每读入一个括号，若是左括号，则直接进栈，等待相匹配的同类右括号；若读入的是右括号，且与当前栈顶左括号同类型，则二者匹配，将栈顶的左括号弹出，否则属于不合法情况。另外。如果输入序列已经读完，而栈中仍有等待匹配的左括号，或者读入一个右括号，而栈中已无等待匹配的同类型左括号，均属于不合法情况。当输入序列和栈同时变空的时候，说明所有括号完全匹配。
leetcode题目8：有效的括号（简单）
qq_43331595的博客
08-14 168
leetcode题目8 题目描述 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足： 1.左括号必须用相同类型的右括号闭合。 2.左括号必须以正确的顺序闭合。 3.注意空字符串可被认为是有效字符串。 示例 1: 输入: "()" 输出: true 示例 2: 输入: "()[]{}" 输出: true 示例 3: 输入: "(]...
数据结构 C 代码 3.2: 栈的应用 -- 括号匹配
m0_74366353的博客
04-24 97
【代码】数据结构 C 代码 3.2: 栈的应用 -- 括号匹配。
C++数据结构实现括号匹配代码。
u013155930的博客
11-22 412
C++数据结构的括号匹配问题。
数据结构C代码栈及括号匹配
qq_61582101的博客
05-10 1153
一、代码学习1、构建栈2、栈的初始化3、进栈4、出栈5、输出栈6、栈的应用---括号匹配7、总代码8、运行结果 1、构建栈 typedef struct CharStack { int top; int data[MAXSIZE]; }*CharStackPtr; 2、栈的初始化 //初始化 CharStackPtr initStack() { CharStackPtr newPtr = (CharStackPtr)malloc(sizeof(struct CharStack)); newPtr-
数据结构 括号匹配（C语言）
weixin_51867622的博客
10-12 1141
#include<stdio.h> #include<stdlib.h> #include <malloc.h> #define MAX 1001 //此程序采用顺序栈做法 typedef char ElementType; //新建一个栈结构 typedef struct stack{ ElementType a; struct stack *next; } List,*lp; //初始化栈 struct stack *create(); int Pus.
数据结构LeetCode（括号匹配等）一
weixin_51578598的博客
10-24 1729
在leetcode刷了点题，我觉得题解太杂而且我也是鶸，所以把我的思路po出来了 1.括号匹配（简单匹配） 力扣https://leetcode-cn.com/problems/valid-parentheses/思路其实非常简单，就是利用堆栈，每一次新的元素与上一次堆入栈中的元素进行匹配，如果匹配成功即弹出栈，最后栈空了说明就是全部括号匹配成功！ class Solution { public: bool isValid(string s) { int length=s..
 数据结构循环单链表
10-07
循环单链表是一种链表的变体，它与单向链表的区别在于尾节点的指针不是指向 null，而是指向链表的头节点。这样就形成了一个循环，最后一个节点指向第一个节点。 循环单链表的主要优点是可以方便地遍历整个链表。遍...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值