数据结构之二叉树(二叉查找树)

//
//  Header.h
//  二叉树
//
//  Created by mouweng on 17/3/20.
//  Copyright © 2017年 二叉树. All rights reserved.
//

#ifndef Header_h
#define Header_h
#include<iostream>
using namespace std;

class Tree
{
public:
    Tree(int size,int *pRoot);
    ~Tree();
    int *SearchNode(int NodeIndex);
    bool AddNode(int NodeIndex,int direction,int *pNode);
    bool DeleteNode(int NodeIndex,int *pNode);
    void TreeTraverse();
private:
    int *m_pTree;
    int m_iSize;
};
#endif /* Header_h */

//
//  main.cpp
//  二叉树
//
//  Created by mouweng on 17/3/20.
//  Copyright © 2017年 二叉树. All rights reserved.
//

#include <iostream>
#include "Header.h"
using namespace std;

Tree::Tree(int size,int *pRoot)
{
    m_iSize=size;
    m_pTree= new int[size];
    for(int i=0;i<size;i++)
    {
        m_pTree[i]=0;
    }
    m_pTree[0]=*pRoot;
}
Tree::~Tree()
{
    delete []m_pTree;
    m_pTree=NULL;
}

int *Tree::SearchNode(int NodeIndex)
{
    if(NodeIndex<0||NodeIndex>=m_iSize)
        return NULL;
    if(m_pTree[NodeIndex]==0)
        return NULL;
    return &m_pTree[NodeIndex];
}

bool Tree::AddNode(int NodeIndex,int direction,int *pNode)
{
    if(NodeIndex<0||NodeIndex>=m_iSize)
        return false;
    if(m_pTree[NodeIndex]==0)
        return false;
    if(direction==0)//0代表做儿子插入，1代表右二子插入
    {
        if((NodeIndex*2+1)>=m_iSize)
            return false;
        if(m_pTree[NodeIndex*2+1]!=0)
            return false;
        m_pTree[NodeIndex*2+1]=*pNode;
    }
    if(direction==1)//0代表做儿子插入，1代表右二子插入
    {
        if((NodeIndex*2+2)>=m_iSize)
            return false;
        if(m_pTree[NodeIndex*2+2]!=0)
            return false;
        m_pTree[NodeIndex*2+2]=*pNode;
    }
    return true;
}

bool Tree::DeleteNode(int NodeIndex,int *pNode)
{
    if(NodeIndex<0||NodeIndex>=m_iSize)
        return false;
    if(m_pTree[NodeIndex]==0)
        return false;
    *pNode=m_pTree[NodeIndex];
    m_pTree[NodeIndex]=0;
    return true;
}

void Tree::TreeTraverse()
{
    for(int i=0;i<m_iSize;i++)
    {
        cout<<m_pTree[i]<<" ";
    }
}



int main()
{
    int root=3;
    Tree *pTree=new Tree(10,&root);
    int node1=5;
    int node2=8;
    pTree->AddNode(0,0,&node1);
    pTree->AddNode(0,1,&node2);
    int node3=2;
    int node4=6;
    pTree->AddNode(1,0,&node3);
    pTree->AddNode(1,1,&node4);
    int node5=9;
    int node6=7;
    pTree->AddNode(2,0,&node5);
    pTree->AddNode(2,1,&node6);
    
    
    pTree->TreeTraverse();
    
    int *p=pTree->SearchNode(2);
    
    cout<<endl<<"node="<<*p<<endl;
    
    int node=0;
    pTree->DeleteNode(6, &node);
    cout<<"node="<<node<<endl;
    pTree->TreeTraverse();
    
    delete pTree;
    
}

//
//  Tree.h
//  链表查找树的实现
//
//  Created by mouweng on 17/3/28.
//  Copyright © 2017年 查找树的实现. All rights reserved.
//链表实现的二叉树！

#include<iostream>
using namespace std;
#ifndef Tree_h
#define Tree_h
class Node
{
public:
    Node();
    Node *SearchNode(int nodeIndex);
    void DeleteNode();
    void PreorderTraversal();
    void InorderTraversal();
    void PostorderTraversal();
    int index;
    int data;
    Node *pLChild;
    Node *pRChild;
    Node *pParent;
};
Node::Node()
{
    index=0;
    data=0;
    pLChild=NULL;
    pRChild=NULL;
    pParent=NULL;
}
Node *Node::SearchNode(int nodeIndex)
{
    if(this->index==nodeIndex)
        return this;
    
    Node *temp=NULL;
    if(this->pLChild!=NULL)
    {
        if(this->pLChild->index==nodeIndex)
            return this->pLChild;
        else
        {
            temp=this->pLChild->SearchNode(nodeIndex);
            if(temp!=NULL)
                return temp;
        }
    }
    if(this->pRChild!=NULL)
    {
        if(this->pRChild->index==nodeIndex)
            return this->pRChild;
        else
        {
            temp=this->pRChild->SearchNode(nodeIndex);
            return temp;
        }
    }
    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->index<<" "<<this->data<<endl;
    if(this->pLChild!=NULL)
        this->pLChild->PreorderTraversal();
    if(this->pRChild!=NULL)
        this->pRChild->PreorderTraversal();
}
void Node::InorderTraversal()
{
    if(this->pLChild!=NULL)
        this->pLChild->InorderTraversal();
    cout<<this->index<<" "<<this->data<<endl;
    if(this->pRChild!=NULL)
        this->pRChild->InorderTraversal();
}
void Node::PostorderTraversal()
{
    if(this->pLChild!=NULL)
        this->pLChild->PostorderTraversal();
    if(this->pRChild!=NULL)
        this->pRChild->PostorderTraversal();
    cout<<this->index<<" "<<this->data<<endl;
}

class Tree
{
public:
    Tree();
    ~Tree();
    Node *SearchNode(int nodeIndex);
    bool AddNode(int nodeIndex,int direction,Node *pNode);
    bool DeleteNode(int nodeIndex,Node *pNode);
    void PreorderTraversal();
    void InorderTraversal();
    void PostorderTraversal();
private:
    Node *m_pRoot;
};

#endif /* Tree_h */

//
//  main.cpp
//  查找树的实现
//
//  Created by mouweng on 17/3/28.
//  Copyright © 2017年 查找树的实现. All rights reserved.
//

#include <iostream>
#include "Tree.h"
Tree::Tree()
{
    m_pRoot=new Node();
}

Tree::~Tree()
{
    m_pRoot->DeleteNode();
}

Node *Tree::SearchNode(int nodeIndex)
{
    return m_pRoot->SearchNode(nodeIndex);
}

bool Tree::AddNode(int nodeIndex,int direction,Node *pNode)//添加节点的操作！
{
    Node *temp=SearchNode(nodeIndex);//把搜索到的节点返回给temp
    if(temp==NULL)
        return false;
    
    Node *node=new Node();//申请节点，如果申请失败，则返回错误
    if(node==NULL)
        return false;
    
    node->index=pNode->index;
    node->data=pNode->data;
    node->pParent=temp;
    
    if(direction==0)
    {
        temp->pLChild=node;
    }
    if(direction==1)
    {
        temp->pRChild=node;
    }

    return true;
}

bool Tree::DeleteNode(int nodeIndex,Node *pNode)//这个删除节点，只要删除这个节点，这个节点的子节点也删除掉
{
    Node *temp=SearchNode(nodeIndex);//把搜索到的节点返回给temp
    if(temp==NULL)
        return false;
    
    if(pNode!=NULL)
    {
        pNode->data=temp->data;
    }
    
    temp->DeleteNode();
    return true;
}

void Tree::PreorderTraversal()//前序遍历
{
    m_pRoot->PreorderTraversal();
}

void Tree::InorderTraversal()//中序遍历
{
    m_pRoot->InorderTraversal();
}
void Tree::PostorderTraversal()//后序遍历
{
    m_pRoot->PostorderTraversal();
}

int main()
{
    Tree *tree=new Tree();
    
    Node *node1=new Node();
    node1->index=1;
    node1->data=5;
    
    Node *node2=new Node();
    node2->index=2;
    node2->data=8;
    
    Node *node3=new Node();
    node3->index=3;
    node3->data=2;
    
    Node *node4=new Node();
    node4->index=4;
    node4->data=6;
    
    Node *node5=new Node();
    node5->index=5;
    node5->data=9;
    
    Node *node6=new Node();
    node6->index=6;
    node6->data=7;
    
    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);
    
    
    tree->PostorderTraversal();
    cout<<endl;
    tree->InorderTraversal();
    cout<<endl;
    tree->PreorderTraversal();
    
    
    tree->DeleteNode(2, NULL);
    
    tree->PostorderTraversal();
    cout<<endl;
    tree->InorderTraversal();
    cout<<endl;
    tree->PreorderTraversal();
    
    
    
    delete tree;
    return 0;
}