LeetCode笔记

1. KMP算法：LeetCode 686

public int KMP(String text, String pattern) {
    int[] next = calcNext(pattern);
    int i = 0, j = 0;
    
    while (i < text.length() && j < pattern.length()) {
        if (j == -1 || text.charAt(i) == pattern.charAt(j)) {
            i++;
            j++;
        }
        else
            j = next[j];
    }
    
    if (j == pattern.length())
        return i - j;
    else
        return -1;
}

public int[] calcNext(String pattern) {
    int[] next = new int[pattern.length()];
    int k = -1, j = 0;
    next[0] = -1;
    
    while (j < pattern.length() - 1) {
        if (k == -1 || pattern.charAt(k) == pattern.charAt(j)) {
        	// v1
        	// next[++j] = ++k;
        	// v2
            k++;
            j++;
            if (pattern.charAt(k) != pattern.charAt(j))
                next[j] = k;
            else
                next[j] = next[k];
        }
        else {
            k = next[k];
        }
    }
    
    return next;
}

2. 二叉树遍历

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

2.1 中序遍历：LeetCode 94

2.1.1 递归

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        traverse(root, res);
        return res;
    }

    void traverse(TreeNode* root, vector<int>& res) {
        if (!root) return;
        traverse(root->left, res);
        res.push_back(root->val);
        traverse(root->right, res);
    }
};

2.1.2 迭代

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        
        stack<TreeNode*> st;
        TreeNode* curr = root;

        while (curr || !st.empty()) {
            while (curr) {
                st.push(curr);
                curr = curr->left;
            }
            curr = st.top();
            st.pop();
            res.push_back(curr->val);
            curr = curr->right;
        }

        return res;
    }
};

2.2 前序遍历：LeetCode 144

2.2.1 递归

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        traverse(root, res);
        return res;
    }

    void traverse(TreeNode* root, vector<int>& res) {
        if (!root) return;
        res.push_back(root->val);
        traverse(root->left, res);
        traverse(root->right, res);
    }
};

2.2.2 迭代

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if (!root) return res;

        stack<TreeNode*> st;
        st.push(root);

        while (!st.empty()) {
            TreeNode* curr = st.top();
            st.pop();
            res.push_back(curr->val);
            if (curr->right) st.push(curr->right);
            if (curr->left) st.push(curr->left);
        }

        return res;
    }
};

2.3 后序遍历：LeetCode 145

2.3.1 递归

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        traverse(root, res);
        return res;
    }

    void traverse(TreeNode* root, vector<int>& res) {
        if (!root) return;
        traverse(root->left, res);
        traverse(root->right, res);
        res.push_back(root->val);
    }
};

2.3.2 迭代

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if (!root) return res;
        
        stack<TreeNode*> st;
        st.push(root);

        while (!st.empty()) {
            TreeNode* curr = st.top();
            st.pop();
            // res.insert(res.begin(), curr->val);
            res.push_back(curr->val);
            if (curr->left) st.push(curr->left);
            if (curr->right) st.push(curr->right);
        }

        swapList(res);
        return res;
    }

    void swapList(vector<int>& v) {
        int left = 0, right = v.size() - 1;
        while (left < right) swap(v[left++], v[right--]);
    }
};