[Leetcode] Binary Tree Inorder Traversal

[ 정답 - 반복 버전 ]

 

1) 초기 상태

2) 현재 ptr을 포함하여, 더이상 내려갈 수 없을 때까지 왼쪽으로 내려가며 그 위치를 스택에 쌓는다.

3) Stack에서 하나를 꺼내고 정답 vector에 넣는다. 현재 ptr은 Stack에서 마지막에 꺼내진 4를 가리키고 있다.

4) ptr을 현재 가리키고있는 ptr의 우측으로 이동한다. (여기서는 4의 우측 자손이 없으므로 ptr == nullptr일 것이다.)

 

5) 2),3) 4) 동작을 반복한다.

 

( 반복 동작 - [Stack이 비어있지 않다 or 현재가 nullptr이 아니다]의 조건을 만족하는 동안 )

현재 ptr == nullptr이므로

- [2) 왼쪽으로 더이상 내려갈 수 없을때까지 왼쪽으로 간다]는 수행되지 않을 것이다.

- [3) 스택에서 하나 꺼내고 정답 vector에 넣는다]가 수행되어 Stack에서 2가 꺼내짐과 동시에 ptr은 2를 가리킬 것이다. 그리고 정답 vector에 2가 들어가게 된다.

 

- [4) ptr을 현재 가리키고 있는 ptr의 우측으로 이동한다]에 의해 5로 이동할 것이다. 

 

[ 연습용 코드 ]

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
#include <iostream>
#include <set>

using namespace std;

struct TreeNode
{
	int val;
	TreeNode* left = nullptr;
	TreeNode* right = nullptr;

	TreeNode() : val(0) {}
	TreeNode(int x) : val(x) {}
	TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) { }
};

class Solution {
public:
	vector<int> inorderTraversal(TreeNode* root)
	{
	}
};

int main()
{
	TreeNode n4(4, nullptr, nullptr);
	TreeNode n5(5, nullptr, nullptr);
	TreeNode n6(6, nullptr, nullptr);

	TreeNode n2(2, &n4, &n5);
	TreeNode n3(3, &n6, nullptr);

	TreeNode n1(1, &n2, &n3);

	Solution s;
	vector<int> result = s.inorderTraversal(&n1); // [4 2 5 1 6 3]

	return 0;
}

 

[ 정답 - 반복 버전 ]

/*
struct TreeNode
{
	int val;
	TreeNode* left = nullptr;
	TreeNode* right = nullptr;

	TreeNode() : val(0) {}
	TreeNode(int x) : val(x) {}
	TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) { }
};
*/

class Solution {
public:
	vector<int> inorderTraversal(TreeNode* root)
	{
		stack<TreeNode*> s;
		vector<int> result;

		TreeNode* now = root;

		while (s.empty() == false || now != nullptr)
		{
			while (now != nullptr)
			{
				s.push(now);
				now = now->left;
			}

			now = s.top();
			s.pop();
			result.push_back(now->val);

			now = now->right;
		}

		return result;
	}
};

 

[ 정답 - 재귀버전 ]

/*
struct TreeNode
{
	int val;
	TreeNode* left = nullptr;
	TreeNode* right = nullptr;

	TreeNode() : val(0) {}
	TreeNode(int x) : val(x) {}
	TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) { }
};
*/

class Solution {
public:
    vector<int> result;
    
    vector<int> inorderTraversal(TreeNode* root)
    {
        Inorder(root);
        
        return result;
    }
    
    void Inorder(TreeNode* root)
    {
        if(root == nullptr)
            return;
        
        Inorder(root->left);
        result.push_back(root->val);
        Inorder(root->right);
    }
};