数据结构学习笔记：栈

part 1：对一序列的主要操作是在序列的末尾插入元素和取出元素，有这类操作要求的序列称之为“堆栈”。堆栈可认为是具有一定约束的线性表，插入和删除操作都作用在栈顶这一端点位置。

由于堆栈是线性表，因而其栈的存储结构可以采用顺序和链式两种形式，分别成为顺序栈和链栈。

当TOP指向-1时，表示空栈；当TOP指向MAXSIZE-1时，表示满栈。

操作一：创建一个给定容量的空堆栈

Stack CreateStack( int MaxSize)
{
   Stack S = (Stack)malloc(sizeof(struct SNode));
   S->Data = (ElementTye * )malloc(Maxsize * sizeof(ElementTye));
   S->Top =-1;
   S->MaxSize =MxSize;
   return S;
}
   

操作二：压栈

void push(CharStackPtr paraStackPtr, int paraValue) {
    if (paraStackPtr->top >= 9) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->top ++;
    paraStackPtr->data[paraStackPtr->top] = paraValue;
}

 操作三：出栈

char pop(CharStackPtr paraStackPtr) {
    if (paraStackPtr->top < 0) {
        printf("Cannot pop element: stack empty.\n");
        return '\0';
    }
    
    paraStackPtr->top --;
    return paraStackPtr->data[paraStackPtr->top + 1];
}

 总代码：

#include<stdio.h>
#include<stdlib.h>
 
typedef struct CharStack{
    int top;
    
    char data[10];
} *CharStackPtr;
 
/**
 *输出
 */
 
void outputStack(CharStackPtr paraStack) {
    int i; 
    for (i = 0; i <= paraStack->top; i ++) {
        printf("%c ", paraStack->data[i]);
    }
    printf("\n");
} 
 
/**
 *初始化
 */
 
CharStackPtr charStackInit() {
    CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(struct CharStack));
    resultPtr->top = -1;
    
    return resultPtr;
}
 
/**
 *压栈
 */
 
void push(CharStackPtr paraStackPtr, int paraValue) {
    if (paraStackPtr->top >= 9) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->top ++;
    paraStackPtr->data[paraStackPtr->top] = paraValue;
}
 
/**
 *出栈
 */
 
char pop(CharStackPtr paraStackPtr) {
    if (paraStackPtr->top < 0) {
        printf("Cannot pop element: stack empty.\n");
        return '\0';
    }
    
    paraStackPtr->top --;
    return paraStackPtr->data[paraStackPtr->top + 1];
}
 
void pushPopTest() {
    char ch;
    int i;
    
    printf("---- pushPopTest begins. ----\n");
    
    CharStackPtr tempStack = charStackInit();
    printf("After initialization, the stack is: ");
    outputStack(tempStack);
    
    for (ch = 'a'; ch < 'm'; ch ++) {
        printf("Pushing %c.\n", ch);
        push(tempStack, ch);
        outputStack(tempStack);
    }
    
    for (i = 0; i < 3; i ++) {
        ch = pop(tempStack);
        printf("Pop %c.\n", ch);
        outputStack(tempStack);
    }
    
    printf("---- pushPopTest ends. ----\n");
}
 
 
int main() {
    pushPopTest();
    
    return 0;
}

part 2： 括号匹配

#include<stdio.h>
#include<stdlib.h>
 
typedef struct CharStack{
    int top;
    
    char data[10];
} *CharStackPtr;
 
/**
 *输出
 */
 
void outputStack(CharStackPtr paraStack) {
    int i; 
    for (i = 0; i <= paraStack->top; i ++) {
        printf("%c ", paraStack->data[i]);
    }
    printf("\n");
} 
 
/**
 *初始化
 */
 
CharStackPtr charStackInit() {
    CharStackPtr resultPtr = (CharStackPtr)malloc(sizeof(struct CharStack));
    resultPtr->top = -1;
    
    return resultPtr;
}
 
/**
 *压栈
 */
 
void push(CharStackPtr paraStackPtr, int paraValue) {
    if (paraStackPtr->top >= 9) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->top ++;
    paraStackPtr->data[paraStackPtr->top] = paraValue;
}
 
/**
 *出栈
 */
 
char pop(CharStackPtr paraStackPtr) {
    if (paraStackPtr->top < 0) {
        printf("Cannot pop element: stack empty.\n");
        return '\0';
    }
    
    paraStackPtr->top --;
    return paraStackPtr->data[paraStackPtr->top + 1];
}
 
int bracketMatching(char *paraString, int paraLength) {
    int i;
    
    CharStackPtr tempStack = charStackInit();
    push(tempStack, '#');
    char tempChar, tempPopedChar;
    
    for (i = 0; i < paraLength; i ++) {
        tempChar = paraString[i];
        
        switch(tempChar) {
            case '(':
            case '[':
            case '{':
                push(tempStack, tempChar);
                break;
            case ')':
                tempPopedChar = pop(tempStack);
                if (tempPopedChar != '(') {
                    return 0;
                }
                break;
            case ']':
                tempPopedChar = pop(tempStack);
                if (tempPopedChar != '[') {
                    return 0;
                }
                break;
            case '}':
                tempPopedChar = pop(tempStack);
                if (tempPopedChar != '{') {
                    return 0;
                }
                break;
            default:
                break;
        }
    }
    
    tempPopedChar = pop(tempStack);
    if (tempPopedChar != '#') {
        return 0;
    }
    
    return 1;
}
 
void bracketMatchingTest() {
    char *tempExpression = "[2 + (1 - 3)] * 4";
    int tempMatch = bracketMatching(tempExpression, 17);
    printf("Is the expression '%s' bracket matching? %d\n", tempExpression, tempMatch);
    
    tempExpression = "( )  )";
    tempMatch = bracketMatching(tempExpression, 6);
    printf("Is the expression '%s' bracket matching? %d\n", tempExpression, tempMatch);
    
    tempExpression = "()()(())";
    tempMatch = bracketMatching(tempExpression, 8);
    printf("Is the expression '%s' bracket matching? %d\n", tempExpression, tempMatch);
    
    tempExpression = "({}[])";
    tempMatch = bracketMatching(tempExpression, 6);
    printf("Is the expression '%s' bracket matching? %d\n", tempExpression, tempMatch);
    
    tempExpression = ")(";
    tempMatch = bracketMatching(tempExpression, 2);
    printf("Is the expression '%s' bracket matching? %d\n", tempExpression, tempMatch);
}
 
int main() {
    bracketMatchingTest();
    
    return 0;
}

part 3： 表达式求值

1.创建

typedef struct CharAndIntStack{
    int topInt;
    int topChar;
    
    int dataInt[100];
    char dataChar[100];
} *CharAndIntStackPtr;

2，压栈

void pushInt(CharAndIntStackPtr paraStackPtr, int paraValue) {
    if (paraStackPtr->topInt >= 99) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->topInt ++;
    
    paraStackPtr->dataInt[paraStackPtr->topInt] = paraValue;
}
 
void pushChar(CharAndIntStackPtr paraStackPtr, char paraValue) {
    if (paraStackPtr->topChar >= 99) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->topChar ++;
    
    paraStackPtr->dataChar[paraStackPtr->topChar] = paraValue; 
}

 3.出栈

int popInt(CharAndIntStackPtr paraStackPtr) {
    if (paraStackPtr->topInt < 0) {
        printf("Cannot pop element: stack empty.\n");
        return 0;
    }
    
    paraStackPtr->topInt --;
    
    return paraStackPtr->dataInt[paraStackPtr->topInt + 1];
}
 
char popChar(CharAndIntStackPtr paraStackPtr) {
    if (paraStackPtr->topChar < 0) {
        printf("Cannot pop element: stack empty.\n");
        return '\0';
    }
    
    paraStackPtr->topChar --;
    
    return paraStackPtr->dataChar[paraStackPtr->topChar + 1];
}

4.all codes

#include<stdio.h>
#include<stdlib.h>
 
typedef struct CharAndIntStack{
    int topInt;
    int topChar;
    
    int dataInt[100];
    char dataChar[100];
} *CharAndIntStackPtr;
 
/**
 *初始化
 */
  
CharAndIntStackPtr charandintStackInit() {
    CharAndIntStackPtr resultPtr = (CharAndIntStackPtr)malloc(sizeof(struct CharAndIntStack));
    
    resultPtr->topChar = -1;
    resultPtr->topInt = -1;
    
    return resultPtr;
}
 
/**
 *压栈
 */
 
void pushInt(CharAndIntStackPtr paraStackPtr, int paraValue) {
    if (paraStackPtr->topInt >= 99) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->topInt ++;
    
    paraStackPtr->dataInt[paraStackPtr->topInt] = paraValue;
}
 
void pushChar(CharAndIntStackPtr paraStackPtr, char paraValue) {
    if (paraStackPtr->topChar >= 99) {
        printf("Cannot push element: stack full.\n");
        return;
    }
    
    paraStackPtr->topChar ++;
    
    paraStackPtr->dataChar[paraStackPtr->topChar] = paraValue; 
}
 
/**
 *出栈
 */
 
int popInt(CharAndIntStackPtr paraStackPtr) {
    if (paraStackPtr->topInt < 0) {
        printf("Cannot pop element: stack empty.\n");
        return 0;
    }
    
    paraStackPtr->topInt --;
    
    return paraStackPtr->dataInt[paraStackPtr->topInt + 1];
}
 
char popChar(CharAndIntStackPtr paraStackPtr) {
    if (paraStackPtr->topChar < 0) {
        printf("Cannot pop element: stack empty.\n");
        return '\0';
    }
    
    paraStackPtr->topChar --;
    
    return paraStackPtr->dataChar[paraStackPtr->topChar + 1];
}
 
/**
 *优先级
 */
 
int Priority(char temp) {
    if (temp == '+' || temp == '-') {
        return 1;
    } else if (temp == '*' || temp == '/') {
        return 2;
    } else {
        return 0;
    }
} 
 
/**
 *判断数字
 */
  
int judgenumber(char temp) {
    if (temp >= '0' && temp <= '9') {
        return 1;
    } else {
        return 0;
    }
}
 
/**
 *计算
 */
 
void compute(CharAndIntStackPtr tempStack) {
    int b = popInt(tempStack);
    int a = popInt(tempStack);
    char c = popChar(tempStack);
    int x;
    if (c == '+') {
        x = a + b;
    } else if (c == '-') {
        x = a - b;
    } else if (c == '*') {
        x = a * b;
    } else {
        x = a / b;
    }
    pushInt(tempStack, x);
}
 
/**
 *判断符号剩余
 */
  
int judgeSize(CharAndIntStackPtr paraStackPtr) {
    if (paraStackPtr->topChar == -1) {
        return 0;
    }
    
    if (paraStackPtr->dataChar[paraStackPtr->topChar] != '\0') {
        return 1;
    } else {
        return 0;
    }
}
 
int main() {
    CharAndIntStackPtr tempStack = charandintStackInit();
    char test[100];
    gets(test);
    
    int testLength = 0, i;
    for (i = 0; test[i] != '\0'; i ++) {
        testLength ++;
    }
    
    for (i = 0; i < testLength; i ++) {
        char c = test[i];
        
        if (judgenumber(c) == 1) {
            int x = 0, j = i;
            while (j < testLength && judgenumber(test[j])) {
                x = x * 10 + test[j ++] - '0';
            }
            i = j - 1;
            pushInt(tempStack, x);
        } else if (c == '(') {
            pushChar(tempStack, c);
        } else if (c == ')') {
            while (tempStack->dataChar[tempStack->topChar] != '(') {
                compute(tempStack);
            }
            popChar(tempStack);
        } else {
            while (judgeSize(tempStack) == 1 && tempStack->dataChar[tempStack->topChar] != '(' && Priority(tempStack->dataChar[tempStack->topChar]) >= Priority(c)) {
                compute(tempStack);
            }
            pushChar(tempStack, c);
        }
    }
    
    while (judgeSize(tempStack) == 1) {
        compute(tempStack);
    }
    
    printf("%d", tempStack->dataInt[tempStack->topInt]);
    
    return 0;
}

 

内容小结

栈是一种操作受限的数据结构，只支持入栈和出栈操作。后进先出是它最大的特点。栈既可以通过数组实现，也可以通过链表来实现。不管基于数组还是链表，入栈、出栈的时间复杂度都为 O(1)