acwing-05

acwing-05

二叉搜索树的后序遍历序列(简单)

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。

如果是则返回true，否则返回false。

假设输入的数组的任意两个数字都互不相同。

样例

输入：[4, 8, 6, 12, 16, 14, 10]

输出：true

• 二叉搜索树的特点就是，左子树的所有结点值都小于根节点，右子树的所有结点值都大于根节点
• 后序遍历，根节点位于一棵树的最后一个值。

class Solution {
public:
    bool verifySequenceOfBST(vector<int> sequence) {
        if(sequence.size()==0)return true;
        return dfs(0,sequence.size()-1,sequence);
    }
    bool dfs(int l,int r,vector<int> seq){
        if(l>=r)return true;
        int root=seq[r];
        int k=l;
        while(k<r&&seq[k]<root)k++;
        for(int i=k;i<r;i++){
            if(seq[i]<root)
            return false;
        }
        return dfs(l,k-1,seq)&&dfs(k,r-1,seq);
    }
};

二叉树中和为某一值的路径(中等)

输入一棵二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。

从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

样例

给出二叉树如下所示，并给出num=22。
      5
     / \
    4   6
   /   / \
  12  13  6
 /  \    / \
9    1  5   1

输出：[[5,4,12,1],[5,6,6,5]]

• 采用dfs思想进行路径搜索
• 建立临时数组暂存路径，当判断出该结点为叶子结点是，累计数组中的值，判断是否等于输入值
• 注意每次需要根据递归的结点更新数组中的值

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> res;
    int Sum;
    vector<vector<int>> findPath(TreeNode* root, int sum) {
        vector<int> ans;
        Sum=sum;
        dfs(root,ans);
        return res;
    }
    void dfs(TreeNode *root,vector<int>& ans){
        if(root==NULL)return ;
        ans.push_back(root->val);
        if(root->left==NULL&&root->right==NULL){
            int m=0;
            for(int i=0;i<ans.size();i++)
                m+=ans[i];
            if(m==Sum)res.push_back(ans);
            ans.pop_back();
            return ;
        }
       dfs(root->left,ans);
       dfs(root->right,ans);
       ans.pop_back();
    }
};

复杂链表的复刻

请实现一个函数可以复制一个复杂链表。

在复杂链表中，每个结点除了有一个指针指向下一个结点外，还有一个额外的指针指向链表中的任意结点或者null。

注意：

• 函数结束后原链表要与输入时保持一致。

题解

• 本题主要考虑到random指针所指向的结点的联系
• 采用hash表对原始结点和新建立的结点的字典的关系
• 遍历原始链表，对复制random指针

class Solution {
public:
    map<ListNode *,ListNode *> hasp;    
    ListNode *copyRandomList(ListNode *head) {
        if(head==NULL)return NULL;
        ListNode *p=head;
        ListNode *dump=new ListNode(-1);
        ListNode *tmp,*q=dump;
        while(p!=NULL){
            tmp=new ListNode(p->val);
            tmp->next=q->next;
            q->next=tmp;
            q=q->next;
            hasp[p]=q;
            p=p->next;
        }
        q=dump->next;
        p=head;
        while(p!=NULL){
            if(p->random==NULL){p=p->next;continue;}
            hasp[p]->random=hasp[p->random];
            p=p->next;
        }
        return dump->next;
    }
};