二叉树的中序遍历 非递归C语言实现

94. 二叉树的中序遍历 – 非递归实现

// code ver1 还是很直观易懂的
int* inorderTraversal(struct TreeNode* root, int* returnSize){
    int* ans;
    ans = (int *)malloc(sizeof(int) * MAXSIZE);
    int i = 0;

    if(!root){
        *returnSize = 0;
        return ans;
    }

    SqStack* S = CreateStack();
    //如果节点有左孩子，则入栈
    while(root){
        Push(S, root);
        root = root->left;
    }

    //每弹出一个节点的同时，检查其是否有右孩子，有的话就存入该节点的右孩子以及该孩子的左孩子...
    while(!StackEmpty(S)){
        struct TreeNode* temp = StackPeek(S);
        ans[i++] = Pop(S);

        if(temp->right){
            temp = temp->right;
            Push(S, temp);
            
            while(temp->left){
                Push(S, temp->left);
                temp = temp->left;
            }
        }
    }

    *returnSize = i;
    return ans;
}

作者：zywang714
链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/zhi-chi-cyu-yan-by-jzns7jsmj6-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。


// code ver2  优化后的cpp
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> s;
        vector<int> res;
        TreeNode* pnode=root;
        while(!s.empty()||pnode!=NULL){
            while(pnode!=NULL){
                s.push(pnode);
                pnode=pnode->left;
            }
            pnode=s.top();
            res.push_back(pnode->val);
            s.pop();
            pnode=pnode->right;
        }
        return res;
    }
};

作者：leo-503
链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/cc-shuang-100-zhan-die-dai-by-leo-503/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。





 #define MAXSIZE 1000 

int* inorderTraversal(struct TreeNode* root, int* returnSize){

    struct TreeNode *p[MAXSIZE];
    int top = -1,i= 0;
    int *r;
    r = (int *)malloc(sizeof(int)*MAXSIZE);

    struct TreeNode *temp ;
    temp = root;
    
    while(temp != NULL || top != -1)
    {
        if(temp != NULL)
        {
            top++;
            p[top] = temp;
            temp = temp->left;
        }
        else
        {
            temp = p[top];
            top--;
            r[i] = temp->val;
            i++;
            temp = temp->right;
        }
    }
    (*returnSize) = i;
    return r;
}

作者：andy2333-4
链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/jing-dian-zhan-jie-jue-er-cha-shu-qian-zhong-hou-x/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。



// code ver3
int* inorderTraversal(struct TreeNode* root, int* returnSize){
    
    
    int size=TreeSize(root);
    //memset(res,0,size);

    int p=-1,index=0;
    if(!root){
        *returnSize=0;
        return NULL;
    } 
    struct TreeNode** src=malloc(sizeof(struct TreeNode*)*size); 
    int *res=malloc(sizeof(int)*size);
    while(root!=NULL||p!=-1)
    {
        while(root)
        {
            src[++p]=root;
            root=root->left;//一直往左走
        }

        if(p!=-1) {
            root=src[p--];
            res[index++]=root->val;
            root=root->right;
        }    
}
*returnSize =index;
return res;
}

作者：cocowy
链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/da-dao-zhi-jian-dong-tai-shen-qing-shu-zu-di-gui-q/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。




int* inorderTraversal(struct TreeNode* root, int* returnSize){
    int *arr = NULL;
    struct TreeNode *stack[50000] = {}, *node;
    int top = 0;
    *returnSize = 0;
    if (!root)  return arr;
    arr = malloc(sizeof(int) * 50000);
    node = root;
    while (top || node) {
        while (node) {
            stack[top++] = node;
            // printf("%d\n",node->val);
            node = node->left;
        }
        if (top) {
            node = stack[--top];
            arr[(*returnSize)++] = node->val;
            // if (node->right)
                node = node->right;
            // else
                // node = NULL;
        }
    }
    return arr;
}