二叉树的遍历C/C++

二叉树建立

一：二叉排序树的左子树节点值都小于根节点值，右子树节点值都大于根节点，因此假如根节点值为10，其左节点值为5，其左节点的右节点值为8，那么从右节点到跟节点的值依次为8 5 10，显然不是有序的
二：哈夫曼树是带权路径最小的二叉树，也不是有序的
三：AVL树是二叉排序树，只不过其左右子树的高度差有限制，每一个节点的左子树和右子树的高度差的绝对值至多等于1
四：堆是一种完全二叉树，其有大顶堆和小顶堆的分别，大顶堆是指其每个节点的值都大于其左右孩子的值（小顶堆反之），因此从任一节点到根节点是升序排列的（小顶堆反之）

//前序，建立二叉树
//前序，建立二叉树
struct TreeNode
{
	int val;
    TreeNode *left;
    TreeNode *right;
};

void CreateBitree(TreeNode* &T)
{
    int tmp;
    cin>>tmp;
    
    if(tmp == 655535) {
        T = NULL;
    } else {
        T = new TreeNode;
        T->val = tmp;
        CreateBitree(T->left);
        CreateBitree(T->right);
    }
}

二叉树前序遍历

typedef struct BTNode_s {
    int value;
    BTNode_s* pLeft;
    BTNode_s* pRight;
} BTNode;

非递归

void PreOrder(BTNode *pRoot)
{
    if (pRoot == nullptr) return;

    BTNode* p = pRoot;
    std::stack<BTNode*> treeStack;

    while(p != nullptr || !treeStack.empty()) {
        while(p != nullptr) {
            printf("%d\t", p->value);
            treeStack.push(p);
            p= p->pLeft; 
        }

        if (!treeStack.empty()) {
            p = treeStack.top();
            treeStack.pop();
            p = p->pRight;
        }
    }
}

递归

void PreOrder(BTNode* T)
{
    if(T == NULL) return;

    printf("%d", T->val);   //显示结点数据，可以更改为其他对节点操作
    PreOrder(T->pLeft);     //再先序遍历左子树
    PreOrder(T->pRight);    //最后先序遍历右子树       
}

二叉树中序遍历

typedef struct BTNode_s {
    int value;
    BTNode_s* pLeft;
    BTNode_s* pRight;
} BTNode;

非递归

void InOrder(BTNode* pRoot)
{
    if(pRoot ==NULL)  return;

    BTNode* p = pRoot;
    std::stack<BTNode*> treeStack;

    while(p != nullptr || !treeStack.empty()) {
        while(p != nullptr) {
            treeStack.push(p);
            p= p->pLeft;
        }

        if(!treeStack.empty()) {
            p= treeStack.top();
            printf("%d\t", p->value);
            treeStack.pop();
            p= p->pRight;
        }
    }
}

递归

void InOrder(BTNode* T)
{
    if(T == NULL)   return;

    InOrder(T->pLeft);      //中序遍历左子树
    printf("%d", T->val);   //显示结点数据，可以更改为其他对节点操作
    InOrder(T->pRight);     //最后中序遍历右子树       
}

二叉树后序遍历

typedef struct BTNode_s {
    int value;
    BTNode_s* pLeft;
    BTNode_s* pRight;
} BTNode;

非递归

void PostOrder(BTNode* pRoot)
{
    if(pRoot == nullptr) return;

    std::stack<BTNode*> treeStack;
    std::stack<int> nodeState;
    BTNode* p = pRoot;

    while(p != nullptr) {
        treeStack.push(p);
        nodeState.push(0);
        p = p->pLeft;
    }

    while(!treeStack.empty()) {
        p = treeStack.top();

        while(p->pRight != nullptr && nodeState.top() == 0) {
            nodeState.pop();
            nodeState.push(1);
            p = p->pRight;

            while(p != nullptr) {
                treeStack.push(p);
                nodeState.push(0);
                p = p->pLeft;
            }
            p = treeStack.top();
        }

        printf("%d\t", p->value);
        treeStack.pop();
        nodeState.pop();
    }  
}

递归

void PostOrder(BTNode* )
{
    if(T == NULL)   return;
    PostOrder(T->pLeft);    //先后序遍历左子树  
    PostOrder(T->pRight);   //再后序遍历右子树
    printf("%d", T->val);   //显示结点数据，可以更改为其他对节点操作       
}

层序遍历

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

vector<int> PrintFromTopToBottom(TreeNode* root) 
{
    vector<int> res;
    if(root == nullptr) return res;
    
    queue<TreeNode*> q;
    q.push(root);
    
    while(!q.empty()) {
        res.push_back(q.front()->val);
        if(q.front()->left) q.push(q.front()->left);
        if(q.front()->right) q.push(q.front()->right);
        q.pop();
    }
    return res;
}