个人学习编程(3-26) leetcode刷题

翻转链表：

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

双指针： 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* prev = NULL;  // prev 用来存储前一个节点，初始化为 NULL（因为反转后的链表最后一个节点的 next 是 NULL）
    struct ListNode* curr = head;  // curr 是当前节点，初始化为链表的头节点

    // 遍历链表
    while(curr) {
        struct ListNode* next = curr->next;  // 暂存当前节点的下一个节点
        curr->next = prev;                   // 将当前节点的 next 指向前一个节点，反转链表
        prev = curr;                         // 将 prev 移动到当前节点（变成下一个节点的前一个节点）
        curr = next;                         // 将 curr 移动到下一个节点
    }

    return prev;  // prev 最终指向反转后的链表头节点
}

假设链表原本是 [1 -> 2 -> 3 -> 4 -> 5]，反转过程如下：

1. 初始时，prev = NULL，curr = 1。
2. 第一次迭代：
   • next = 2
   • curr->next = NULL（将 1 的 next 指向 NULL）
   • prev = 1，curr = 2
3. 第二次迭代：
   • next = 3
   • curr->next = 1（将 2 的 next 指向 1）
   • prev = 2，curr = 3
4. 以此类推，直到链表完全反转。

最终，返回的链表是 [5 -> 4 -> 3 -> 2 -> 1]。

 数组赋值：

只改变链表的值，通过赋值，不改变链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head) {
    if(head == NULL) return NULL;
    struct ListNode* cur = head;
    int arr[5000] = {0};
    int i = 0;
    while(cur){
        arr[i] = cur->val;
        i++;
        cur = cur -> next;
    }
    i--;
    cur = head;
    while(i >= 0 && cur != NULL){
        cur->val = arr[i];
        i--;
        cur = cur->next;
    }
    return head;
}

括号的匹配：

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

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
3. 每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = "()"

输出：true

示例 2：

输入：s = "()[]{}"

输出：true

示例 3：

输入：s = "(]"

输出：false

示例 4：

输入：s = "([])"

输出：true

C语言： 

bool isValid(char* s) {
    #define MAX_LENGTH 10000
    #define MAX_LENGTH 10000

    // 栈结构体定义
    typedef struct {
        char data[MAX_LENGTH];
        int top;
    } Stack;

    // 栈初始化
    void initStack(Stack* stack) {
        stack->top = -1;
    }

    // 判断栈是否为空
    bool isEmpty(Stack* stack) {
        return stack->top == -1;
    }

    // 向栈中压入元素
    void push(Stack* stack, char ch) {
        stack->data[++(stack->top)] = ch;
    }

    // 弹出栈顶元素
    char pop(Stack* stack) {
        if (!isEmpty(stack)) {
            return stack->data[(stack->top)--];
        }
        return '\0';  // 如果栈为空，返回空字符
    }
    Stack stack;
    initStack(&stack);

    // 遍历字符串中的每个字符
    for (int i = 0; s[i] != '\0'; i++) {
        char ch = s[i];

        // 如果是左括号，压入栈
        if (ch == '(' || ch == '{' || ch == '[') {
            push(&stack, ch);
        }
        // 如果是右括号，检查栈顶是否匹配
        else if (ch == ')' || ch == '}' || ch == ']') {
            if (isEmpty(&stack)) {
                return false;  // 栈为空，表示没有左括号匹配
            }
            char top = pop(&stack);
            if ((ch == ')' && top != '(') || 
                (ch == '}' && top != '{') || 
                (ch == ']' && top != '[')) {
                return false;  // 不匹配
            }
        }
    }

    // 最后检查栈是否为空，若为空，则括号匹配成功
    return isEmpty(&stack);
// ZZ
}

 C++：

#include <bits/stdc++.h>
#include <stack>
using namespace std;

int main() {
    char s[20] = "([]))";  // 初始化字符串 s，包含括号
    stack<char> st;  // 创建一个栈，用来存储未配对的括号
    int i = 0;  // 索引，用来遍历字符串

    while (s[i] != '\0')  // 遍历字符串
    {
        if (!st.empty())  // 如果栈不为空
        {
            char temp = st.top();  // 获取栈顶元素
            // 如果栈顶元素和当前字符配对，弹出栈顶元素
            if ((temp == '(' && s[i] == ')') || 
                (temp == '{' && s[i] == '}') || 
                (temp == '[' && s[i] == ']'))
            {
                st.pop();
            } 
            else {
                st.push(s[i]);  // 否则将当前字符压入栈
            }
        } 
        else {
            st.push(s[i]);  // 栈为空时，直接将当前字符压入栈
        }
        i++;  // 索引增加
    }

    // 如果栈为空，说明括号配对成功
    if (st.empty()) {
        printf("good\n");
    } else {
        printf("no\n");
    }

    return 0;
}