二叉树的二叉链表存储

节点形态：

实现：

/******************************************
二叉树的二叉链表存储
by Rowandjj
2014/5/18
******************************************/
#include<IOSTREAM>
using namespace std;

/*二叉树的二叉链表存储表示*/
typedef int TElemType;
typedef struct _TREENODE_
{
    TElemType data;//值
    struct _TREENODE_ *lChild;//左孩子
    struct _TREENODE_ *rChild;//右孩子
}TreeNode,*pTreeNode,**ppTreeNode;
/*--------------辅助队列-------------------*/
typedef struct _QUEUE_NODE_//队列节点定义
{
    pTreeNode data;//数据域(存储二叉树节点)
    struct _QUEUE_NODE_ *pNext;//指针域
}QueueNode,*pQueueNode;

typedef struct _QUEUE_
{
    pQueueNode pHead;//队列头指针
    pQueueNode pTail;//队列尾指针
    int nodeCount;//队列节点个数
}Queue,*pQueue;
/*队列基本操作*/
void InitQueue(pQueue pQueueTemp);
void EnQueue(pQueue pQueueTemp,pTreeNode pTreeNodeTemp);
bool DeQueue(pQueue pQueueTemp,ppTreeNode ppTreeNodeTemp);
bool IsQueueEmpty(Queue QueueTemp);
void DestroyQueue(pQueue pQueueTemp);
//-----------------------------------------------------------------------
/*二叉树基本操作*/
void InitTree(ppTreeNode ppTreeNodeTemp);
void CreateTree(ppTreeNode ppTreeNodeTemp);
void DestroyTree(ppTreeNode ppTreeNodeTemp);
bool IsEmpty(pTreeNode pTreeNodeTemp);
void PreTravel(pTreeNode pTreeNodeTemp);//先序遍历
void MidTravel(pTreeNode pTreeNodeTemp);//中序遍历
void PosTravel(pTreeNode pTreeNodeTemp);//后序遍历
void LevelTravel(pTreeNode pTreeNodeTemp);//层次遍历
int GetDepth(pTreeNode pTreeNodeTemp);//求二叉树深度
void FindNode(pTreeNode pTreeNodeTemp,int data,ppTreeNode pFind);//查找节点，如果成功则用pFind返回
void Assign(pTreeNode pTreeNodeTemp,TElemType data);//赋值
void GetRoot(pTreeNode pTreeNodeTemp,void (*print)(TElemType));//获取根节点
pTreeNode GetParent(pTreeNode pTreeNodeTemp,TElemType data);//获取父节点
pTreeNode GetPoint(pTreeNode pTreeNodeTemp,TElemType data);//返回指向元素值为data的节点的指针
pTreeNode GetLeftChild(pTreeNode pTreeNodeTemp,TElemType data);//获取元素值为data的左孩子
pTreeNode GetRightChild(pTreeNode pTreeNodeTemp,TElemType data);//获取元素值为data的右孩子
pTreeNode GetLeftSibling(pTreeNode pTreeNodeTemp,TElemType data);//获取元素值为data的左兄弟
pTreeNode GetRightSibling(pTreeNode pTreeNodeTemp,TElemType data);//获取元素值为data的右兄弟
bool InsertChild(pTreeNode pTreeNodeTemp,int flag,pTreeNode pTreeNew);//将pTreeNew整体插到pTreeNodeTemp中,约定pTreeNew右子树为空,根据标志位flag的0或者1来判断插入位置
bool DeleteChild(pTreeNode pTreeNodeTemp,int flag);//flag==0,删除左子树，否则删除右子树

void printNode(TElemType e);

//-------------队列基本操作实现----------------------------------
void InitQueue(pQueue pQueueTemp)
{
    pQueueTemp->pHead = pQueueTemp->pTail = (pQueueNode)malloc(sizeof(QueueNode));
    if(pQueueTemp->pHead == NULL)
    {
        return;
    }
    pQueueTemp->pHead->pNext = NULL;
    pQueueTemp->nodeCount = 0;
}

void EnQueue(pQueue pQueueTemp,pTreeNode pTreeNodeTemp)
{
    pQueueNode pNodeNew = (pQueueNode)malloc(sizeof(QueueNode));
    if(pNodeNew != NULL)
    {
        pNodeNew->data = pTreeNodeTemp;
        pNodeNew->pNext = NULL;

        pQueueTemp->pTail->pNext = pNodeNew;
        pQueueTemp->pTail = pNodeNew;
        
        pQueueTemp->nodeCount++;
    }
    
}
bool DeQueue(pQueue pQueueTemp,ppTreeNode ppTreeNodeTemp)
{
    if(IsQueueEmpty(*pQueueTemp))
    {
        return false;
    }
    pQueueNode pDel = pQueueTemp->pHead->pNext;
    pQueueTemp->pHead->pNext = pDel->pNext;
    *ppTreeNodeTemp = pDel->data;    
    pQueueTemp->nodeCount--;
    if(pQueueTemp->pTail == pDel)
    {
        pQueueTemp->pTail = pQueueTemp->pHead;
    }

    free(pDel);
    return true;
}
bool IsQueueEmpty(Queue QueueTemp)
{
    return (QueueTemp.nodeCount > 0) ? false : true;
}
void DestroyQueue(pQueue pQueueTemp)
{
    if(pQueueTemp != NULL)
    {
        pQueueNode pTemp = pQueueTemp->pHead->pNext;
        while(pTemp!=NULL)
        {
            pQueueTemp->pHead->pNext = pTemp->pNext;
            free(pTemp);
            pTemp = pQueueTemp->pHead->pNext;
        }
        free(pQueueTemp->pHead);
        pQueueTemp->pHead = pQueueTemp->pTail = NULL;
        pQueueTemp->nodeCount = 0;
    }
}
//------------------二叉树操作实现--------------------------------

void CreateTree(ppTreeNode ppTreeNodeTemp)
{
    int a = 0;
    cin>>a;
    if(a == -1)
    {
        return;
    }
    else
    {
        *ppTreeNodeTemp = (pTreeNode)malloc(sizeof(TreeNode));
        if(*ppTreeNodeTemp != NULL)
        {
            (*ppTreeNodeTemp)->data = a;
            (*ppTreeNodeTemp)->lChild = NULL;
            (*ppTreeNodeTemp)->rChild = NULL;
            
            CreateTree(&(*ppTreeNodeTemp)->lChild);
            CreateTree(&(*ppTreeNodeTemp)->rChild);
        }
    }
}

void DestroyTree(ppTreeNode ppTreeNodeTemp)
{
    if(*ppTreeNodeTemp == NULL)
    {
        return;
    }
    if((*ppTreeNodeTemp)->lChild != NULL)
    {
        DestroyTree(&(*ppTreeNodeTemp)->lChild);        
    }
    if((*ppTreeNodeTemp)->rChild != NULL)
    {
        DestroyTree(&(*ppTreeNodeTemp)->rChild);
    }
    
    free(*ppTreeNodeTemp);
    *ppTreeNodeTemp = NULL;
}

bool IsEmpty(pTreeNode pTreeNodeTemp)
{
    return (pTreeNodeTemp == NULL);
}

void PreTravel(pTreeNode pTreeNodeTemp)//先序遍历
{
    if(pTreeNodeTemp != NULL)
    {
        cout<<pTreeNodeTemp->data<<" ";//先访问根节点
        PreTravel(pTreeNodeTemp->lChild);//再先序遍历左子树
        PreTravel(pTreeNodeTemp->rChild);//最后先序遍历右子树
    }
}
void InitTree(ppTreeNode ppTreeNodeTemp)
{
    *ppTreeNodeTemp = NULL;
}
void MidTravel(pTreeNode pTreeNodeTemp)//中序遍历
{
    if(pTreeNodeTemp != NULL)
    {
        MidTravel(pTreeNodeTemp->lChild);//先左子树
        cout<<pTreeNodeTemp->data<<" ";//再根节点
        MidTravel(pTreeNodeTemp->rChild);//最后右子树
    }
}
void PosTravel(pTreeNode pTreeNodeTemp)//后序遍历
{
    if(pTreeNodeTemp != NULL)
    {
        PosTravel(pTreeNodeTemp->lChild);//先左子树
        PosTravel(pTreeNodeTemp->rChild);//再右子树
        cout<<pTreeNodeTemp->data<<" ";//最后根节点
    }
}

int GetDepth(pTreeNode pTreeNodeTemp)
{
    int i = 0;
    int j = 0;
    if(pTreeNodeTemp == NULL)
    {
        return 0;
    }
    else
    {
         if(pTreeNodeTemp->lChild != NULL)
         {
            i = GetDepth(pTreeNodeTemp->lChild);    
         }else
         {
            i = 0;
         }
         if(pTreeNodeTemp->rChild != NULL)
         {
            j = GetDepth(pTreeNodeTemp->rChild);     
         }else
         {
            j = 0;
         }
         return (i>j)?i+1:j+1;
    }
}

void FindNode(pTreeNode pTreeNodeTemp,int data,ppTreeNode pFind)
{
    if(pTreeNodeTemp == NULL)
    {
        return;
    }
    if(pTreeNodeTemp->data == data)
    {
        *pFind = pTreeNodeTemp;
    }
    else
    {
        FindNode(pTreeNodeTemp->lChild,data,pFind);
        FindNode(pTreeNodeTemp->rChild,data,pFind);
    }
}
void Assign(pTreeNode pTreeNodeTemp,int data)
{
    if(pTreeNodeTemp->data != NULL)
    {
        pTreeNodeTemp->data = data;
    }
}

void GetRoot(pTreeNode pTreeNodeTemp,void (*print)(TElemType))
{
    if(pTreeNodeTemp != NULL)
    {
        print(pTreeNodeTemp->data);
    }else
    {
        print(-1);
    }
}

pTreeNode GetParent(pTreeNode pTreeNodeTemp,TElemType data)
{
    Queue qTemp;
    pTreeNode pTreeNodeNew;
            
    if(pTreeNodeTemp != NULL)
    {
        InitQueue(&qTemp);
        EnQueue(&qTemp,pTreeNodeTemp);//先入队根节点
        while(!IsQueueEmpty(qTemp))
        {  
            DeQueue(&qTemp,&pTreeNodeNew);
            if(pTreeNodeNew->lChild&&pTreeNodeNew->lChild->data==data || pTreeNodeNew->rChild&&pTreeNodeNew->rChild->data==data)
            {
                return pTreeNodeNew;
            }else
            {
                if(pTreeNodeNew->lChild)
                {
                    EnQueue(&qTemp,pTreeNodeNew->lChild);
                }
                if(pTreeNodeNew->rChild)
                {
                    EnQueue(&qTemp,pTreeNodeNew->rChild);
                }
            }
        }
    }
    DestroyQueue(&qTemp);
    return NULL;
} 

pTreeNode GetPoint(pTreeNode pTreeNodeTemp,TElemType data)
{
    Queue qTemp;
    pTreeNode pTreeNodeNew;
    if(pTreeNodeTemp != NULL)
    {
        InitQueue(&qTemp);
        EnQueue(&qTemp,pTreeNodeTemp);
        
        while(!IsQueueEmpty(qTemp))
        {
            DeQueue(&qTemp,&pTreeNodeNew);
            if(pTreeNodeNew->data == data)
            {
                return pTreeNodeNew;
            }
            else
            {
                if(pTreeNodeNew->lChild)
                {
                    EnQueue(&qTemp,pTreeNodeNew->lChild);
                }
                if(pTreeNodeNew->rChild)
                {
                    EnQueue(&qTemp,pTreeNodeNew->rChild);
                }
            }
        }
    }
    DestroyQueue(&qTemp);
    return NULL;
}

pTreeNode GetLeftChild(pTreeNode pTreeNodeTemp,TElemType data)
{
    if(pTreeNodeTemp != NULL)
    {
        pTreeNode pParentNode = GetPoint(pTreeNodeTemp,data);
        if(pParentNode && pParentNode->lChild)
        {
            return pParentNode->lChild;
        }
    }
    return NULL;
}
pTreeNode GetRightChild(pTreeNode pTreeNodeTemp,TElemType data)
{
    if(pTreeNodeTemp != NULL)
    {
        pTreeNode pParentNode = GetPoint(pTreeNodeTemp,data);
        if(pParentNode && pParentNode->rChild)
        {
            return pParentNode->rChild;
        }
    }
    return NULL;
}
pTreeNode GetLeftSibling(pTreeNode pTreeNodeTemp,TElemType data)
{
    if(pTreeNodeTemp != NULL)
    {
        pTreeNode pParent = GetParent(pTreeNodeTemp,data);
        if(pParent && pParent->lChild && pParent->rChild->data == data)
        {
            return pParent->lChild;
        }
    }
    return NULL;
}
pTreeNode GetRightSibling(pTreeNode pTreeNodeTemp,TElemType data)
{
    if(pTreeNodeTemp != NULL)
    {
        pTreeNode pParent = GetParent(pTreeNodeTemp,data);
        if(pParent && pParent->rChild && pParent->lChild->data == data)
        {
            return pParent->rChild;
        }
    }
    return NULL;
}
void LevelTravel(pTreeNode pTreeNodeTemp)
{
    Queue qTemp;
    pTreeNode pTreeNodeTravel;
    if(pTreeNodeTemp != NULL)
    {
        InitQueue(&qTemp);
        EnQueue(&qTemp,pTreeNodeTemp);
        while(!IsQueueEmpty(qTemp))
        {
            DeQueue(&qTemp,&pTreeNodeTravel);
            cout<<pTreeNodeTravel->data<<" ";
            if(pTreeNodeTravel->lChild)
            {
                EnQueue(&qTemp,pTreeNodeTravel->lChild);
            }
            if(pTreeNodeTravel->rChild)
            {
                EnQueue(&qTemp,pTreeNodeTravel->rChild);
            }    
        }
    }
    DestroyQueue(&qTemp);
}
bool InsertChild(pTreeNode pTreeNodeTemp,int flag,pTreeNode pTreeNew)
{
    if(pTreeNodeTemp != NULL && pTreeNew != NULL && pTreeNew->rChild == NULL)
    {
        if(flag == 0)//左插
        {
            pTreeNew->rChild = pTreeNodeTemp->lChild;
            pTreeNodeTemp->lChild = pTreeNew;
        }else//flag == 1，右插
        {
            pTreeNew->rChild = pTreeNodeTemp->rChild;
            pTreeNodeTemp->rChild = pTreeNew;
        }
        return true;
    }
    return false;
}
bool DeleteChild(pTreeNode pTreeNodeTemp,int flag)
{
    if(pTreeNodeTemp != NULL)
    {
        if(flag == 0)//删除左子树
        {
            DestroyTree(&pTreeNodeTemp->lChild);
        }else//删除右子树
        {
            DestroyTree(&pTreeNodeTemp->rChild);
        }
        return true;
    }
    return false;
}
void printNode(TElemType e)
{
    cout<<"root = ";
    cout<<e<<" ";
}