LeedCode 144. 二叉树的前序遍历 C/C++《两种语言实现》加 《非递归实现》

和前面的一样，我们先看一下题目：

给定一个二叉树，返回它的 前序 遍历。

示例:

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

输出: [1,2,3]

首先我们先给出C语言的实现代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {

 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 
* };
 */
/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
typedef struct TreeNode* STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top; // 栈顶
	int _capacity; // 容量
}Stack;

void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

void StackDestory(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		size_t newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		ps->_a = (STDataType*)realloc(ps->_a, sizeof(STDataType)*newcapacity);
		assert(ps->_a != NULL);
		ps->_capacity = newcapacity;
	}
ps->_a[ps->_top] = x;
ps->_top++;
}

void StackPop(Stack* ps)
{
	assert(ps && ps->_top > 0);
	--ps->_top;

}

STDataType StackTop(Stack* ps)
{
	assert(ps && ps->_top > 0);
	return ps->_a[ps->_top - 1];
}

int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0 ? 0 : 1;
}

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}

int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
    Stack st;
    StackInit(&st);
    struct TreeNode* cur = root;
    while(StackEmpty(&st) != 0 || cur != NULL)
    {
        // 1.访问坐路节点并入栈
        while(cur != NULL)
        {
            //printf("%d ", cur->val);
            ++(*returnSize);
        
        StackPush(&st, cur);
        cur = cur->left;
    }
    
    struct TreeNode* top = StackTop(&st);
    StackPop(&st);
    
    // 子问题：访问右子树
    cur = top->right;        
}

int* prearray = (int*)malloc(4*(*returnSize));
int i = 0;
cur = root;
while(StackEmpty(&st) != 0 || cur != NULL)
{
    // 1.访问坐路节点并入栈
    while(cur != NULL)
    {
        printf("%d ", cur->val);
        prearray[i++] = cur->val;
        
        StackPush(&st, cur);
        cur = cur->left;
    }
    
    struct TreeNode* top = StackTop(&st);
    StackPop(&st);
    
    // 子问题：访问右子树
    cur = top->right;        
}

return prearray;
}

我们可以看出C语言的实现代码，非常的长，但是比较容易理解，但是使用c++的话，更比较容易实现，我们看一下实现的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:
  

      //使用的是递归的方法，一层层遍历，就可以了；
        void preorder(TreeNode* root, vector<int>& v)   //这里传的是&
        {
            if(root == NULL)
               return;
        
        v.push_back(root->val);
              
        preorder(root->left , v);
        preorder(root->right , v);  
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> v;
        preorder(root,v);
        
        return v;
    }
};

第三种：《非递归的实现》
我们看下面的代码：

 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
  //非递归
    vector<int> preorderTraversal(TreeNode* root){
        
        vector<int> v;
        TreeNode* cur = root;
        stack<TreeNode*> st;
        //开始访问一棵树
        while(cur || !st.empty())
        {
            while(cur)
            {
                st.push(cur);
                v.push_back(cur->val);
                cur = cur->left;
            }
            TreeNode* top = st.top();
            st.pop();
            cur = top->right;
        }
        return v;
    }
};

我们可以看到，c++的实现方法是非常简单，而且容易理解，但是如果还没有学过Vector，那么我推荐看我的vector博客，来复习一下；
vector《一》链接：https://blog.youkuaiyun.com/dpfxaca6/article/details/89101801
vector《二》链接：https://blog.youkuaiyun.com/dpfxaca6/article/details/89117427