零 必读系列 1学习算法和刷题的思路指南

目录

 

数据结构存储方式

数据结构基本操作

框架

算法刷题指南

---

数据结构存储方式

• 顺序存储
• 链式存储

 

数据结构基本操作

遍历+访问：增删查改

框架

数组：

void traverse(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        // 迭代访问 arr[i]
    }
}

链表（迭代+递归）：

/* 基本的单链表节点 */
class ListNode {
    int val;
    ListNode next;
}

// 迭代
void traverse(ListNode head) {
    for (ListNode p = head; p != null; p = p.next) {
        // 访问 p.val
    }
}

// 递归
void traverse(ListNode head) {
    // 访问 head.val
    traverse(head.next);
}

二叉树遍历（递归）：

/* 基本的二叉树节点 */
class TreeNode {
    int val;
    TreeNode left, right;
}

void traverse(TreeNode root) {
    traverse(root.left);
    traverse(root.right);
}

二叉树可扩展为N叉树：

/* 基本的 N 叉树节点 */
class TreeNode {
    int val;
    TreeNode[] children;
}

void traverse(TreeNode root) {
    for (TreeNode child : root.children) {
        traverse(child);
    }
}

N叉树又可扩展为图，只需用个布尔数组visited标记遍历过的即可。

 

算法刷题指南

该作者建议先刷二叉树，容易培养框架思维。然后刷回溯、动态规划、分治等算法专题。

二叉树框架：

void traverse(TreeNode root) {
    // 前序遍历
    traverse(root.left);
    // 中序遍历
    traverse(root.right);
    // 后续遍历
}

套入题目，下面的举例可以以后再看，理解代码框架可以应用即可。

LeetCode 124，Hard，求二叉树最大路径和，主要代码：

int ans = INT_MIN;
int oneSideMax(TreeNode* root) {
    if (root == nullptr) {
        return 0;
    }
    
    int left = max(0, oneSideMax(root->left));
    int right = max(0, oneSideMax(root->right));
    // 后续遍历
    ans = max(ans, left + right + root->val);
    return max(left, right) + root->val;
}

LeetCode 105，Medium，根据前序遍历和中序遍历的结果还原二叉树，主要代码：

TreeNode buildTree(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd, Map<Integer, Integer> inMap) {
    if (prestart > preEnd || inStart > inEnd) {
        return null;
    }

    // 前序遍历
    TreeNode root = new TreeNode(preorder[prestart]);
    int inRoot = inMap.get(root.val);
    int numsLeft = inRoot - inStart;

    root.left = buildTree(preorder, preStart + 1, prestart + numsLeft,
        inorder, inStart, inRoot - 1, inMap);
    root.right = buildTree(preorder, prestart + numsLeft + 1, preEnd,
        inorder, inRoot + 1, inEnd, inMap);
    return root;
}

LeetCode 99，Hard，恢复一颗BST，主要代码：

void traverse(TreeNode* Node) {
    if (!node) {
        return;
    }

    traverse(node->left);
    // 中序遍历
    if (node->val < prev->val) {
        s = (s == NULL) ? prev : s;
        t = node;
    }
    prev = node;
    traverse(node->right);
}

• 凡是涉及递归的问题，都是树的问题。
• 回溯算法就是N叉树的前后序遍历问题。