Convert Binary Search Tree (BST) to Sorted Doubly-Linked List

94. Binary Tree Inorder Traversal
    https://leetcode.com/problems/binary-tree-inorder-traversal/description/

/**
 * 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<int> inorderTraversal(TreeNode* root) {
        vector<int>res;
        helper(root, res);
        return res;
        
    }
    
    void helper(TreeNode* root, vector<int>&res)
    {
        if(root == NULL) return;
        helper(root->left, res);
        res.push_back(root->val);
        helper(root->right, res);
    }
};

Convert Binary Search Tree (BST) to Sorted Doubly-Linked List
in order.
这是fb的一个高频题
这题的解法主要参考网上的资料，不算原创，理解的也不是特别深刻。

参考网上的方法：https://articles.leetcode.com/convert-binary-search-tree-bst-to/
用binary tree in order recursion
有个讲解很好，
https://blog.csdn.net/teaspring/article/details/17756343
方法二。

class Solution {
public:
// This is a modified in-order traversal adapted to this problem.
// prev (init to NULL) is used to keep track of previously traversed node.
// head pointer is updated with the list's head as recursion ends.
void helper(Node *p, Node *& prev, Node *& head) {
	if(p == null) return;
	helper(p->left, prev, head);
	prev = p->left;
	if(pre)
	{
		prev->right = p;
	}
	else
	{
		head = prev;
	}

	Node* right = p->right;
	head->left = p;
	p->right = head;
	pre = p;
	
	helper(p->right, prev, head);
}
 
// Given an ordered binary tree, returns a sorted circular
// doubly-linked list. The conversion is done in-place.
Node* treeToDoublyList(Node *root) {
	Node* pre = null;
	Node* head = null;
	helper(root, pre, head);
	return head;
}
};