C++二叉树的链表实现，包括递归和非递归实现

在上文的博客中已经写了二叉树的实现，那么为什么还要继续写这篇博文呢？答案是因为上文简单的写了二叉树的递归遍历，相信大家肯定刺激度不够，所以这篇博文中添加了非递归遍历，满足大家的好奇心，学习数据结构主要是蕴含在其中的思路，思路对了，什么都很简单的，不要局限在这种方式中，希望这篇博文会给大家带来一些收获。

Node.h

#ifndef NODE_H
#define NODE_H

class Node{
public:
    Node();
    int pos;
    int data;
    Node* pLchild;
    Node* pRchild;
    Node* pParent;
    Node* searchNode(int pos);
    void deleteNode();
    void PreorderTraversal();
    void PreorderTraversalNonRecur();
    void InorderTraversal();
    void InorderTraversalNonRecur();
    void PostorderTraversal();
    void PostorderTraversalNonRecur();
};
#endif

Tree.h

#ifndef TREE_H
#define TREE_H
#include "Node.h"
class Tree{
public:
    Tree();
    ~Tree();
    Node* searchIndex(int nodeIndex);
    bool addNode(int nodeIndex, int direction, Node* pNode);
    bool delNode(int nodeIndex, Node *pNode);
    void PreorderTraversalNonRecur();
    void PreorderTraversal();
    void InorderTraversal();
    void InorderTraversalNonRecur();
    void PostorderTraversal();
    void PostorderTraversalNonRecur();
private:
    Node* m_pRoot;
};

#endif

Node.cpp

#include "Node.h"
#include <iostream>
#include <stack>
using namespace std;
Node::Node(){
    pos = 0;
    data = 0;
    pLchild = NULL;
    pRchild = NULL;
    pParent = NULL;
}
Node* Node::searchNode(int pos){
    if (this->pos == pos){
        return this;
    }
    Node*t = NULL;
    if (this->pLchild != NULL){
        if (this->pLchild->pos == pos){
            return this->pLchild;
        }
        else{
            t = this->pLchild->searchNode(pos);
            if (t != NULL){
                return t;
            }
        }
    }
    if (this->pRchild != NULL){
        if (this->pRchild->pos == pos){
            return this->pRchild;
        }
        else{
            t = this->pRchild->searchNode(pos);
            if (t != NULL){
                return t;
            }
        }
    }
    return NULL;
}

//Ϊɭô
void Node::deleteNode(){
    if (this->pLchild != NULL){
        this->pLchild->deleteNode();
    }
    if (this->pRchild != NULL){
        this->pRchild->deleteNode();
    }
    if (this->pParent != NULL){
        if (this->pParent->pLchild == this){
            this->pParent->pLchild = NULL;
        }
        if (this->pParent->pRchild == this){
            this->pParent->pRchild = NULL;
        }
    }
    delete this;
}
void Node::PreorderTraversal(){
    /*cout << this->pos << " " << this->data << endl;
    if (this->pLchild != NULL){
    this->pLchild->PreorderTraversal();
    }if (this->pRchild != NULL){
    this->pRchild->PreorderTraversal();
    }*/
    if (this == NULL){
        return;
    }
    else{
        cout << this->pos << "  " << this->data << endl;
        this->pLchild->PreorderTraversal();
        this->pRchild->PreorderTraversal();
    }
}
void Node::PreorderTraversalNonRecur(){
    stack<Node*> stack;
    Node *node = this;
    while (node != NULL || !stack.empty()){
        while (node != NULL){
            cout << node->pos << " " << node->data << endl;
            stack.push(node);
            node = node->pLchild;
        }
        if (!stack.empty()){
            node = stack.top();
            stack.pop();
            node = node->pRchild;
        }
    }
}
void Node::InorderTraversal(){
    /*if (this->pLchild != NULL){
        this->pLchild->InorderTraversal();
        }
        cout << this->pos << " " << this->data<<endl;
        if (this->pRchild != NULL){
        this->pRchild->InorderTraversal();
        }*/
    if (this == NULL){
        return;
    }
    else{
        this->pLchild->InorderTraversal();
        cout << this->pos << "  " << this->data << endl;
        this->pRchild->InorderTraversal();
    }
}
void Node::InorderTraversalNonRecur(){
    stack<Node*> stack;
    Node* node = this;
    while (node != NULL || (!stack.empty())){
        while (node != NULL){
            stack.push(node);
            node = node->pLchild;
        }
        if (!stack.empty()){
            node = stack.top();
            cout << node->pos << " " << node->data << endl;
            stack.pop();
            node = node->pRchild;
        }
    }
}
void Node::PostorderTraversal(){
    /*if (this->pLchild != NULL){
        this->pLchild->PostorderTraversal();
        }
        if (this->pRchild != NULL){
        this->pRchild->PostorderTraversal();
        }
        cout << this->pos << " " << this->data<<endl;*/
    if (this == NULL){
        return;
    }
    else{
        this->pLchild->PostorderTraversal();
        this->pRchild->PostorderTraversal();
        cout << this->pos << "  " << this->data << endl;
    }
}
void Node::PostorderTraversalNonRecur(){
    Node *cur = this;
    Node* pre = NULL;
    stack<Node*> stack;
    stack.push(cur);
    while (!stack.empty()){
        cur = stack.top();
        if (cur->pLchild == NULL&&cur->pRchild == NULL || (pre != NULL&&(cur->pLchild==pre||cur->pRchild==pre))){
            cout << cur->pos << " " << cur->data << endl;
            stack.pop();
            pre = cur;
        }
        else{
            if (cur->pRchild != NULL){
                stack.push(cur->pRchild);
            }if (cur->pLchild != NULL){
                stack.push(cur->pLchild);
            }
        }
    }
}

Tree.cpp

#include "Tree.h"
#include <iostream>
using namespace std;
Tree::Tree(){
    m_pRoot = new Node();
}
Tree::~Tree(){
    //delNode(0, NULL);
    m_pRoot->deleteNode();
}
Node* Tree::searchIndex(int nodeIndex){
    return m_pRoot->searchNode(nodeIndex);
}
bool Tree::delNode(int nodeIndex, Node *pNode){
    Node* temp = searchIndex(nodeIndex);
    if (temp == NULL){
        return false;
    }
    pNode->pos = temp->pos;
    pNode->data = temp->data;

    temp->deleteNode();
    return true;
}
bool Tree::addNode(int nodeIndex, int direction, Node* pNode){
    Node* node = searchIndex(nodeIndex);
    if (node == NULL){
        cout << "这里出错了" << endl;
        return false;
    }
    Node *temp = new Node();
    if (temp == NULL){
        return false;
    }
    temp->data = pNode->data;
    //temp->pos = pNode->pos;
    temp->pParent = node;
    if (direction == 0){
        if (node->pLchild != NULL){
            return false;
        }
        cout << "第" << nodeIndex * 2 + 1 << "个节点  " <<temp->data<< endl;
        temp->pos = nodeIndex * 2 + 1;
        node->pLchild = temp;
        return true;
    }
    if (direction == 1){
        if (node->pRchild != NULL){
            return false;
        }
        cout << "第" << nodeIndex * 2 + 2 << "个节点  " <<temp->data<< endl;
        temp->pos = nodeIndex * 2 + 2;
        node->pRchild = temp;
        return true;
    }
    return true;
}
void Tree::PreorderTraversal(){
    m_pRoot->PreorderTraversal();
}
void Tree::PreorderTraversalNonRecur(){
    m_pRoot->PreorderTraversalNonRecur();
}
void Tree::InorderTraversal(){
    m_pRoot->InorderTraversal();
}
void Tree::InorderTraversalNonRecur(){
    m_pRoot->InorderTraversalNonRecur();
}
void Tree::PostorderTraversal(){
    m_pRoot->PostorderTraversal();
}
void Tree::PostorderTraversalNonRecur(){
    m_pRoot->PostorderTraversalNonRecur();
}

Demo.cpp

#include <iostream>
#include "Tree.h"
using namespace std;
int main(){
    Node* node1 = new Node();
    node1->pos = 1;
    node1->data = 5;

    Node* node2 = new Node();
    node2->pos = 2;
    node2->data = 8;

    Node* node3 = new Node();
    node3->pos = 3;
    node3->data = 2;

    Node* node4 = new Node();
    node4->pos = 4;
    node4->data = 6;

    Node* node5 = new Node();
    node5->pos = 5;
    node5->data = 9;

    Node* node6 = new Node();
    node6->pos = 6;
    node6->data = 7;

    Tree* tree = new Tree();
    tree->addNode(0, 0, node1);
    tree->addNode(0, 1, node2);

    tree->addNode(1, 0, node3);
    tree->addNode(1, 1, node4);

    tree->addNode(2, 0, node5);
    tree->addNode(2, 1, node6);
    cout << "前序遍历:" << endl;
    tree->PreorderTraversalNonRecur();
    cout << "中序遍历:" << endl;
    tree->InorderTraversalNonRecur();
    cout << "后序遍历:" << endl;
    tree->PostorderTraversalNonRecur();
    Node *temp = new Node();
    tree->delNode(5, temp);
    cout << "结果:"<<temp->pos << " " << temp->data << endl;
    tree->InorderTraversal();
    return 0;
}

在Node.cpp中我们定义了节点的非递归遍历，即树的非递归遍历，希望大家仔细查看node.cpp中的三个非递归实现的算法部分，进一步提高自己的实力，加油，向着美好出发！