数据结构--树

1.非递归创建

    BiTree st[100],pr=NULL;
    int flag = 0;
    int n = 0;
    int a = 0;
    for (int j = 0; j < i; j++)
    {
        if (definition[j].key != 0)
        {
            //建立节点
            T = (BiTNode*)malloc(sizeof(BiTNode));
            T->data.key = definition[j].key;
            T->lchild = T->rchild = NULL;
            strcpy_s(T->data.others, definition[j].others);
            //连接节点
            if (n >0)
            {
                //确定连接方向
                if (flag)
                {
                    flag = 0;
                    st[--n]->rchild = T;
                }
                else
                    st[n - 1]->lchild = T;
                if (!a)//保留头节点
                {
                    a = 1;
                    p = st[0];

                }
            }
            st[n++] = T;

        }
        else {
            if (flag)
            {
                st[--n]->rchild = NULL;
            }
            else
            {
                st[n-1]->lchild = NULL;
                flag = 1;
            }
            


        }
    }

  2.非递归删除

status ClearBiTree(BiTree& T)
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int n = 0, a = 1;
    BiTree st[100], pr, sa=T ;
    int flag = 0;
    
    while (n != 0 || a == 1) {
        a = 0;//为了第一次n=0时可以通过
        flag = 0;
        T = sa;

        while (!flag && T)
        {
            pr = T;//入栈元素
            st[n++] = pr;
            T = T->lchild;
            if (!T)
            {
                T = pr->rchild;
                if (!T)
                {
                    free(st[--n]);//左右为0.出栈，置空
                    //因为有栈储存，且删除时无需保留树的关系，所以可用置空标记
                    flag = 1;//到叶子了，开始回溯
                }
                else
                {
                    pr->rchild = NULL;//标记已读位
                }
            }
            else
            {
                pr->lchild = NULL;//标记已读位
            }
        }
        int sin = 1;
        while (sin  !=0&&n>0)//回溯，寻找可能分支
        {
            sin = 0;
            if (n > 0) {
                if (!st[n - 1]->lchild)
                {
                    if (!st[n - 1]->rchild)
                    {
                        free(st[--n]);//此节点无可读分支，置空，继续向上回溯
                        sin = 1;
                    }
                    else
                    {
                        sa = st[n - 1]->rchild;
                        st[n - 1]->rchild = NULL;
                    }
                }
                else
                {
                    sa = st[n - 1]->lchild;
                    st[n - 1]->lchild = NULL;
                }
            }
        }

    }
    return 0;

    /********** End **********/
}

3.非递归求深度

int BiTreeDepth(BiTree T)
//求二叉树T的深度
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int max = 0;
    int mid = 0, n = 0;
    BiTree st[100], pr;
    int flag = 0;

    while (T || n > 0)
    {
        st[n++] = T,a;//a储存上一个出栈元素
        //由于先取左孩再取右孩，当上一出栈位非空且为回溯点的右孩时，节点分支以走完，继续向上回溯
        pr = T;
        mid++;
        flag = 1;
        while (flag&&n>0)//找下一个目标位
        {
            flag = 0;
            if(a&&T->rchild==a)
            {
                a=st[n--];
                flag=1;
                T=st[n-1];
                if(n==1)
                {
                    T=NULL;
                    n=0;
                    }


            }
            else if (T->lchild)
            {
                T = T->lchild;
                pr->lchild = NULL;

            }
            else {
                if (T->rchild)
                {
                    T = T->rchild;
                    pr->rchild = NULL;
                }
                else//无可走位，回溯
                {
                    max = max > mid ? max : mid;
                    a=st[n--];
                    
                    flag = 1;
                    pr=T = st[n - 1];
                    mid--;
                    if (n == 0)
                        T = NULL;
                }
            }
        }
    }
    return max;


    /********** End **********/
}

4.查找

BiTNode* LocateNode(BiTree T, KeyType e)
{   
 BiTree st[100], pr,a;
    int n = 0, flag = 0;
    while (T || n > 0)
    {
        if (T->data.key == e)//查找节点
            return T;
        st[n++] = T;//入栈
        flag = 1;
        while (flag)
        {
            flag = 0;
            pr = T;
            if(a&&T->rchild==a)
            {
                    a=st[n--];
                    flag = 1;
                    if (n)
                        T = st[n - 1];
                    else//结尾，标记退出
                    {
                        T = NULL;
                        flag = 0;
                    }

            }
            else if (T->lchild)//寻找下一节点
            {
                T = T->lchild;
                pr->lchild = NULL;//标记
            }

            else {
                if (T->rchild)
                {
                    T = T->rchild;
                    pr->rchild = NULL;
                }
                else//出栈，向上回溯
                {
                    a=st[n--];
                    flag = 1;
                    if (n)
                        T = st[n - 1];
                    else//结尾，标记退出
                    {
                        T = NULL;
                        flag = 0;
                    }
                }
            }
        }

    }
    
    return NULL;
}