学習目標:
スタックについて学びましょう。一見したところ、スタックは非常に奇妙です。なぜシーケンス テーブルよりも単純な構造を作成したいのでしょうか?その応用例をいくつか知った後でのみ、スタックの威力を理解することができます。
学習ガイド:ファンシェンのコード
学習課題:
- コードをコピーする
学習成果カタログ
コードの説明:
1. 空のスタックとして初期化します。top はスタックの先頭要素を指すので、その初期値は − 1 -1−1 です。 2.
プッシュするときは、最初に top を変更してから要素を配置する必要があります。3
.ポップする場合は、最初のトップを変更して戻る必要があります。
勉強の時間：
2022.5.10
1 構造を定義する
/**
* 创建栈的结构体
*/
typedef struct CharStack {
int top;
int data[STACK_MAX_SIZE];
} *CharStackPtr,CharStack;2 操作方法
2.1 印刷スタック
/**
* @brief 打印栈
*
* @param paraStack
*/
void outputStack(CharStackPtr paraStack) {
printf("栈内元素有:");
for (int i = 0; i <= paraStack->top; i++) {
printf("%c ", paraStack->data[i]);
}
printf("\n");
}2.2 スタックの初期化
/**
* @brief 初始化栈
*
* @return 头节点
*/
CharStackPtr charStackInit() {
CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(CharStack));
resultPtr->top = -1;
return resultPtr;
}2.3 押付け操作
/**
* @brief 入栈操作
*
* @param paraStackPtr
* @param paraValue
*/
void push(CharStackPtr paraStackPtr, int paraValue) {
//1检查栈内是否还有空间
if (paraStackPtr->top >= STACK_MAX_SIZE - 1) {
printf("栈满，无法继续添加元素\n");
return;
}
//2移动栈顶
paraStackPtr->top++;
//3添加元素进栈
paraStackPtr->data[paraStackPtr->top] = paraValue;
}2.4 ポップ操作
/**
* @brief 出栈操作
*
* @param paraStackPtr
*
* @return 出栈元素
*/
char pop(CharStackPtr paraStackPtr) {
//1检查栈内是否有元素
if (paraStackPtr->top < 0) {
printf("栈空，无法取出元素\n");
return '\0';
}
//2移动栈顶
paraStackPtr->top--;
//3添加元素
return paraStackPtr->data[paraStackPtr->top + 1];
}3つのテスト
3.1 テストクラス
/**
* @brief 测试类
*/
void pushPopTest() {
printf("---- pushPopTest 测试开始 ----\n");
CharStackPtr tempStack = charStackInit();
printf("初始化后栈是: \n");
outputStack(tempStack);
char ch;
for (ch = 'a'; ch < 'm'; ch ++) {
printf("元素%c 入栈.\n", ch);
push(tempStack, ch);
outputStack(tempStack);
}
for (int i = 0; i < 3; i ++) {
ch = pop(tempStack);
printf("元素 %c出栈.\n", ch);
outputStack(tempStack);
}
printf("---- pushPopTest 测试结束 ----\n");
}3.2 試験結果
---- pushPopTest 测试开始 ----
初始化后栈是:
栈内元素有:
元素a 入栈.
栈内元素有:a
元素b 入栈.
栈内元素有:a b
元素c 入栈.
栈内元素有:a b c
元素d 入栈.
栈内元素有:a b c d
元素e 入栈.
栈内元素有:a b c d e
元素f 入栈.
栈内元素有:a b c d e f
元素g 入栈.
栈内元素有:a b c d e f g
元素h 入栈.
栈内元素有:a b c d e f g h
元素i 入栈.
栈内元素有:a b c d e f g h i
元素j 入栈.
栈内元素有:a b c d e f g h i j
元素k 入栈.
栈满，无法继续添加元素
栈内元素有:a b c d e f g h i j
元素l 入栈.
栈满，无法继续添加元素
栈内元素有:a b c d e f g h i j
元素 j出栈.
栈内元素有:a b c d e f g h i
元素 i出栈.
栈内元素有:a b c d e f g h
元素 h出栈.
栈内元素有:a b c d e f g
---- pushPopTest 测试结束 ----
--------------------------------
Process exited after 0.0472 seconds with return value 31
Press ANY key to continue...
4つのすべてのコード
#include <stdio.h>
#include <malloc.h>
#define STACK_MAX_SIZE 10
/**
* 创建栈的结构体
*/
typedef struct CharStack {
int top;
int data[STACK_MAX_SIZE];
} *CharStackPtr,CharStack;
/**
* @brief 打印栈
*
* @param paraStack
*/
void outputStack(CharStackPtr paraStack) {
printf("栈内元素有:");
for (int i = 0; i <= paraStack->top; i++) {
printf("%c ", paraStack->data[i]);
}
printf("\n");
}
/**
* @brief 初始化栈
*
* @return 头节点
*/
CharStackPtr charStackInit() {
CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(CharStack));
resultPtr->top = -1;
return resultPtr;
}
/**
* @brief 入栈操作
*
* @param paraStackPtr
* @param paraValue
*/
void push(CharStackPtr paraStackPtr, int paraValue) {
//1检查栈内是否还有空间
if (paraStackPtr->top >= STACK_MAX_SIZE - 1) {
printf("栈满，无法继续添加元素\n");
return;
}
//2移动栈顶
paraStackPtr->top++;
//3添加元素进栈
paraStackPtr->data[paraStackPtr->top] = paraValue;
}
/**
* @brief 出栈操作
*
* @param paraStackPtr
*
* @return 出栈元素
*/
char pop(CharStackPtr paraStackPtr) {
//1检查栈内是否有元素
if (paraStackPtr->top < 0) {
printf("栈空，无法取出元素\n");
return '\0';
}
//2移动栈顶
paraStackPtr->top--;
//3添加元素
return paraStackPtr->data[paraStackPtr->top + 1];
}
/**
* @brief 测试类
*/
void pushPopTest() {
printf("---- pushPopTest 测试开始 ----\n");
CharStackPtr tempStack = charStackInit();
printf("初始化后栈是: \n");
outputStack(tempStack);
char ch;
for (ch = 'a'; ch < 'm'; ch ++) {
printf("元素%c 入栈.\n", ch);
push(tempStack, ch);
outputStack(tempStack);
}
for (int i = 0; i < 3; i ++) {
ch = pop(tempStack);
printf("元素 %c出栈.\n", ch);
outputStack(tempStack);
}
printf("---- pushPopTest 测试结束 ----\n");
}
void main() {
pushPopTest();
}長い間失われていた5つのバグ
5.1 コンパイラがエラーを報告し、CharSrack を見つけることができませんでした
したがって、手動で構造に追加してもエラーは報告されません。
5.2 テストクラスのエラーレポート
教師の ch は最初の for で定義されているため、私のコンパイラは 2 番目の for で教師の ch を見つけることができないため、ch を外側で定義すると問題は解決します。
5.3、印刷結果に問題があります
書き込み後、印刷されたスタックが $$$ でいっぱいになったので、変更した 2 つの小さな点のバグかと思いましたが、よく考えてみると、その可能性は低いようです。
---- pushPopTest 测试开始 ----
初始化后链表是:
元素a 入栈.
$
元素b 入栈.
$ $
元素c 入栈.
$ $ $
元素d 入栈.
$ $ $ $
元素e 入栈.
$ $ $ $ $
元素f 入栈.
$ $ $ $ $ $
元素g 入栈.
$ $ $ $ $ $ $
元素h 入栈.
$ $ $ $ $ $ $ $
元素i 入栈.
$ $ $ $ $ $ $ $ $
元素j 入栈.
$ $ $ $ $ $ $ $ $ $
元素k 入栈.
栈满，无法继续添加元素
$ $ $ $ $ $ $ $ $ $
元素l 入栈.
栈满，无法继续添加元素
$ $ $ $ $ $ $ $ $ $
元素 j出栈.
$ $ $ $ $ $ $ $ $
元素 i出栈.
$ $ $ $ $ $ $ $
元素 h出栈.
$ $ $ $ $ $ $
---- pushPopTest 测试结束 ----
--------------------------------
Process exited after 0.03805 seconds with return value 31
Press ANY key to continue...$ が欲しすぎるのかもしれないので、印刷したいエラーを探しに行ったところ、このデータの後ろにある [i] が欠落していることがわかりました。追加するだけです。
6 2 つの練習問題
演習 1 スタックの適用 -- ブラケット マッチング
1 ブラケット一致判定動作
/**
* @brief 判断括号是否匹配
*
* @param paraLength
* @param paraString
*
* @return 是否匹配
*/
bool bracketMatching(char* paraString, int paraLength) {
//1通过在底部压入“#”来初始化栈。
CharStackPtr tempStack = charStackInit();
push(tempStack, '#');
char tempChar, tempPopedChar;
//2操作paraString进行括号匹配
for (int i = 0; i < paraLength; i++) {
tempChar = paraString[i];
//前括号入栈，后括号判断前括号并出栈
switch (tempChar) {
//前括号入栈
case '(':
push(tempStack, tempChar);
break;
case '[':
push(tempStack, tempChar);
break;
case '{':
push(tempStack, tempChar);
break;
//后括号判断是否与前括号匹配，并出栈
case ')':
tempPopedChar = pop(tempStack);
if (tempPopedChar != '(') {
return false;
}
break;
case ']':
tempPopedChar = pop(tempStack);
if (tempPopedChar != '[') {
return false;
}
break;
case '}':
tempPopedChar = pop(tempStack);
if (tempPopedChar != '{') {
return false;
}
break;
//非括号元素，不进行操作，返回继续操作下一个元素
default:
break;
}
}
tempPopedChar = pop(tempStack);
if (tempPopedChar != '#') {
return true;
}
return true;
}2 試験カテゴリーと試験結果
2.1 テストクラス
/**
* 单元测试
*/
void bracketMatchingTest() {
printf("---- bracketMatchingTest 测试开始 ----\n");
char *tempExpression = (char*)"[2 + (1 - 3)] * 4";
bool tempMatch = bracketMatching(tempExpression, 17);
printf("对于表达式 '%s' \n括号是否匹配? %d \n\n", tempExpression, tempMatch);
tempExpression = (char*)"( ) )";
tempMatch = bracketMatching(tempExpression, 6);
printf("对于表达式 '%s' \n括号是否匹配? %d \n\n", tempExpression, tempMatch);
tempExpression = (char*)"()()(())";
tempMatch = bracketMatching(tempExpression, 8);
printf("对于表达式 '%s' \n括号是否匹配? %d \n\n", tempExpression, tempMatch);
tempExpression = (char*)"({}[])";
tempMatch = bracketMatching(tempExpression, 6);
printf("对于表达式 '%s' \n括号是否匹配? %d \n\n", tempExpression, tempMatch);
tempExpression = (char*)")(";
tempMatch = bracketMatching(tempExpression, 2);
printf("对于表达式 '%s' \n括号是否匹配? %d \n\n", tempExpression, tempMatch);
printf("---- bracketMatchingTest 测试结束 ----\n");
}2.2 試験結果
---- bracketMatchingTest 测试开始 ----
对于表达式 '[2 + (1 - 3)] * 4'
括号是否匹配? 1
对于表达式 '( ) )'
括号是否匹配? 0
对于表达式 '()()(())'
括号是否匹配? 1
对于表达式 '({}[])'
括号是否匹配? 1
对于表达式 ')('
括号是否匹配? 0
---- bracketMatchingTest 测试结束 ----
--------------------------------
Process exited after 0.0348 seconds with return value 0
Press ANY key to continue...3 つの括弧はすべてのコードに一致します
#include <stdio.h>
#include <malloc.h>
#define STACK_MAX_SIZE 10
/**
* 创建栈的结构体
*/
typedef struct CharStack {
int top;
int data[STACK_MAX_SIZE];
} *CharStackPtr, CharStack;
/**
* @brief 打印栈
*
* @param paraStack
*/
void outputStack(CharStackPtr paraStack) {
printf("栈内元素有:");
for (int i = 0; i <= paraStack->top; i++) {
printf("%c ", paraStack->data[i]);
}
printf("\n");
}
/**
* @brief 初始化栈
*
* @return 头节点
*/
CharStackPtr charStackInit() {
CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(CharStack));
resultPtr->top = -1;
return resultPtr;
}
/**
* @brief 入栈操作
*
* @param paraStackPtr
* @param paraValue
*/
void push(CharStackPtr paraStackPtr, int paraValue) {
//1检查栈内是否还有空间
if (paraStackPtr->top >= STACK_MAX_SIZE - 1) {
printf("栈满，无法继续添加元素\n");
return;
}
//2移动栈顶
paraStackPtr->top++;
//3添加元素进栈
paraStackPtr->data[paraStackPtr->top] = paraValue;
}
/**
* @brief 出栈操作
*
* @param paraStackPtr
*
* @return 出栈元素
*/
char pop(CharStackPtr paraStackPtr) {
//1检查栈内是否有元素
if (paraStackPtr->top < 0) {
printf("栈空，无法取出元素\n");
return '\0';
}
//2移动栈顶
paraStackPtr->top--;
//3添加元素
return paraStackPtr->data[paraStackPtr->top + 1];
}
/**
* @brief 判断括号是否匹配
*
* @param paraLength
* @param paraString
*
* @return 是否匹配
*/
bool bracketMatching(char* paraString, int paraLength) {
//1通过在底部压入“#”来初始化栈。
CharStackPtr tempStack = charStackInit();
push(tempStack, '#');
char tempChar, tempPopedChar;
//2操作paraString进行括号匹配
for (int i = 0; i < paraLength; i++) {
tempChar = paraString[i];
//前括号入栈，后括号判断前括号并出栈
switch (tempChar) {
//前括号入栈
case '(':
push(tempStack, tempChar);
break;
case '[':
push(tempStack, tempChar);
break;
case '{':
push(tempStack, tempChar);
break;
//后括号判断是否与前括号匹配，并出栈
case ')':
tempPopedChar = pop(tempStack);
if (tempPopedChar != '(') {
return false;
}
break;
case ']':
tempPopedChar = pop(tempStack);
if (tempPopedChar != '[') {
return false;
}
break;
case '}':
tempPopedChar = pop(tempStack);
if (tempPopedChar != '{') {
return false;
}
break;
//非括号元素，不进行操作，返回继续操作下一个元素
default:
break;
}
}
tempPopedChar = pop(tempStack);
if (tempPopedChar != '#') {
return true;
}
return true;
}
/**
* 单元测试
*/
void bracketMatchingTest() {
printf("---- bracketMatchingTest 测试开始 ----\n");
char *tempExpression = (char*)"[2 + (1 - 3)] * 4";
bool tempMatch = bracketMatching(tempExpression, 17);
printf("对于表达式 '%s' \n括号是否匹配? %d \n\n", tempExpression, tempMatch);
tempExpression = (char*)"( ) )";
tempMatch = bracketMatching(tempExpression, 6);
printf("对于表达式 '%s' \n括号是否匹配? %d \n\n", tempExpression, tempMatch);
tempExpression = (char*)"()()(())";
tempMatch = bracketMatching(tempExpression, 8);
printf("对于表达式 '%s' \n括号是否匹配? %d \n\n", tempExpression, tempMatch);
tempExpression = (char*)"({}[])";
tempMatch = bracketMatching(tempExpression, 6);
printf("对于表达式 '%s' \n括号是否匹配? %d \n\n", tempExpression, tempMatch);
tempExpression = (char*)")(";
tempMatch = bracketMatching(tempExpression, 2);
printf("对于表达式 '%s' \n括号是否匹配? %d \n\n", tempExpression, tempMatch);
printf("---- bracketMatchingTest 测试结束 ----\n");
}
int main() {
bracketMatchingTest();
return 0;
}
4 教師プログラムが私のコンパイラで実行されるバグ:
大量のエラーレポートをコピーした後、cv は csdn にアクセスして確認しました。C++ の引用符の内容は const char* 型なので、型を変更するだけです。
演習 2 スタックの適用 -- 式の評価
1 つの完全なコード
#include <stdio.h>
#include <malloc.h>
#define STACK_MAX_SIZE 10
/**
* 创建栈的结构体
*/
typedef struct CharStack {
int top;
int data[STACK_MAX_SIZE];
} *CharStackPtr, CharStack;
/**
* @brief 打印栈
*
* @param paraStack
*/
void outputStack(CharStackPtr paraStack) {
for (int i = 0; i <= paraStack->top; i++) {
printf("%c ", paraStack->data[i]);
}
printf("\n");
}
/**
* @brief 初始化栈
*
* @return 头节点
*/
CharStackPtr charStackInit() {
CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(CharStack));
resultPtr->top = -1;
return resultPtr;
}
/**
* @brief 入栈操作
*
* @param paraStackPtr
* @param paraValue
*/
void push(CharStackPtr paraStackPtr, int paraValue) {
//1检查栈内是否还有空间
if (paraStackPtr->top >= STACK_MAX_SIZE - 1) {
printf("栈满，无法继续添加元素\n");
return;
}
//2移动栈顶
paraStackPtr->top++;
//3添加元素进栈
paraStackPtr->data[paraStackPtr->top] = paraValue;
}
/**
* @brief 出栈操作
*
* @param paraStackPtr
*
* @return 出栈元素
*/
char pop(CharStackPtr paraStackPtr) {
//1检查栈内是否有元素
if (paraStackPtr->top < 0) {
printf("栈空，无法取出元素\n");
return '\0';
}
//2移动栈顶
paraStackPtr->top--;
//3添加元素
return paraStackPtr->data[paraStackPtr->top + 1];
}
int isEmpty(CharStackPtr paraStackptr) {
if (paraStackptr->top != -1) {
return 1;
}
return 0;
}
char GetTop(CharStackPtr s) { //取栈顶元素，先判空
char x;
if (!isEmpty(s)) {
return 0;
} else
x = s->data[s->top];
return x;
}
int Judge(char top) { //用于判断字符ch是否是优先运算符
int x;
switch (top) {
case '(':
x = 0;
break;
case '+':
case '-':
x = 1;
break;
case '*':
case '/':
x = 2;
break;
case ')':
x = 3;
break;
}
return x;
}
double eval(double b, double a, char top) { //用于计算当前的值，并将该值返回
double c = 0;
switch (top) {
case '+':
c = b + a;
break;
case '-':
c = b - a;
break;
case '*':
c = b * a;
break;
case '/':
if (a == 0) {
printf("分母为零!\n");
return 0;
} else
c = b / a;
break;
default:
printf("输入的字符非法!\n");
break;
}
return c;
}
/**
* 单元测试
*/
void expressionEvaluationTest() {
char str[1000];
printf("请输入算术表达式(功能：+，-，*，/)\n");
scanf("%s", str);
CharStackPtr op = charStackInit(); //初始化操作符栈
CharStackPtr num = charStackInit(); //初始化操作数栈
int i, j; //i,j为循环变量，a,b接收从操作数栈中出栈的元素
double f; //接收将字符数转换为浮点数的值
double a = 0;
double b = 0;
double c = 0;
char d[1000]; //储存字符串中连续的‘数’
char top = 0; //接收从操作符栈中出栈的元素
for (i = 0; str[i]; i++) { //将字符串中的元素按顺序入到栈中
switch (str[i]) {
case '(':
case '+':
case '-':
/*先判断当前运算符与操作符栈栈顶元素的优先级，如果高于栈顶元素，则入栈；
小于栈顶元素，则从操作数栈中依次出两个数，并将操作符栈中栈顶元素出栈，
再将从操作数栈中出的两个数，按从操作符栈栈中出的运算符运算，
并将结果压入操作数栈中，再将当前的操作符压入操作符栈中。*/
if ((!isEmpty(op)) || (Judge(str[i]) > Judge(GetTop(op)))||(str[i]=='(')) {
push(op, str[i]);
} else {
a = pop(num); //接收从 操作数栈 中出栈的元素
b = pop(num); //接收从 操作数栈 中出栈的元素
top = pop(op);//接收从 操作符栈 中出栈的元素
c = eval(b, a, top);
push(num, c);
//将计算后的值压入 操作数栈 中
push(op, str[i]);
}
break;
case '*':
case '/':
if ((!isEmpty(op)) || (Judge(str[i]) > Judge(GetTop(op)))||(str[i]=='(')) {
//当操作符栈为空或者该操作符的优先级大于栈顶元素的优先级时入栈保存
push(op, str[i]);
} else {
a = pop(num);//接收从 操作数栈 中出栈的元素
b = pop(num);//接收从 操作数栈 中出栈的元素
top = pop(op);//接收从 操作符栈 中出栈的元素
c = eval(b, a, top);
push(num,c);
//将计算后的值压入 操作数栈 中
push(op,str[i]);
}
break;
case ')':
while (isEmpty(op)&&GetTop(op)!='(') { //当操作符栈不为空的时候执行
a = pop(num);//接收从操作数栈中出栈的元素
b = pop(num);//接收从操作数栈中出栈的元素
top = pop(op);//接收从操作符栈中出栈的元素
c = eval(b, a, top);
push(num, c);
//将计算后的值压入操作数栈中
break;
}
case '\0':
break;
default:
j = 0;
do {
d[j++] = str[i++];
}while (str[i] >= '0' && str[i] <= '9'); //可存入一个或多个数字字符
d[j] = NULL; //将输入的连续多个数字字符拼成了字符串
i--;
f = atof(d); //转为浮点数
push(num,f); //将转换后的数压入操作数栈中
break;
}
}
while (isEmpty(op)) { //当操作符栈不为空的时候执行
a = pop(num);//接收从操作数栈中出栈的元素
b = pop(num);//接收从操作数栈中出栈的元素
top = pop(op);//接收从操作符栈中出栈的元素
c = eval(b, a, top);
push(num, c);
//将计算后的值压入操作数栈中
}
printf("该表达式的计算结果为：") ;
int sum=pop(num);
printf("%d\n",sum);
}
int main(){
expressionEvaluationTest();
return 0;
}
テスト結果 (括弧が使用できない、128 を超える数値の計算に問題がある、壊れている)
请输入算术表达式(功能：+，-，*，/)
3*6+2*4-8+12-3*6
该表达式的计算结果为：12
--------------------------------
Process exited after 20.11 seconds with return value 0
Press ANY key to continue...式評価のアイデアを使用したリコウに関する古典的な質問:
解決策を読んだ後、Javaで書いたところ、以前はCで書かれていたことがわかりました。
class Solution {
public int evalRPN(String[] tokens) {
Deque<Integer> stack = new LinkedList<Integer>();
int n= tokens.length;
for (int i=0;i<n;i++){
String token = tokens[i];
if (isNum(token)){
stack.push(Integer.parseInt(token));
}else {
int num2=stack.pop();
int num1=stack.pop();
switch (token){
case "+":
stack.push(num1+num2);
break;
case "-":
stack.push(num1-num2);
break;
case "*":
stack.push(num1*num2);
break;
case "/":
stack.push(num1/num2);
break;
default:
break;
}
}
}
return stack.pop();
}
boolean isNum(String s){
return !Objects.equals(s, "+") && !Objects.equals(s, "-") && !Objects.equals(s, "*") && !Objects.equals(s, "/");
}
}