二叉树的中序遍历/二叉搜索树与双向链表

递归法

class Solution {
public:
	vector<int> res;
    vector<int> inorderTraversal(TreeNode* root) {
    	if(root == NULL) return res;//先判断根节点是否为空
    	if(root->left) inorderTraversal(root->left);//遍历左子树
    	res.push_back(root->val);//当前根节点关键字记录
    	if(root->right) inorderTraversal(root->right);//遍历右子树
    	return res;
    }
};

非递归法——栈：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
       vector<int> res;
       stack<TreeNode*> st;
       while(root){
           st.push(root);
           root = root->left;
       }
       while(!st.empty()){
           auto node = st.top();
           st.pop();
           res.push_back(node->val);
           node = node->right;
           while(node){
               st.push(node);
               node = node->left;
           }
       }
       return res;
    }
};

应用： 二叉搜索树与双向链表

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。

分析：

进行中序遍历，遍历到的每一个节点均进行连接，左子树指向前，右子树指向后，

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node() {}

    Node(int _val) {
        val = _val;
        left = NULL;
        right = NULL;
    }

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
public:
    void InOrder(Node *root,Node *&pre){
        if(!root) return;
        InOrder(root->left,pre);//左子树中序遍历完成，pre保存最后一个节点，
        if(pre){//建立左子树，根节点，右子树的链表关系
            root->left = pre;
            pre->right = root;
        }
        pre = root;
        InOrder(root->right,pre);//右子树中序遍历完成，pre指向右子树的最大节点，即整棵树的最大节点；
    }
    //中序遍历完成，除了第一个和最后一个节点，其他节点的链表关系均已建立
    Node* treeToDoublyList(Node* root) {
        if(root == NULL) return NULL;
        Node *pre = NULL;
        InOrder(root,pre);//中序遍历后，pre指向最后一个最大的节点，
        Node *t = root;
        while(t->left){
            t = t->left;
        }
        t->left = pre;//建立首节点和尾节点的链表关系
        pre->right = t;
        return t;
    }
};