二叉搜尋樹的後序遍歷序列

題目描述

輸入一個整數陣列，判斷該陣列是不是某二叉搜尋樹的後序遍歷的結果。假設輸入的陣列的任意兩個數字都互不相同。

例如，下圖是後序遍歷序列 3,1,2 所對應的二叉搜尋樹。

解題思路

BST的後序序列的合法序列是，對於一個序列S，最後一個元素是x （也就是根），如果去掉最後一個元素的序列為T，那麼T滿足：T可以分成兩段，前一段（左子樹）小於x，後一段（右子樹）大於x，且這兩段（子樹）都是合法的後序序列。完美的遞迴定義

c++

class Solution {
private:
  bool func(vector<int>
 
&a, int l, int r)
  {
    if(l >= r) return true;
    int i = r;
    while(i > l && a[i - 1] > a[r]) --i;
    for(int j = i - 1; j >= l; --j) if(a[j] > a[r]) return false;
    return func(a, l, i - 1)&&func(a,i,r-1);
   }
public:
    bool VerifySquenceOfBST(vector<int
 
> sequence) {
      if(!sequence.size()) return false;
        return func(sequence, 0, sequence.size() - 1);
    }

};

java

public boolean VerifySquenceOfBST(int[] sequence) {
    if (sequence == null || sequence.length == 0)
        return false;
    return verify(sequence, 0, sequence.length - 1
 
);
}

private boolean verify(int[] sequence, int first, int last) {
    if (last - first <= 1)
        return true;
    int rootVal = sequence[last];
    int cutIndex = first;
    while (cutIndex < last && sequence[cutIndex] <= rootVal)
        cutIndex++;
    for (int i = cutIndex + 1; i < last; i++)
        if (sequence[i] < rootVal)
            return false;
    return verify(sequence, first, cutIndex - 1) && verify(sequence, cutIndex, last - 1);
}

二叉樹中和為某一值的路徑

題目描述

輸入一顆二叉樹和一個整數，打印出二叉樹中結點值的和為輸入整數的所有路徑。路徑定義為從樹的根結點開始往下一直到葉結點所經過的結點形成一條路徑。

下圖的二叉樹有兩條和為 22 的路徑：10, 5, 7 和 10, 12

解題思路

class Solution {
private:

  void dfs(TreeNode* root,int s,vector<vector<int>> &ret,vector<int> &trace)
  {
       trace.push_back(root->val);
       if(root->left == NULL&& root->right==NULL)
       {
         if(root->val == s)
              ret.push_back(trace);
       }
       if(root->left != NULL)
              dfs(root->left, s-root->val, ret, trace);

       if(root->right != NULL)
              dfs(root->right, s-root->val, ret, trace);

      trace.pop_back();  
  }
public:
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {

      vector<vector<int>> res;
      vector<int> trace;

      if(root) dfs(root,expectNumber,res,trace);

      return res;

    }
};

java

private ArrayList<ArrayList<Integer>> ret = new ArrayList<>();

public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
    backtracking(root, target, new ArrayList<>());
    return ret;
}

private void backtracking(TreeNode node, int target, ArrayList<Integer> path) {
    if (node == null)
        return;
    path.add(node.val);
    target -= node.val;
    if (target == 0 && node.left == null && node.right == null) {
        ret.add(new ArrayList(path));
    } else {
        backtracking(node.left, target, path);
        backtracking(node.right, target, path);
    }
    path.remove(path.size() - 1);
}

python

def pathSum(self, root, sum):
    if not root:
        return []
    res = []
    self.dfs(root, sum, [], res)
    return res

def dfs(self, root, sum, ls, res):
    if not root.left and not root.right and sum == root.val:
        ls.append(root.val)
        res.append(ls)
    if root.left:
        self.dfs(root.left, sum-root.val, ls+[root.val], res)
    if root.right:
        self.dfs(root.right, sum-root.val, ls+[root.val], res)

複雜連結串列的複製

題目描述

輸入一個複雜連結串列（每個節點中有節點值，以及兩個指標，一個指向下一個節點，另一個特殊指標指向任意一個節點），返回結果為複製後複雜連結串列的 head。

解題思路

c++

/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(pHead == NULL)
            return NULL;
        RandomListNode * cur = pHead;
        //插入新節點
        while(cur!=NULL)
        {
            RandomListNode *newnode = new RandomListNode(cur->label);
            newnode->next = cur->next;
            cur->next = newnode;
            cur = newnode->next;
        }
        //建立random連結
        cur = pHead;
        while(cur!=NULL)
        {
            RandomListNode *newnode = cur->next;
            if(cur->random != NULL)
                newnode->random = cur->random->next;
            cur = newnode -> next;
        }
        //拆分
        cur = pHead;
        RandomListNode *pclonehead = pHead->next;
        while(cur->next != NULL)
        {
            RandomListNode *next = cur->next;
            cur->next = next ->next;
            cur = next;
        }
        return pclonehead;
    }
};

java

public RandomListNode Clone(RandomListNode pHead) {
    if (pHead == null)
        return null;
    // 插入新節點
    RandomListNode cur = pHead;
    while (cur != null) {
        RandomListNode clone = new RandomListNode(cur.label);
        clone.next = cur.next;
        cur.next = clone;
        cur = clone.next;
    }
    // 建立 random 連結
    cur = pHead;
    while (cur != null) {
        RandomListNode clone = cur.next;
        if (cur.random != null)
            clone.random = cur.random.next;
        cur = clone.next;
    }
    // 拆分
    cur = pHead;
    RandomListNode pCloneHead = pHead.next;
    while (cur.next != null) {
        RandomListNode next = cur.next;
        cur.next = next.next;
        cur = next;
    }
    return pCloneHead;
}

二叉搜尋樹與雙向連結串列

題目描述

輸入一棵二叉搜尋樹，將該二叉搜尋樹轉換成一個排序的雙向連結串列。要求不能建立任何新的結點，只能調整樹中結點指標的指向。

java

private TreeNode pre = null;
private TreeNode head = null;

public TreeNode Convert(TreeNode root) {
    if (root == null)
        return null;
    inOrder(root);
    return head;
}

private void inOrder(TreeNode node) {
    if (node == null)
        return;
    inOrder(node.left);
    node.left = pre;
    if (pre != null)
        pre.right = node;
    pre = node;
    if (head == null)
        head = node;
    inOrder(node.right);
}

c++

//直接用中序遍歷
public class Solution {
    TreeNode head = null;
    TreeNode realHead = null;
    public TreeNode Convert(TreeNode pRootOfTree) {
        ConvertSub(pRootOfTree);
        return realHead;
    }

    private void ConvertSub(TreeNode pRootOfTree) {
        if(pRootOfTree==null) return;
        ConvertSub(pRootOfTree.left);
        if (head == null) {
            head = pRootOfTree;
            realHead = pRootOfTree;
        } else {
            head.right = pRootOfTree;
            pRootOfTree.left = head;
            head = pRootOfTree;
        }
        ConvertSub(pRootOfTree.right);
    }
}