力扣刷题攻略链表篇-链表的遍历

文章内容是自己刷leetcode官方刷题攻略的一些经验与总结。
题目链接详见 leetcode刷题攻略
如果喜欢的话，别忘了点个赞哦 ^ _ ^

一.430扁平化多级双向链表

1.题目描述

2.题目分析与解答

我们需要将给定的链表拉平，当一个节点有孩子时，需要将孩子接到该节点的 next 指针处，该节点原本 next 指针位置的元素需要接到该节点孩子最右边的后面。我们需要一层一层往下处理孩子，所以要用到栈这种数据结构保存有孩子节点的 next 指针位置的元素。

处理方法：
当遇到一个节点有孩子时，把他的 next 指针指向的节点先入栈，然后把孩子接到该节点 next 指针的位置，当所有孩子处理完后，我们需要拼接栈中的元素到指定位置，这时候需要两个指针，一个 cur 记录栈中当前节点，一个 pre 记录该节点的前一个结点，使其能够双向连接。

C++ 代码如下：

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* prev;
    Node* next;
    Node* child;
};
*/

class Solution {
public:
    Node* flatten(Node* head) {

        //用栈来保存每一个有孩子节点的next节点，先进后出
        if(!head) return nullptr;
        stack<Node*> st;
        Node *cur = head;
        Node *pre = nullptr;
        while(cur || !st.empty()) {
            if(cur == nullptr) {
                //需要从栈中取出一个元素拼接到后面
                cur = st.top();
                st.pop();
                cur->prev = pre;
                pre->next = cur;
            }
            if(cur->child) {
                if(cur->next) st.push(cur->next); //记录next
                cur->child->prev = cur; //孩子前驱指向当前节点
                cur->next = cur->child; //将孩子放到next位置
                cur->child = nullptr; //孩子设为空
            }

            pre = cur;
            cur = cur->next;
        }

        return head;
    }
};

二.114二叉树展开为链表

1.题目描述

2.题目分析与解答

我们需要将一个二叉树展开为链表，需要在 root 上原地改变，而不是新建立一棵树。按照先序遍历，root 的左节点为空，右节点按照遍历顺序赋值。

可以用辅助数组将二叉树的先序遍历结果保存下来，然后遍历赋值即可。

C++ 代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<TreeNode*> ans;
    void flatten(TreeNode* root) {
        //需要在root上原地改变，而不是重新建立一棵树
        //先序遍历放数组，然后赋值
        if(root == nullptr) return ;
        preOrder(root);
        int len = ans.size();
        
        for(int i = 1; i < len; i ++) {
            root->right = ans[i];
            root->left = nullptr;
            root = root->right;
        }
    }

    void preOrder(TreeNode* root) {
        //中左右
        if(root) {
            ans.push_back(root);
            preOrder(root->left);
            preOrder(root->right);
        }
        
    }
};

3.空间优化为 O(1)

上面借助辅助数组的做法空间复杂度为 O(n)，这里讲一种进阶做法，将空间复杂度降为 O(1)。

因为是按照先序遍历（中左右），我们可以这么做：
如果当前节点有左子树，我们可以将当前节点的右子树接到当前节点左子树的最右边位置（该位置是当前节点右子树的前驱节点），然后将当前节点的左子树接到右子树的位置。接着处理下一个节点。

C++ 代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<TreeNode*> ans;
    void flatten(TreeNode* root) {
        //需要在root上原地改变，而不是重新建立一棵树
        //先序遍历放数组，然后赋值

        //优化:空间复杂度为O(1)
        //因为是按照先序遍历建立链表，我们可以这样做
        //如果当前节点有左节点，找到左子树的最右边节点，将当前节点的右子树放到最右边节点的右子树位置，将当前节点的左子树放到当前节点的右子树位置，然后处理下一个节点。

        if(root == nullptr) return ;
        TreeNode *cur = root;
        while(cur) {
            if(cur->left) {
                TreeNode *tem = cur->left;
                while(tem->right) {
                    tem = tem->right;
                }
                tem->right = cur->right;
                cur->right = cur->left;
                cur->left = nullptr;
            }

            cur = cur->right;
        }

    }

    
};