数据结构链表和树代码部分总结

kanzwienhoff

已于 2023-09-07 16:02:51 修改

阅读量212

点赞数

文章标签：数据结构链表

于 2021-12-08 20:40:58 首次发布

本文链接：https://blog.csdn.net/kanzwienhoff/article/details/121795155

版权

本文详细介绍了单链表的头插法、尾插法、长度计算、判断空、按序号查找、按值查找、删除节点及插入等核心操作，同时涵盖了循环链表、交叉链表、二叉树的遍历、完全二叉树判断、二叉排序树特性，以及相关算法如后序遍历、层序遍历和深度计算。

摘要由CSDN通过智能技术生成

数据结构链表和树代码部分总结

单链表
- 完整代码
循环单链表
- 完整代码
交叉链表
二叉树
二叉排序树
完整代码

单链表

头插法

//头插法建立单链表
LinkList List_HeadInsert(LinkList &L)//这里&是引用，更改变量L的值
{
    Node *s;
    int x;
    L=(LinkList)malloc(sizeof(Node));
    L->next=NULL;//这里是指针的用法
    cin>>x;
    while(x!=9999)
    {
        s=(Node*)malloc(sizeof(Node));
        s->data=x;
        s->next=L->next;
        L->next=s;
        cin>>x;
    }
    return L;
}

尾插法

//尾插法建立单链表
LinkList List_PostInsert(LinkList &L)
{
    //n为表尾指针
    Node *s,*n;
    int x;
    L=(LinkList)malloc(sizeof(Node));
    L->next=NULL;
    n=L;
    cin>>x;
    while(x!=9999)
    {

        s=(Node*)malloc(sizeof(Node));
        s->next=n->next;
        n->next=s;
        s->data=x;
        n=s;
        cin>>x;
    }
    n->next=NULL;
    return L;
}

求单链表长度

//求单链表长度
int GetListLength(LinkList L)
{
    Node* r=L->next;
    int Count=0;
    while(r!=NULL)
    {
        r=r->next;
        Count++;
    }
    return Count;
}

单链表判空

//单链表判空
bool IsEmptyList(LinkList L)
{
    Node* r=L->next;
    if(r==NULL)
        return true;
    else
        return false;
}

按序号查找单链表

//按序号查找单链表
Node *Get_Elem(LinkList L,int i)
{
    int j=1;
    Node* n=L->next;
    if(i==0)//i=0，返回头结点
        return L;
    if(i<1)//i无效，返回为空
        return NULL;

    while(n&&j<i)
    {
        n=n->next;
        j++;
        cout<<n->data<<" ";
    }
    return n;
}

按值查找节点

//按值查找节点
Node* LocationElem(LinkList L,int e)
{
    Node* s=L->next;
    while(s!=NULL&&s->data!=e)
    {
        s=s->next;
    }
    return s;
}

单链表的删除

//单链表的删除
void Del_List(LinkList &L, int e)
{
    Node* s=L->next;
    while(s!=NULL&&s->data!=e)
    {
        s=s->next;
    }
    s->data=s->next->data;
    s->next=s->next->next;
    free(s->next);
}

单链表按序号插入

//单链表按序号插入
void Insert_List(LinkList &L,int e,int i)
{
    Node* n;
    n->data=e;
    n->next=NULL;
    Node* s=L->next;
    int j=1;
    while(s&&j<i)
    {
        s=s->next;
        j++;
    }
    if(s)
    {
        n->next=s->next;
        s->next=n;
    }
}

反向输出链表值

//反向输出链表值
void r_print(LinkList L)
{
    if(L->next!=NULL)
    {
        r_print(L->next);
    }
    cout<<L->data<<endl;
}

删除链表最小值

//删除链表最小值
LinkList delete_min(LinkList L)
{
    Node *pre=L, *p=pre->next;//工作指针
    Node *minpre=pre, *minp=p;//记录最小值
    while(p)
    {
        if(p->data < minp->data)
        {
            minp=p;
            minpre=pre;
        }
        pre=p;
        p=p->next;
    }
    //删除
    minpre->next=minp->next;
    free(minp);
    return L;
}

就地逆置单链表（头插法的应用）

//就地逆置单链表（头插法的应用）
LinkList reverse_list(LinkList L)
{
    Node *p, *q;
    p=L->next;
    L->next=NULL;
    while(p)
    {
        q=p;
        p=p->next;
        q->next=L->next;
        L->next=q;
    }
}

完整代码

#include <iostream>
#include <stdlib.h>

using namespace std;

typedef struct Node
{
    int data;
    struct Node* next;
} Node, *LinkList;

//头插法建立单链表
LinkList List_HeadInsert(LinkList &L)//这里&是引用，更改变量L的值
{
    Node *s;
    int x;
    L=(LinkList)malloc(sizeof(Node));
    L->next=NULL;//这里是指针的用法
    cin>>x;
    while(x!=9999)
    {
        s=(Node*)malloc(sizeof(Node));
        s->data=x;
        s->next=L->next;
        L->next=s;
        cin>>x;
    }
    return L;
}

//尾插法建立单链表
LinkList List_PostInsert(LinkList &L)
{
    //n为表尾指针
    Node *s,*n;
    int x;
    L=(LinkList)malloc(sizeof(Node));
    L->next=NULL;
    n=L;
    cin>>x;
    while(x!=9999)
    {

        s=(Node*)malloc(sizeof(Node));
        s->next=n->next;
        n->next=s;
        s->data=x;
        n=s;
        cin>>x;
    }
    n->next=NULL;
    return L;
}

//求单链表长度
int GetListLength(LinkList L)
{
    Node* r=L->next;
    int Count=0;
    while(r!=NULL)
    {
        r=r->next;
        Count++;
    }
    return Count;
}

//单链表判空
bool IsEmptyList(LinkList L)
{
    Node* r=L->next;
    if(r==NULL)
        return true;
    else
        return false;
}

//按序号查找单链表
Node *Get_Elem(LinkList L,int i)
{
    int j=1;
    Node* n=L->next;
    if(i==0)//i=0，返回头结点
        return L;
    if(i<1)//i无效，返回为空
        return NULL;

    while(n&&j<i)
    {
        n=n->next;
        j++;
        cout<<n->data<<" ";
    }
    return n;
}

//按值查找节点
Node* LocationElem(LinkList L,int e)
{
    Node* s=L->next;
    while(s!=NULL&&s->data!=e)
    {
        s=s->next;
    }
    return s;
}

//单链表的删除
void Del_List(LinkList &L, int e)
{
    Node* s=L->next;
    while(s!=NULL&&s->data!=e)
    {
        s=s->next;
    }
    s->data=s->next->data;
    s->next=s->next->next;
    free(s->next);
}

//单链表按序号插入
void Insert_List(LinkList &L,int e,int i)
{
    Node* n;
    n->data=e;
    n->next=NULL;
    Node* s=L->next;
    int j=1;
    while(s&&j<i)
    {
        s=s->next;
        j++;
    }
    if(s)
    {
        n->next=s->next;
        s->next=n;
    }
}

//反向输出链表值,
void r_print(LinkList L)
{
    if(L->next!=NULL)
    {
        r_print(L->next);
    }
    cout<<L->data<<endl;
}

//删除链表最小值
LinkList delete_min(LinkList L)
{
    Node *pre=L, *p=pre->next;//工作指针
    Node *minpre=pre, *minp=p;//记录最小值
    while(p)
    {
        if(p->data < minp->data)
        {
            minp=p;
            minpre=pre;
        }
        pre=p;
        p=p->next;
    }
    //删除
    minpre->next=minp->next;
    free(minp);
    return L;
}

//就地逆置单链表（头插法的应用）
LinkList reverse_list(LinkList L)
{
    Node *p, *q;
    p=L->next;
    L->next=NULL;
    while(p)
    {
        q=p;
        p=p->next;
        q->next=L->next;
        L->next=q;
    }
}

//顺序输出链表
void print(LinkList L)
{
    Node *p=L->next;
    while(p!=NULL)
    {
        cout<<p->data<<endl;
        p=p->next;
    }
}

int main()
{
    LinkList L;
    List_PostInsert(L);
    //Del_List(L,3);
    reverse_list(L);
    print(L);
    return 0;
}

应该是没啥错误（大概）

循环单链表

头插法

//头插法
void HeadInsert(LinkList L,int n)
{
    Node* s=(Node*)malloc(sizeof(Node));
    s->data=n;
    s->next=L->next;
    L->next=s;
}

尾插法

//尾插法
void PostInsert(LinkList L,int n)
{
    //检查指针，始终志向最后一个结点
    Node* c=(Node*)malloc(sizeof(Node));
    c=L->next;
    while(c->next!=L)
    {
        c=c->next;
    }
    Node* s=(Node*)malloc(sizeof(Node));
    s->data=n;
    s->next=c->next;
    c->next=s;
}

删除结点

//删除结点
bool deleteFactor(LinkList L,int n)
{
    Node* pre_node=(Node*)malloc(sizeof(Node));
    Node* node=(Node*)malloc(sizeof(Node));
    pre_node=L;
    node=L->next;
    while(node!=L&&node->data!=n)
    {
        pre_node=pre_node->next;
        node=node->next;
    }
    //这里是循环一周没有找到对应的结点，则返回失败
    if(node==L)
        return false;
    else
    {
        pre_node->next=node->next;
        free(node);
        return true;
    }
}

打印循环链表

//打印循环链表
void PrintList(LinkList L)
{
    Node* top=(Node*)malloc(sizeof(Node));
    top=L->next;
    while(top!=L)
    {
        cout<<top->data<<"->";
        top=top->next;

    }
    cout<<"NULL"<<endl;
}

完整代码

#include <iostream>
#include <stdlib.h>

using namespace std;

typedef struct Node
{
    int data;
    struct Node* next;
} Node,*LinkList;

LinkList InitList()
{
    LinkList L=(Node*)malloc(sizeof(Node));
    L->data=0;
    L->next=L;
    return L;
}

//头插法
void HeadInsert(LinkList L,int n)
{
    Node* s=(Node*)malloc(sizeof(Node));
    s->data=n;
    s->next=L->next;
    L->next=s;
}

//尾插法
void PostInsert(LinkList L,int n)
{
    //检查指针，始终志向最后一个结点
    Node* c=(Node*)malloc(sizeof(Node));
    c=L->next;
    while(c->next!=L)
    {
        c=c->next;
    }
    Node* s=(Node*)malloc(sizeof(Node));
    s->data=n;
    s->next=c->next;
    c->next=s;
}

//删除结点
bool deleteFactor(LinkList L,int n)
{
    Node* pre_node=(Node*)malloc(sizeof(Node));
    Node* node=(Node*)malloc(sizeof(Node));
    pre_node=L;
    node=L->next;
    while(node!=L&&node->data!=n)
    {
        pre_node=pre_node->next;
        node=node->next;
    }
    //这里是循环一周没有找到对应的结点，则返回失败
    if(node==L)
        return false;
    else
    {
        pre_node->next=node->next;
        free(node);
        return true;
    }
}

//打印循环链表
void PrintList(LinkList L)
{
    Node* top=(Node*)malloc(sizeof(Node));
    top=L->next;
    while(top!=L)
    {
        cout<<top->data<<"->";
        top=top->next;

    }
    cout<<"NULL"<<endl;
}

int main()
{
    LinkList L=InitList();
    for(int i=1; i<5; i++)
    {
        PostInsert(L,i);
    }
    PrintList(L);
    deleteFactor(L,6);
    PrintList(L);
    return 0;
}

交叉链表

#include <iostream>
#include <stdlib.h>

using namespace std;

typedef struct node{
    int value;
    struct node* next;
}Node ;

int Get_Length(Node* L)
{
    Node* s=L;
    int j=0;
    while(s!=NULL)
    {
        s=s->next;
        j++;
    }
    return j;
}

//移动长链表的指针和短链表指针相对位置相同
Node* remove_list(Node* L,int n)
{
    Node* s=L;
    for(int i=0;i<n;i++)
    {
        s=s->next;
    }
    return s;
}

//找出第一个公共结点
Node* find_common_node(Node* L1,Node*L2)
{
    int length1=Get_Length(L1);
    int length2=Get_Length(L2);
    Node* Max_List=L1;
    Node* Min_List=L2;
    if(length1<length2)
    {
        Max_List=L2;
        Min_List=L1;
    }
    int del=abs(length1-length2);
    Node* m=remove_list(Max_List,del);
    Node* n=Min_List;
    while(m!=n)
    {
        if(m!=NULL&&n!=NULL)
        {
            m=m->next;
            n=n->next;
        }
        else
        {
            return NULL;
        }

    }
    return m;
}

int main()
{
    Node* n1=(node*)malloc(sizeof(Node));
    Node* n2=(node*)malloc(sizeof(Node));
    Node* n3=(node*)malloc(sizeof(Node));
    Node* n4=(node*)malloc(sizeof(Node));
    Node* n5=(node*)malloc(sizeof(Node));
    Node* n6=(node*)malloc(sizeof(Node));
    Node* n7=(node*)malloc(sizeof(Node));
    n1->value=1;
    n2->value=2;
    n3->value=3;
    n4->value=4;
    n5->value=5;
    n6->value=6;
    n7->value=7;
    n1->next=n2;
    n2->next=n3;
    n3->next=n4;
    n4->next=n5;
    n5->next=n6;
    n7->next=n3;
    n6->next=NULL;
    Node* L1=n1;
    Node* L2=n7;
    cout<<find_common_node(L1,L2)->value;
    return 0;
}

二叉树

后序遍历，结点最大栈长为树的高度

//后序遍历，结点最大栈长为树的高度
int Ddpth(BiTree T)
{
    BiTree p=T,r=NULL;//r记录p的前一个结点
    int Max=0;
    stack<BiTree> s;
    while(p||!s.empty())
    {
        if(p!=NULL)
        {
            s.push(p);
            p=p->lchild;
        }
        else
        {
            p=s.top();
            if(p->rchild!=NULL&&p->rchild!=r)//右孩子存在并且没有被访问
            {
                p=p->rchild;
                s.push(p);//可省
                p=p->lchild;//可省
            }
            else
            {
                if(s.size()>Max)
                    Max=s.size();
                r=p;
                s.pop();
                p=NULL;
            }
        }
    }
    return Max;
}

层序遍历，层次即为高度

//层序遍历，层次即为高度
int BT_level_depth(BiTree T)
{
    if(T==NULL)
        return 0;
    BiTree p=T,Q[100];
    int Front=-1,rear=-1,last=0,level=0;
    Q[++rear]=p;
    while(Front<rear)
    {
        p=Q[++Front];
        if(p->lchild)
            Q[++rear]=p->lchild;
        if(p->rchild)
            Q[++rear]=p->rchild;
        if(Front==last)
        {
            last=rear;
            level++;  //层次+1
        }
    }
    return level;
}

递归求树高

//递归求树高
int BT_depth(BiTree T)
{
    if(T==NULL)
        return 0;
    else
    {
        int l=BT_depth(T->lchild);
        int r=BT_depth(T->rchild);
        if(l>r)
            return l+1;
        else if(l<=r)
            return r+1;
    }
}

中序非递归遍历二叉树

//中序非递归遍历二叉树
void InOrder(BiTree T)
{
    BiTree p=T;
    stack<BiTree>s;
    while(p||!s.empty())
    {
        if(p)
        {
            s.push(p);
            p=p->lchild;
        }
        else
        {
            p=s.top();
            s.pop();//这两步是弹出栈顶指针再给p
            /*****/
            //visit(p);中序遍历在这里访问
            /*****/
            cout<<p->data;
            p=p->rchild;
        }
    }
}

先序非递归遍历二叉树

//先序非递归遍历二叉树
void PreOrder(BiTree T)
{
    BiTree p=T;
    stack<BiTree>s;
    while(p||!s.empty())
    {
        if(p)
        {
            /*****/
            //visit(p);先序遍历在这里访问
            /*****/
            cout<<p->data;
            s.push(p);
            p=p->lchild;
        }
        else
        {
            p=s.top();
            s.pop();//这两步是弹出栈顶指针再给p
            p=p->rchild;
        }
    }
}

完整代码

#include<iostream>
#include<stack>
#include<queue>
#include<malloc.h>

/*
调试程序输入二叉树：-+a##*b##-c##d##/e##f##
程序输出该二叉树的高度：5
*/
using namespace std;
typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild,*rchild;
} BiTNode,*BiTree;

void CreateTree(BiTree &T)
{
    char ch;
    cin>>ch;
    if(ch=='#')
        T=NULL;
    else
    {
        T=(BiTree)malloc(sizeof(BiTNode));
        if(!T)
            cout<<"生成结点错误"<<endl;
        T->data=ch;
        CreateTree(T->lchild);
        CreateTree(T->rchild);
    }
}

//后序遍历，结点最大栈长为树的高度
int Ddpth(BiTree T)
{
    BiTree p=T,r=NULL;//r记录p的前一个结点
    int Max=0;
    stack<BiTree> s;
    while(p||!s.empty())
    {
        if(p!=NULL)
        {
            s.push(p);
            p=p->lchild;
        }
        else
        {
            p=s.top();
            if(p->rchild!=NULL&&p->rchild!=r)//右孩子存在并且没有被访问
            {
                p=p->rchild;
                s.push(p);//可省
                p=p->lchild;//可省
            }
            else
            {
                if(s.size()>Max)
                    Max=s.size();
                r=p;
                s.pop();
                p=NULL;
            }
        }
    }
    return Max;
}

//层序遍历，层次即为高度
int BT_level_depth(BiTree T)
{
    if(T==NULL)
        return 0;
    BiTree p=T,Q[100];
    int Front=-1,rear=-1,last=0,level=0;
    Q[++rear]=p;
    while(Front<rear)
    {
        p=Q[++Front];
        if(p->lchild)
            Q[++rear]=p->lchild;
        if(p->rchild)
            Q[++rear]=p->rchild;
        if(Front==last)
        {
            last=rear;
            level++;  //层次+1
        }
    }
    return level;
}

//递归求树高
int BT_depth(BiTree T)
{
    if(T==NULL)
        return 0;
    else
    {
        int l=BT_depth(T->lchild);
        int r=BT_depth(T->rchild);
        if(l>r)
            return l+1;
        else if(l<=r)
            return r+1;
    }
}

//中序非递归遍历二叉树
void InOrder(BiTree T)
{
    BiTree p=T;
    stack<BiTree>s;
    while(p||!s.empty())
    {
        if(p)
        {
            s.push(p);
            p=p->lchild;
        }
        else
        {
            p=s.top();
            s.pop();//这两步是弹出栈顶指针再给p
            /*****/
            //visit(p);中序遍历在这里访问
            /*****/
            cout<<p->data;
            p=p->rchild;
        }
    }
}

//先序非递归遍历二叉树
void PreOrder(BiTree T)
{
    BiTree p=T;
    stack<BiTree>s;
    while(p||!s.empty())
    {
        if(p)
        {
            /*****/
            //visit(p);先序遍历在这里访问
            /*****/
            cout<<p->data;
            s.push(p);
            p=p->lchild;
        }
        else
        {
            p=s.top();
            s.pop();//这两步是弹出栈顶指针再给p
            p=p->rchild;
        }
    }
}

int main()
{
    BiTree T=NULL;
    CreateTree(T);
    cout<<"后序遍历求树高："<<Ddpth(T)<<endl;
    cout<<"层次遍历求树高："<<BT_level_depth(T)<<endl;
    cout<<"递归求树高"<<BT_depth(T)<<endl;
    PreOrder(T);
    InOrder(T);
    return 0;
}

判断是否是完全二叉树（伪代码）

//将所有的节点加入队列包括空节点，当遇到空节点时判断其后是否有空节点
bool IsComplete(BiTree T)
{
    InitQueue(Q);//创建队列
    if(!T)
        return 1;//完全二叉树也可以没有节点
    EnQueue(Q,T);//二叉树全部入队列
    BiTree p=T;
    while(!isEmpty(Q))
    {
        Dequeue(Q,p);//每次出队列一个结点
        if(p)
        {
            Enqueue(Q,p->lchild);
            Enqueue(Q,p->rchild);
        }
        else //节点为空，检查其后是否有非空节点
        {
            while(!isEmpty(Q))
            {
                Dequeue(Q,p);
                if(p)
                    return false;
            }
        }
    }
    return true;
}

二叉排序树

注意，函数头里的形参Node*写代码题可以换成BiTree，好多教科书里都是BiTree

前序遍历（递归）

//前序遍历（递归）
void preOrder(Node* node)
{
    if(node!=NULL)
    {
        //根左右
        cout<< node->data<<" ";
        preOrder(node->lchild);
        preOrder(node->rchild);
    }
}

求双分支节点个数

//求双分支节点个数
//遇到双分支节点+1
int DsonNodes(Node* T)
{
    if(T==NULL)
        return 0;
    else if(T->lchild!=NULL&&T->rchild!=NULL)
        return DsonNodes(T->lchild)+DsonNodes(T->rchild)+1;
    else
        return DsonNodes(T->lchild)+DsonNodes(T->rchild);
}

交换二叉树的左右子树

//交换二叉树左右子树
void swapTree(Node* T)
{
    if(T)
    {
        swapTree(T->lchild);
        swapTree(T->rchild);
        Node* temp;
        temp=T->lchild;
        T->lchild=T->rchild;
        T->rchild=temp;
    }
}

BST的高度

//BST的高度
int BST_Height(Node* node)
{
    if(node==NULL)
        return 0;

    int Left_Height=BST_Height(node->lchild);
    int Right_Height=BST_Height(node->rchild);
    int Max=Left_Height;
    if(Max<Right_Height)
    {
        Max=Right_Height;
    }
    return Max+1;
}

查找次数+1=所在层数

//查找次数+1=所在层数
int level(Node* T,Node* r)
{
    int n=0;
    Node* p=T;
    if(p==NULL)
        return 0;
    else
    {
        while(p&&p->data!=r->data)
        {
            if(p->data<r->data)
                p=p->rchild;
            else
                p=p->lchild;
            n++;
        }
        if(p==NULL)
            return 0;
        else
            return n+1;
    }
}

递归遍历二叉树是否为二叉排序树

int IsSearchTree(Node* t)  //递归遍历二叉树是否为二叉排序树
{
    if(!t)        //空二叉树情况
        return 1;
    else if(!(t->lchild) && !(t->rchild))   //左右子树都无情况
        return 1;
    else if((t->lchild) && !(t->rchild))    //只有左子树情况
    {
        if(t->lchild->data>t->data)
            return 0;
        else
            return IsSearchTree(t->lchild);
    }
    else if((t->rchild) && !(t->lchild))   //只有右子树情况
    {
        if(t->rchild->data<t->data)
            return 0;
        else
            return IsSearchTree(t->rchild);
    }
    else         //左右子树全有情况
    {
        if((t->lchild->data>t->data) || (t->rchild->data<t->data))
            return 0;
        else
            return ( IsSearchTree(t->lchild) && IsSearchTree(t->rchild) );
    }
}

从大到小输出不小于k的关键字

//从大到小输出不小于k的关键字
void RDL_print(Node* T,int k)
{
    if (T != NULL)
    {
        RDL_print(T->rchild,k);

        if(T->data>=k)
            cout<<T->data<<" ";

        RDL_print(T->lchild,k);
    }
}

完整代码

#include <iostream>
#include <stdlib.h>

using namespace std;

typedef struct node
{
    int data;
    node* lchild;
    node* rchild;
} Node;

typedef struct
{
    Node* root;
} Tree;

void Insert(Tree* tree, int value)
{
    Node* node=(Node*)malloc(sizeof(Node));
    node->data=value;
    node->lchild=NULL;
    node->rchild=NULL;
    //判断要插入的节点是否为空
    if(tree->root==NULL)
    {
        tree->root=node;
    }
    else
    {
        Node* temp=tree->root;
        while(temp->data!=NULL)
        {
            if(value<temp->data)
            {
                if(temp->lchild==NULL)
                {
                    temp->lchild=node;
                    return;
                }
                else
                {
                    temp=temp->lchild;
                }
            }
            else
            {
                if(temp->rchild==NULL)
                {
                    temp->rchild=node;
                    return;
                }
                else
                {
                    temp=temp->rchild;
                }
            }
        }
    }
}
//前序遍历（递归）
void preOrder(Node* node)
{
    if(node!=NULL)
    {
        //根左右
        cout<< node->data<<" ";
        preOrder(node->lchild);
        preOrder(node->rchild);
    }
}

//BST的高度
int BST_Height(Node* node)
{
    if(node==NULL)
        return 0;

    int Left_Height=BST_Height(node->lchild);
    int Right_Height=BST_Height(node->rchild);
    int Max=Left_Height;
    if(Max<Right_Height)
    {
        Max=Right_Height;
    }
    return Max+1;
}

//查找次数+1=所在层数
int level(Node* T,Node* r)
{
    int n=0;
    Node* p=T;
    if(p==NULL)
        return 0;
    else
    {
        while(p&&p->data!=r->data)
        {
            if(p->data<r->data)
                p=p->rchild;
            else
                p=p->lchild;
            n++;
        }
        if(p==NULL)
            return 0;
        else
            return n+1;
    }
}

int IsSearchTree(Node* t)  //递归遍历二叉树是否为二叉排序树
{
    if(!t)        //空二叉树情况
        return 1;
    else if(!(t->lchild) && !(t->rchild))   //左右子树都无情况
        return 1;
    else if((t->lchild) && !(t->rchild))    //只有左子树情况
    {
        if(t->lchild->data>t->data)
            return 0;
        else
            return IsSearchTree(t->lchild);
    }
    else if((t->rchild) && !(t->lchild))   //只有右子树情况
    {
        if(t->rchild->data<t->data)
            return 0;
        else
            return IsSearchTree(t->rchild);
    }
    else         //左右子树全有情况
    {
        if((t->lchild->data>t->data) || (t->rchild->data<t->data))
            return 0;
        else
            return ( IsSearchTree(t->lchild) && IsSearchTree(t->rchild) );
    }
}

//从大到小输出不小于k的关键字
void RDL_print(Node* T,int k)
{
    if (T != NULL)
    {
        RDL_print(T->rchild,k);

        if(T->data>=k)
            cout<<T->data<<" ";

        RDL_print(T->lchild,k);
    }
}

//求双分支节点个数
int DsonNodes(Node* T)
{
    if(T==NULL)
        return 0;
    else if(T->lchild!=NULL&&T->rchild!=NULL)
        return DsonNodes(T->lchild)+DsonNodes(T->rchild)+1;
    else
        return DsonNodes(T->lchild)+DsonNodes(T->rchild);
}

//交换二叉树左右子树
void swapTree(Node* T)
{
    if(T)
    {
        swapTree(T->lchild);
        swapTree(T->rchild);
        Node* temp;
        temp=T->lchild;
        T->lchild=T->rchild;
        T->rchild=temp;
    }
}

int main()
{
    int arr[]= {5,3,7,1,6,4,9};
    Tree* tree=(Tree*)malloc(sizeof(Tree));
    tree->root=NULL;
    for(int i=0; i<7; i++)
    {
        Insert(tree,arr[i]);
    }
    preOrder(tree->root);
    cout<<endl;
    //cout<<BST_Height(tree->root)<<endl;
    Node* a=(Node*)malloc(sizeof(Node));
    a->data=3;
    a->lchild=NULL;
    a->rchild=NULL;
    cout<<level(tree->root,a)<<endl;
    cout<<IsSearchTree(tree->root)<<endl;
    int k=5;
    RDL_print(tree->root,k);
    cout<<endl;
    cout<<DsonNodes(tree->root)<<endl;
    swapTree(tree->root);
    preOrder(tree->root);
    free(tree);
    /*
    Tree tree;
    tree.root=NULL;
    for(int i=0; i<7; i++)
    {
        Insert(&tree,arr[i]);
    }
    preOrder(tree.root);
     */
    return 0;
}