C语言- 基础数据结构和算法 - 08 栈的应用_就近匹配20220611

听黑马程序员教程《基础数据结构和算法 (C版本)》，

照着老师所讲抄的，

视频地址https://www.bilibili.com/video/BV1vE411f7Jh?p=1

喜欢的朋友可以去看看，欢迎大家一起交流学习。

/*
    检测括号成对匹配。
    对字符串中实现符号成对检测。
    算法思路：
    从第一个字符串开始扫描，
    当遇到普通字符时忽略，
    当遇到左括号时入栈内，

*/

08 栈的应用_就近匹配20220611_main.c

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <string.h>
 4
 5 #include "LinkStack.c"
 6
 7 /*
 8     检测括号成对匹配。
 9     对字符串中实现符号成对检测。
10     算法思路：
11     从第一个字符串开始扫描，
12     当遇到普通字符时忽略，
13     当遇到左括号时入栈内，
14
15 */
16
17 typedef struct MYCHAR{
18     LinkNode* node;
19     char* pAddres;        // 放字符地址，因为每个字符都有一个地址。
20     int index;            // 记录位置
21 }MyChar;
22
23 int IsLeft(char c){
24     return c == '(';
25 }
26 int IsRight(char c){
27     return c == ')';
28 }
29
30 MyChar* CreateMyChar(char* p,int index){
31     MyChar* mychar = (MyChar*)malloc(sizeof(MyChar));
32     mychar->pAddres = p;
33     mychar->index = index;
34     return mychar;
35 }
36
37 void ShowError(char* str,int pos){
38     printf("%s\n",str);
39     int i;
40     for(i=0;i<pos;i++){
41         printf(" ");
42     }
43     printf("^");
44 }
45
46 int main(){
47     printf("好好学习，天天向上~!\t\t\t 08 栈的应用_就近匹配20220611\n\n\n");
48
49
50     char* str = "1+6+8(dfddf)fdeer)((kdk)";
51
52     // 创建栈容器
53     LinkStack* stack = Init_LinkStack();
54     // 遍历
55     int index = 0;
56     char* p = str;
57     while(*p !='\0'){
58
59         // 如果是左括号“（”，直接进栈
60         if(IsLeft(*p)){
61             Push_LinkStack(stack,(LinkNode*)CreateMyChar(p,index));
62         }
63         // 如果是右括号，从栈顶弹出元素，判断是不是左括号。
64         if(IsRight(*p)){
65             if(Size_LinkStack(stack)>0){
66                 MyChar* mychar = (MyChar*)Top_LinkStack(stack);
67                 if(IsLeft(*(mychar->pAddres))){
68                     Pop_LinkStack(stack);
69                     free(mychar);
70                 }
71
72             }else{
73                 ShowError(str,index);
74                 printf("右括号没有匹配的左括号：\n");
75                 break;
76             }
77
78         }
79         p++;
80         index++;
81
82     }
83
84     // 如果栈里不为空，则说明有不匹配的字符，打印出来
85     while(Size_LinkStack(stack)>0){
86         MyChar* mychar = (MyChar*)Top_LinkStack(stack);
87         ShowError(str,mychar->index);
88         printf("左括号没有匹配的右括号：\n");
89         Pop_LinkStack(stack);
90         free(mychar);
91     }
92
93
94     printf("\n\n");
95     system("pause");
96     return 0;
97 }

LinkStack.c

 1 #include "LinkStack.h"
 2
 3
 4 // 初始化
 5 LinkStack* Init_LinkStack(){
 6
 7     // 开内存
 8      LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
 9      // 初始化
10      stack->HeadNode.next = NULL;
11      stack->size = 0;
12
13     return stack;
14 }
15
16 // 入栈
17 void Push_LinkStack(LinkStack* stack,LinkNode* data){
18
19     if(stack == NULL){
20         return;
21     }
22     if(data == NULL){
23         return;
24     }
25
26     data->next = stack->HeadNode.next;
27     stack->HeadNode.next = data;
28
29     stack->size++;
30
31 }
32
33 // 出栈 (删除第一个元素）
34 void Pop_LinkStack(LinkStack* stack){
35
36     if(stack == NULL){
37         return ;
38     }
39     if(stack->size==0){
40         return ;
41     }
42
43     // 第一个有效节点
44     LinkNode* pNext =  stack->HeadNode.next;
45     stack->HeadNode.next = pNext->next;    // pNext.next为第一个有效节点的下一个节点
46
47     stack->size--;
48
49 }
50
51 // 返回栈顶元素
52 LinkNode* Top_LinkStack(LinkStack* stack){
53
54     if(stack == NULL){
55         return NULL;
56     }
57     if(stack->size==0){
58         return NULL;
59     }
60
61     return stack->HeadNode.next;
62 }
63
64 // 返回栈元素的个数
65 int Size_LinkStack(LinkStack* stack){
66     if(stack == NULL){
67         return -1;
68     }
69     return stack->size;
70 }
71
72 // 清空栈
73 void Clear_LinkStack(LinkStack* stack){
74
75     if(stack == NULL){
76         return;
77     }
78     stack->HeadNode.next = NULL;
79     stack->size=0;
80
81 }
82
83 // 销毁栈
84 void FreeSpace_LinkStack(LinkStack* stack){
85
86     if(stack == NULL){
87         return;
88     }
89
90     free(stack);
91
92
93 }

LinkStack.h

 1 #ifndef LINKSTACK_H
 2 #define LINKSTACK_H
 3
 4 #include <stdio.h>
 5 #include <stdlib.h>
 6
 7
 8 // 链式栈的节点
 9 typedef struct LINKNODE{
10     struct LINKNODE* next;
11 }LinkNode;
12
13 // 链式栈
14
15 typedef struct LINKSTACK{
16     LinkNode HeadNode;    //头节点
17     int size;
18 }LinkStack;
19
20 // 初始化
21 LinkStack* Init_LinkStack();
22 // 入栈
23 void Push_LinkStack(LinkStack* stack,LinkNode* data);
24 // 出栈 (删除第一个元素）
25 void Pop_LinkStack(LinkStack* stack);
26 // 返回栈顶元素
27 LinkNode* Top_LinkStack(LinkStack* stack);
28 // 返回栈元素的个数
29 int Size_LinkStack(LinkStack* stack);
30 // 清空栈
31 void Clear_LinkStack(LinkStack* stack);
32 // 销毁栈
33 void FreeSpace_LinkStack(LinkStack* stack);
34
35
36
37 #endif