/* run this program using the console pauser or add your own getch, system("pause") or input loop */
// 用到的庫檔案
#include <stdio.h>  // printf();scanf()
#include <stdlib.h> // exit()
#include <malloc.h> // malloc()
#include <time.h>   // srand((unsigned)time(NULL));
// 函式結果狀態程式碼
#define TRUE    1
#define FALSE   0
#define OK      1
#define ERROR   0
#define INFEASIBLE  -1
#define OVERFLOW    -2
// Status是函式的型別，其值是函式結果狀態程式碼
typedef int Status;
// #define ElemType int  // 也可以用巨集定義確定ElemType型別
typedef char SElemType;
// -----棧的鏈式儲存結構-----
typedef struct SNode {
    SElemType data;                 // 資料域
    struct SNode *next;             // 指標域
} SNode, *LinkStack;

// 操作結果：構造一個空棧S。
Status InitStack(LinkStack &S) {
    S = (LinkStack)malloc(sizeof(SNode));
    if(!S)                          // 儲存分配失敗
        exit(OVERFLOW);             // exit(-2)程式異常退出
    S->next = NULL;
    S->data = NULL;
    return OK;
}// InitStack

// 操作結果：銷燬棧S，S不再存在。
Status DestroyStack(LinkStack &S) {
    LinkStack p = S->next, ptmp;    // p指向棧頂
    while(p) {                      // p指向棧底時，迴圈停止
        ptmp = p->next;
        free(p);                    // 釋放每個資料結點的指標域
        p = ptmp;
    }
    free(S);
    return OK;
}// DestroyStack

// 操作結果：把S置為空棧。
Status ClearStack(LinkStack &S) {
    LinkStack p = S->next, ptmp;    // p指向棧頂
    while(p) {                      // p指向棧底時，迴圈停止
        ptmp = p->next;
        free(p);                    // 釋放每個資料結點的指標域
        p = ptmp;
    }
    S->next = NULL;
    return OK;
}// ClearStack

// 操作結果：若S為空棧，返回TRUE，否則返回FALSE
Status StackEmpty(LinkStack S) {
    if(S->next == NULL)
        return TRUE;                // 返回1
    else
        return FALSE;               // 返回0
}// StackEmpty

// 操作結果：返回S的元素個數，即棧的長度。
int StackLength(LinkStack S) {
    int n = 0;
    LinkStack p = S->next;          // p指向棧頂
    while(p) {
        n++;
        p = p->next;
    }
    return n;
}// StackLength

// 操作結果：若棧不空，則用e返回S的棧頂元素，並返回OK；否則返回ERROR。
Status GetTop(LinkStack S, SElemType &e) {
    if ( S->next == NULL )
        return ERROR;               // 棧空
    e = S->next->data;              // 取棧頂元素
//  printf("獲取的棧頂元素：%d\n", e);
    return OK;
}// GetTop

// 操作結果：插入元素e為新的棧頂元素。
Status Push(LinkStack &S, SElemType e) {
    LinkStack p = (LinkStack)malloc(sizeof(SNode));
    p->next = S->next;              // 新結點指向棧頂
    p->data = e;
    S->next = p;                    // 更新棧頂指標
//  printf("插入的棧頂元素：%d\n", e);
    return OK;
}// Push

// 操作結果：若棧不空，則刪除S的棧頂元素，並用e返回其值；否則返回ERROR。
Status Pop(LinkStack &S, SElemType &e) {
    // 若1個元素也沒有：
    if (S->next == NULL)
        return ERROR;
    // 若有1個以上元素
    e = S->next->data;
    LinkStack ptmp = S->next->next;
    free(S->next);
    S->next = ptmp;
//  printf("刪除的棧頂元素：%d\n", e);
    return OK;
}// Pop

Status visit(SElemType e) {
    printf("%c -> ", e);
    return OK;
}
// 操作結果：從 棧底到棧頂 依次對棧中每個資料元素呼叫函式visit()。一旦vistit()失敗，剛操作失敗。
Status StackTraverse(LinkStack S, Status (*pfn_visit)(SElemType)) {
    if(S->next == NULL)
    {
        printf("棧為空!\n");
        return ERROR;
    }
    for(int i=StackLength(S); i>0; i--)
    {
        LinkStack p = S->next;      // p指向棧頂
        int j = 1;                  // j為計數器
        while ( p && j<i ) {        // 順指標向後查詢，直到p指向第i個元素或p為空
            p = p->next;
            ++j;
        }
        visit(p->data);
    }
    printf("\n");
    return OK;
}// StackTraverse_base_to_Top
// 操作結果：從 棧頂到棧底 依次對棧中每個資料元素呼叫函式visit()。一旦vistit()失敗，剛操作失敗。
Status StackTraverse_Top(LinkStack S, Status (*pfn_visit)(SElemType)) {
    if(S->next == NULL)
    {
        printf("棧為空!\n");
        return ERROR;
    }
    LinkStack p = S->next;          // p指向棧頂
    while(p) {
        visit(p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}// StackTraverse_Top_to_base

// 3.2.1 數制轉換
void conversion()
{   // 對於輸入的任意一個非負十進位制整數，列印輸出與其等值的八進位制數
    unsigned N = 0;                 // 非負整數
    SElemType e;

    LinkStack S = NULL;
    InitStack(S);                   // 初始化棧

    printf("將十進位制整數N轉換為8進位制數：", N);
    //scanf("%u", &N);
    N = 8;
    while(N)
    {
        Push(S, N % 8);             // 入棧
        N = N/8;
    }
    while(!StackEmpty(S))
    {
        Pop(S, e);                  // 出棧
        printf("%d ", e);
    }
    printf("\n");

    DestroyStack(S);                // 銷燬棧
}// conversion 演算法3.1

// 3.2.2 括號匹配的檢驗
void check()
{   // 檢驗表示式中括號<>、()、[]和{}是否配對
    SElemType e;
    int i = 0;

    LinkStack S;
    InitStack(S);


    const char* expression
        = "#include <stdio.h> int main() { int a[5][5]; int (*p)[4]; p = a[0]; printf(\"%d\\n\", &p[3][3] - &a[3][3]); return 0; }";
    //gets(expression);
    while (expression[i] != '\0')
    {
        switch (expression[i])
        {
        case '<':
        case '(':
        case '[':
        case '{':
            Push(S, expression[i]); // 當遇見左符號時壓入棧中
            break;
        case '>':
        case ')':
        case ']':
        case '}':
            if (!StackEmpty(S))     // 當遇見右符號時從棧中彈出棧頂符號 // 進行匹配
            {
                Pop(S, e);
                // 匹配成功：繼續讀入下一個字元   // 匹配失敗：立即停止，並報錯
                if ( !( e == '<' && expression[i] == '>' ||
                        e == '(' && expression[i] == ')' ||
                        e == '[' && expression[i] == ']' ||
                        e == '{' && expression[i] == '}' ) )
                {
                    printf("%c does not match!\n", expression[i]);
                    exit(ERROR);
                }
            }
            else
            {
                printf("%c does not match!\n", expression[i]);
                exit(ERROR);
            }
        default:                    // 當遇見普通字元時忽略
            break;
        }
        i++;
    }

    if (StackEmpty(S))              // 成功：所有字元掃描完畢，且棧為空
        printf("Succeed!\n");
    else                            // 失敗：匹配失敗或所有字元掃描完結但棧非空
        printf("Invalid code!\n");

    DestroyStack(S);
}

//3.2.3 行編輯程式
FILE *fp;
Status copy(SElemType e)    // 將字元e輸入至fp所指的檔案中
{
    fputc(e, fp);
    return OK;
}
void LineEdit()
{   printf("利用字元棧s，從終端接收一行並送至呼叫過程的資料區。\n");
    LinkStack S;
    InitStack(S);

    char ch = getchar();                // 從終端接收第一個字元
    while(ch != EOF)                    // EOF為全文結束符
    {
        while(ch != EOF && ch != '\n')
        {
            switch(ch)
            {
            case '#':
                if(!StackEmpty(S))
                    Pop(S, ch);         // 僅當棧非空時退棧
                break;
            case '@':
                ClearStack(S);          // 重置s為空棧
                break;
            default :
                Push(S, ch);            // 有效字元進棧，未考慮棧滿情形
                break;
            }
            ch = getchar();             // 從終端接收下一個字元
        }
        // 將從棧底到棧頂的棧內字元傳送至呼叫過程的資料區;
        StackTraverse(S, copy);
        fputc('\n', fp);                // 向檔案輸入一個換行符

        ClearStack(S);                  // 重置s為空棧

        if(ch != EOF)   ch = getchar();
    }

    DestroyStack(S);
}// LineEdit 演算法3.2
int main() {
    conversion();
    check();

    fp = fopen("test.txt", "w");
    if(fp)
    {
        LineEdit();
        fclose(fp);
    }
    else
        printf("建立檔案失敗!\n");

    return 0;
}