20. 有效的括号

20. 有效的括号

1、题目介绍

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

试题链接：https://leetcode-cn.com/problems/valid-parentheses/

2、使用java语言进行解答

2.1、暴力做法—无限替换

    public static boolean isValid(String s) {
        String out;
        while (true) {
            out = s;
            s = s.replace("()","");
            s = s.replace("{}","");
            s = s.replace("[]","");
            if(s.isEmpty()) {
                return true;
            }
            if(s.equals(out)) {
                return false;
            }
        }
    }

算法效果：

可以看出，暴力替换的算法在时间和空间上都是效率较低的。

2.2、使用栈

    public static boolean isValid(String s) {
        Stack stack = new Stack();
        char[] arr = s.toCharArray();
        for(int i = 0;i < arr.length;i++) {
            if(arr[i] == '(' || arr[i] == '[' || arr[i] == '{') {
                stack.push(arr[i]);
                continue;
            }
            if(!stack.isEmpty()) {
                if((arr[i] == ')' && stack.peek() == '(') ||
                        (arr[i] == ']' && stack.peek() == '[') ||
                        (arr[i] == '}' && stack.peek() == '{')
                ) {
                    stack.pop();
                }else {
                    return false;
                }
            }else {
                return false;
            }
        }

        if(stack.isEmpty()){
            return true;
        }else {
            return false;
        }
    }

算法效果：

3、使用C语言来进行解答

//链表结点
typedef struct LinkNode {
    char data;
    struct LinkNode* next;
}LinkNode;

//栈结构体
typedef struct LinkList {
    LinkNode* head;
    int size;
}LinkStack;

//1，初始化函数
LinkStack* Init_LinkStack() {
    LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
    stack->size = 0;
    //头节点，不保存数据信息
    stack->head = (LinkNode*)malloc(sizeof(LinkNode));
    stack->head->data = '\0';
    stack->head->next = NULL;
    return stack;
}
//2，入栈
void Push_LinkStack(LinkStack* stack, char data) {
    LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
    newNode->data = data;
    newNode->next = stack->head->next;
    stack->head->next = newNode;
    stack->size++;
}
//3，出栈
char Pop_LinkStack(LinkStack* stack) {
    LinkNode* delNode = stack->head->next;
    stack->head->next = delNode->next;
    stack->size--;

    return delNode->data;
}
//4，返回栈顶元素的值
char Top_LinkStack(LinkStack* stack) {
    return stack->head->next->data;
}
//5，返回栈元素的个数
int Size_LinkStack(LinkStack* stack) {
    return stack->size;
}

int isValid(char * s){
    //获得一个栈
    LinkStack* stack = Init_LinkStack();
    //遍历字符串
    for(int i = 0;s[i] != '\0';i++) {
        if(s[i] == '(' || s[i] == '[' || s[i] == '{') {
            Push_LinkStack(stack,s[i]);
            continue;
        }

        if(Size_LinkStack(stack) != 0) {
            if((s[i] == ')' && Top_LinkStack(stack) == '(') ||
               (s[i] == ']' && Top_LinkStack(stack) == '[') ||
               (s[i] == '}' && Top_LinkStack(stack) == '{')
                    ) {
                Pop_LinkStack(stack);
            }else {
                return 0;
            }
        }else {
            return 0;
        }
    }

    if(Size_LinkStack(stack) == 0){
        return 1;
    }else {
        return 0;
    }
}

算法效果：