补充

创建二叉树

void CreateBiTree(BiTree* T)
{
    TElemType ch;
    scanf("%c",&ch);
    if(ch == '#')
        *T = NULL;
    else
    {
        *T = (BiTree)malloc(sizeof(BiTNode));
        if(!*T)
            exit(OVERFLOW);
        (*T)->data = ch;
        CreateBiTree(&(*T)->lchild);
        CreateBiTree(&(*T)->rchild);    
    }   
}

线索二叉树：指向前驱和后继的指针称为线索，加上线索的二叉树称为线索二叉树；

• 把空指针域中的rchild改为指向它的后继结点
• 把空指针域中的lchild改为指向当前结点的前驱

其实线索二叉树，等于把一颗二叉树变成了了一个双向链表

对二叉树以某种次序遍历使其变为线索二叉树的过程称为线索化

如何知道某一节点的lchild是指向它的左孩子还是指向前驱，rchild是指向右孩子还是指向后继？

• 我们在每个结点再增加两个标志域：
• lchild ltag data rtag rchild

线索二叉树结构实现

typedef enum{Link,Thread} PointerTag;

typedef struct BiThrNode
{
    TElemType data;
    struct BiThrNode* lchild,*rchild;
    PointerTag LTag;
    PointerTag RTag;    
}BiThrNode,*BiThrTree;

线索化的过程就是在遍历的过程中修改空指针的过程

如果所用的二叉树需经常遍历或查找结点时需要某种遍历序列中的前驱和后继，那么采用线索二叉链表的存储结构非常不错

二叉排序树（二叉查找树）

• 若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值
• 若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值
• 它的左右子树分别为二叉排序树

若查找成功指针p，指向该数据元素结点，返回true
否则指针p指向查找路径上访问的最后一个结点
指针f指向T的双亲，其开始调用值为NULL

    Status SearchBST(BiTree T,int key,BiTree f,BiTree *p)
    {
        if(T == NULL)
        {
                *p = f;
                return false;
        }
        else if(key == T->data)
        {
            *p = T;
            return true;
        }
        else if(key < T->data)
            return SearchBST(T->lchild,key,f,p);
        else
            return SearchBST(T->rchild,key,f,p);
    }

Status InsertBST(BiTree *T,int key)
{
    BiTree p,s;
    if(!SearchBST(*T,key,NULL,&p))
    {
        s = (BiTree)malloc(sizeof(BiTNode));
        s->data = key;
        s->lchild = s->rchild = NULL;
        if(!p)
            *T = s;
        else if(key < p->data)
            p->lchild = s;
        else
            p->rchild = s;
        return true;    
    }   
}

二叉排序树是以链接的方式存储，保持了链接存储结构在执行插入和删除操作时不用移动元素的优点，仅需修改链接指针
查找的事件复杂度就为O(logn)

平衡二叉树：是一种二叉排序树，其中每一个节点的左子树和右子树的高度差至多等于1

排序

#define MAXSIZE 10
typedef struct
{
    int r[MAXSIZE];
    int length;     
}SqList;  

void swap(SQList* L, int i,int j）
{
    int temp = L->r[i];
    L->r[i] = L->r[j];
    L->r[j] = temp; 
}

冒泡：

void BubbleSort(SqList *L)
{
    int i, j;
    int exchange = 1;   
    for(i=0;i<L->length && exchange;i++)
    {
        exchange = 0;       
        for(j = L->length-1;j>i;j--)
        {
            if(L->r[j] < L->r[j-1])
            {           
                swap(L,j,j-1);
                exchange = 1;
            }           
        }       
    }       
}

O(n的平方)

选择排序

void SelectSort(SqList *L)
{
    int i,j,k;
    for(i=0;i<L->length;i++)
    {
        k = i;
        for(j=i;j<L->length;j++)
        {
            if(SqList->r[j] < SqList->r[k])
                k = j;
        }
        swap(L,i,k);
    }   
}

插入排序