数据结构学习笔记——树（查找，二叉树，二叉搜索树）

一、查找

1.静态查找（没有插入和删除操作)

（1）顺序查找

①顺序查找的一种实现：

哨兵：在数组第0位放置查找数字，若查到数字则返回位数，若未查找到，则返回0，在主函数中进行判断，通过哨兵可以减少一个判断条件语句

查找模块代码如下：

int Search(List head,int K)
{
    int i;
    head->num[0]=K;
    for(i=head->length;head->num[i]!=K;i--)
    {
        printf("the index is %d\n",i);
        printf("the number is %d\n",head->num[i]);
    }
    return i;
}

---

完整代码如下：

#include <stdio.h>
#include <stdlib.h>
#define Max 50

typedef  struct Lnode*List;

struct Lnode
{
    int num[Max];
    int length;
};

int Search(List head,int K)
{
    int i;
    head->num[0]=K;
    for(i=head->length;head->num[i]!=K;i--)
    {
        printf("the index is %d\n",i);
        printf("the number is %d\n",head->num[i]);
    }
    return i;
}

List Build()
{
    List p;
    p=(List)malloc(sizeof(struct Lnode));
    return p;
}

void Input(List head,int length)
{
    for(int i=length;i>0;i--)
    {
        printf("please enter the %d number:",i);
        scanf("%d",&head->num[i]);
    }
}

void Output(List head,int length)
{
    for(int i=length;i>0;i--)
        printf("the %d number is %d\n",i,head->num[i]);
}

int main()
{
    List p;
    int length;
    int K;
    int index;
    p=Build();
    printf("please enter the length:");
    scanf("%d",&p->length);
    Input(p,p->length);
    Output(p,p->length);
    printf("please enter the search_number:");
    scanf("%d",&K);
    index=Search(p,K);
    if(index==0)
        printf("none");
    else
        printf("the index is %d",index);
}

（2）二分查找

①二分查找的使用条件：
n个数据元素必须满足有序，从小到大或从大到小，本例以从小到大的顺序进行二分查找

②二分查找代码：

int BinarySearch(List p,int K)
{
    int left,right,mid;
    int NoFind=0;
    left=1;
    right=p->length;
    while(left<=right)
    {
        mid=(left+right)/2;
        if(K<p->num[mid])
        {
            right=mid-1;
        }
        else if(K>p->num[mid])
        {
            left=mid+1;
        }
        else
            return mid;
    }
    return NoFind;
}

③完整调试代码：

#include <stdio.h>
#include <stdlib.h>
#define Max 50

typedef  struct Lnode*List;

struct Lnode
{
    int num[Max];
    int length;
};

int BinarySearch(List p,int K)
{
    int left,right,mid;
    int NoFind=0;
    left=1;
    right=p->length;
    while(left<=right)
    {
        mid=(left+right)/2;
        if(K<p->num[mid])
        {
            right=mid-1;
        }
        else if(K>p->num[mid])
        {
            left=mid+1;
        }
        else
            return mid;
    }
    return NoFind;
}


List Build()
{
    List p;
    p=(List)malloc(sizeof(struct Lnode));
    return p;
}

void Input(List head,int length)
{
    for(int i=length;i>0;i--)
    {
        printf("please enter the %d number:",i);
        scanf("%d",&head->num[i]);
    }
}

void Output(List head,int length)
{
    for(int i=length;i>0;i--)
        printf("the %d number is %d\n",i,head->num[i]);
}

int main()
{
    List p;
    int length;
    int K;
    int index;
    p=Build();
    printf("please enter the length:");
    scanf("%d",&p->length);
    Input(p,p->length);
    Output(p,p->length);
    printf("please enter the search_number:");
    scanf("%d",&K);
    index=BinarySearch(p,K);
    if(index==0)
        printf("none");
    else
        printf("the index is %d",index);
}

二、树

1.树的定义：

2.树的相关名词

3.二叉树

（1）二叉树的定义

注：完全二叉树与完美二叉树的区别就是最底层的最后几个子树可以不存在

（2）二叉树的性质

叶节点（没有子树）分别为D，J，K，H共4个，度（子树个数）为2的非叶节点A，B，E共三个

（3）二叉树的非递归遍历

①先序遍历

void Preorder(BinTree BT)
{
    Stack S=CreateStack();
    BinTree T=BT;
    while(T||!IsEmpty(S))
    {
        while(T)
        {
            Push(S,T);
            printf("%d",T->Data);
            T=T->left;
        }
        if(!IsEmpty(S))
        {
            T=Pop(S);
            T=T->right;
        }
    }
    printf("\n");
}

②中序遍历

void Inorder(BinTree BT)
{
    Stack S=CreateStack();
    BinTree T=BT;
    while(T||!IsEmpty(S))
    {
        while(T)
        {
            Push(S,T);
            T=T->left;
        }
        if(!IsEmpty(S))
        {
            T=Pop(S);
            printf("%d",T->Data);
            T=T->right;
        }
    }
    printf("\n");
}

③后序遍历

主程序

#include<stdio.h>
#include<stdlib.h>

typedef struct TreeNode*BinTree;

struct TreeNode
{
    int Data;
    BinTree left;
    BinTree right;
};

typedef struct Snode*Stack;

struct Snode
{
    BinTree Data;
    Stack Next;
};

Stack CreateStack()
{
    Stack S;
    S=(Stack)malloc(sizeof(struct Snode));
    S->Next=NULL;
    return S;
}

int IsEmpty(Stack S)
{
    return(S->Next==NULL);
}
void Push(Stack S,BinTree item)
{
    Stack temp;
    temp=(Stack)malloc(sizeof(struct Snode));
    temp->Data=item;
    temp->Next=S->Next;
    S->Next=temp;
}

BinTree Pop(Stack S)
{
    Stack Top;
    BinTree First;
    if(IsEmpty(S))
    {
        printf("empty");
        return 0;
    }
    else
    {
        Top=S->Next;
        S->Next=Top->Next;
        First=Top->Data;
        free(Top);
        return First;
    }
}

BinTree Insert(int Data)
{
    BinTree Bt;
    Bt=(BinTree)malloc(sizeof(struct TreeNode));
    Bt->Data=Data;
    Bt->left=NULL;
    Bt->right=NULL;
}

BinTree CreatBinTree()
{
	BinTree BT;
	BT = (BinTree)malloc(sizeof(struct TreeNode));
	BT->Data=1;
	BT->left=Insert(2);
	BT->right=Insert(3);
	BT->left->left=Insert(4);
	BT->left->right=Insert(6);
	BT->left->right->left=Insert(5);
	BT->right->left=Insert(7);
	BT->right->right=Insert(9);
	BT->right->left->right=Insert(8);
	return BT;
}

void Preorder(BinTree BT)
{
    Stack S=CreateStack();
    BinTree T=BT;
    while(T||!IsEmpty(S))
    {
        while(T)
        {
            Push(S,T);
            printf("%d",T->Data);
            T=T->left;
        }
        if(!IsEmpty(S))
        {
            T=Pop(S);
            T=T->right;
        }
    }
    printf("\n");
}

void Inorder(BinTree BT)
{
    Stack S=CreateStack();
    BinTree T=BT;
    while(T||!IsEmpty(S))
    {
        while(T)
        {
            Push(S,T);
            T=T->left;
        }
        if(!IsEmpty(S))
        {
            T=Pop(S);
            printf("%d",T->Data);
            T=T->right;
        }
    }
    printf("\n");
}

void Lastorder(BinTree BT)
{
    Stack S=CreateStack();
    BinTree T=BT;
    while(T||!IsEmpty(S))
    {
        while(T)
        {
            Push(S,T);
            T=T->left;
        }
        if(!IsEmpty(S))
        {
            if(T->right)
            {
                T=T->right;
            }
            else
            {
                T=Pop(S);
                printf("%d",T->Data);
            }
        }
    }
    printf("\n");
}


int main()
{
    BinTree BT;
	BT = CreatBinTree();
	printf("Preorder:");
	Preorder(BT);
	printf("Inorder:");
	Inorder(BT);
	
}

④层序遍历

（4）二叉树遍历的应用

①输出叶结点

void Search(BinTree BT)
{
    Stack S=CreateStack();
    BinTree T=BT;
    while(T||!IsEmpty(S))
    {
        while(T)
        {
            Push(S,T);
            if(T->left==NULL&&T->right==NULL)
            {
                printf("%d",T->Data);
            }
            T=T->left;
        }
        if(!IsEmpty(S))
        {
            T=Pop(S);
            T=T->right;
        }
    }
    printf("\n");
}

4.二叉搜索树

（1）二叉搜索树的定义

（2）二叉搜索树的查找操作