LeetCode 94 二叉樹的中序遍歷 C,Java,Python

LeetCode94 二叉樹的中序遍歷

來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/

博主Github：https://github.com/GDUT-Rp/LeetCode

題目：

給定一個二叉樹，返回它的中序 遍歷。

示例 1:

輸入: [1,null,2,3]
   1
    \
     2
    /
   3

輸出: [1,3,2]

解題思路：

方法一：遞歸算法

直觀想法

定義一個輔助遞歸函數實現。

C++

#include <iostream>
#include <vector>

using namespace std;

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> ans;
		printTree(root, ans);
		return ans;
	}

    TreeNode* createTree() {
        TreeNode *head, *node;
        head = new TreeNode(2);
        head->left = new TreeNode(1);
        head->right = new TreeNode(3);
    }

    void printTree(TreeNode *head, vector<int> &ans) {
        if (head == NULL) {
            return ;
        }
        if (head->left != NULL){
            printTree(head->left, ans);
        }
        ans.push_back(head->val);
        //cout << head->val << " ";
        if (head->right != NULL){
            printTree(head->right, ans);
        }
        return;
    }
};

int main()
{
    Solution solution;
    TreeNode* head = solution.createTree();
    vector<int> ans = solution.inorderTraversal(head);
    for(auto elem:ans){
        cout << elem << " " << endl;
    }
    cout << "Hello world!" << endl;
    return 0;
}

Java

class Solution {
    public List < Integer > inorderTraversal(TreeNode root) {
        List < Integer > res = new ArrayList < > ();
        helper(root, res);
        return res;
    }

    public void helper(TreeNode root, List < Integer > res) {
        if (root != null) {
            if (root.left != null) {
                helper(root.left, res);
            }
            res.add(root.val);
            if (root.right != null) {
                helper(root.right, res);
            }
        }
    }
}

Python

# -*- coding: utf-8 -*-
# @File   : LeetCode94.py
# @Author : Runpeng Zhang
# @Date   : 2020/2/18
# @Desc   : None

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution:
    def inorderTraversal(self, root: TreeNode):
        res = []
        self.helper(root, res)
        return res

    def helper(self, root, res):
        if root:
            if root.left:
                self.helper(root.left, res)
            res.append(root.val)
            if root.right:
                self.helper(root.right, res)

    def buildTree(self):
        root = TreeNode(1)
        root.left = TreeNode(2)
        root.right = TreeNode(4)
        return root


test = Solution()
treeNode = test.buildTree()
print(test.inorderTraversal(treeNode))

複雜度分析

時間複雜度：$O(n)$。遞歸函數 $T(n) = 2 \cdot T(n/2)+1$。
空間複雜度：最壞情況下需要空間 $O(n)$，平均情況爲 $O(\log n)$。

方法二：基於棧的遍歷

直觀想法

本方法的策略與上衣方法很相似，區別是使用了棧。

演示效果

C++

/**
 * 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;
        stack<TreeNode*> mystack;
        while (root != NULL || !mystack.empty()) {
            while (root != NULL) {
                mystack.push(root);
                root = root->left;
            }
            root = mystack.top();
            mystack.pop();
            res.push_back(root->val);
            root = root->right;
        }
        return res;
	}
};

Java

public class Solution {
    public List < Integer > inorderTraversal(TreeNode root) {
        List < Integer > res = new ArrayList < > ();
        Stack < TreeNode > stack = new Stack < > ();
        TreeNode curr = root;
        while (curr != null || !stack.isEmpty()) {
            while (curr != null) {
                stack.push(curr);
                curr = curr.left;
            }
            curr = stack.pop();
            res.add(curr.val);
            curr = curr.right;
        }
        return res;
    }
}

Python

# -*- coding: utf-8 -*-
# @File   : LeetCode94.py
# @Author : Runpeng Zhang
# @Date   : 2020/2/18
# @Desc   : None

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution:
    def inorderTraversal(self, root: TreeNode):
        """
        遞歸進行中序遍歷
        :rtype: 中序遍歷數組
        """
        res = []
        self.helper(root, res)
        return res

    def helper(self, root, res):
        """
        輔助函數：遞歸遍歷二叉樹
        :rtype: object
        """
        if root:
            if root.left:
                self.helper(root.left, res)
            res.append(root.val)
            if root.right:
                self.helper(root.right, res)

    def buildTree(self):
        """
        建一顆簡單的二叉樹
        :rtype: 二叉樹根節點
        """
        root = TreeNode(1)
        root.left = TreeNode(2)
        root.right = TreeNode(4)
        return root

    def stackTree(self, root):
        """
        用棧結構來完成中序遍歷
        :rtype: 中序遍歷數組
        """
        stack = []
        res = []
        while root or len(stack) > 0:
            while root:
                stack.append(root)
                root = root.left
            root = stack.pop()
            res.append(root.val)
            root = root.right
        return res

test = Solution()
treeNode = test.buildTree()
print(test.inorderTraversal(treeNode))
print(test.stackTree(treeNode))