判断是否为完全二叉树、二叉树最近公共节点、两个最远节点距离、搜索二叉树转双向循环链表、前中序重建二叉树

二叉树几道面试题

• 搜索二叉树面试题

#include "Stack.h"
#include "Queue.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int tydata;

typedef struct BStree{
    tydata data;
    struct BStree *pLeft;
    struct BStree *pRight;
}BStree;
//创建新节点
BStree *NewBStree(tydata data)
{
    BStree *NewNode = (BStree *)malloc(sizeof(BStree));
    assert(NewNode);
    NewNode->data = data;
    NewNode->pLeft = NewNode->pRight = NULL;

    return NewNode;
}
//构造搜索二叉树
int BStreePush(BStree **ppHead, tydata data)
{
    BStree *pCur = *ppHead;
    BStree *pNewNode = NULL;
    BStree *pNext = NULL;
    if(*ppHead == NULL)
    {
        pNewNode = NewBStree(data);
        *ppHead = pNewNode;
        return -1;
    }
    if(pCur->data == data)
    {
        return -1;
    }
    while( pCur != NULL )
    {
        pNext = pCur;
        if(data < pCur->data)
        {
            pCur = pCur->pLeft;
            if(pCur != NULL && pCur->data == data)
            {
                return -1;
            }
        }
        else
        {
            pCur = pCur->pRight;    
            if(pCur != NULL && pCur->data == data)
            {
                return -1;
            }
        }
    }
    pNewNode = NewBStree(data);
    if(data < pNext->data)
        pNext->pLeft = pNewNode;
    else
        pNext->pRight = pNewNode;
    return 1;
}

//查找节点在不在树中
BStree * BStreeFind(BStree* pRoot, int i)
{
    if(pRoot == NULL)
        return NULL;
    if(pRoot->data == i)
        return pRoot;
    BStree* targrt=NULL;    
    targrt = BStreeFind(pRoot->pLeft, i);
    if(NULL == targrt)
        targrt = BStreeFind(pRoot->pRight, i);
    return targrt;
}
//搜索二叉树的删除
void BStreeDel(BStree **pHead, tydata data)
{
    BStree *parent = *pHead;
    BStree *Del = *pHead;
    BStree *Cur = *pHead;
    assert(pHead);
    while(Del)//找要删除的节点
    {
        if(Del->data == data)
            break;
        Cur = Del;
        if(Del != NULL && Del->data > data)
        {
            Del = Del->pLeft;
        }
        else if(Del != NULL && Del->data < data)
        {
            Del = Del->pRight;
        }
    }
    if(Del->pRight == NULL)//要删除的节点右树为空
    {
        if(Del != *pHead)//非根节点
        {
            if(Cur->data > data)
                Cur->pLeft = Del->pLeft;
            else
                Cur->pRight = Del->pLeft;
        }
        else//根节点
        {
            *pHead = Del->pLeft;
        }
        free(Del);
    }
    else if(Del->pLeft == NULL)//要删除的节点右树为空
    {
        if(Del != *pHead)//非根节点
        {
            if(Cur->data > data)
                Cur->pLeft = Del->pRight;
            else
                Cur->pRight = Del->pRight;
        }
        else//根节点
        {
            *pHead = Del->pRight;
        }
        free(Del);
    }
    else//要删除的节点左右树都不为空
    {
        Cur = Del;
        Del = Del->pRight;
        parent = Cur;
        while(Del->pLeft != NULL)//找左树中最小的，代替这个节点
        {
            parent = Del;
            Del = Del->pLeft;
        }
        Cur->data = Del->data;
        if(parent == Cur)
            parent->pRight = Del->pRight;
        else
            parent->pLeft = Del->pRight;
        free(Del);
    }
}
//搜索二叉树中插入节点
int BStreePush1(BStree **ppHead,tydata data)
{
    if(*ppHead == NULL)
    {
        *ppHead = NewBStree(data);
        return 1;
    }
    if((*ppHead)->data < data)
    {
        return BStreePush1(&(*ppHead)->pRight,data);
    }
    else if((*ppHead)->data > data)
    {
        return BStreePush1(&(*ppHead)->pLeft,data);
    }
    return -1;
}

//层序遍历（利用队列特性）
void sequence(BStree *pRoot)
{
    Queue queue;
    BStree *pTop;
    QueueInit(&queue);
    QueuePush(&queue, pRoot);
    while(!(QueueIsEmpty(&queue)))
    {
        pTop = (BStree *)QueueFront(&queue);
        printf("%d ", pTop->data);
        QueuePop(&queue);
        if(pTop->pLeft != NULL)
            QueuePush(&queue, pTop->pLeft);
        if(pTop->pRight != NULL)
            QueuePush(&queue, pTop->pRight);
    }
    printf("\n");
}

//求两个节点的公共节点（方法1）左右找，找到了返回节点，找不到返回空
//当左右都不为空，则找到公共节点，然后返回
BStree* AncestralNode(BStree *pRoot, int i, int j)
{
    if(pRoot == NULL)
        return NULL;
    if(pRoot->data == i || pRoot->data == j)
        return pRoot;
    BStree *Left, *Right;
    Left = AncestralNode(pRoot->pLeft, i, j);
    Right = AncestralNode(pRoot->pRight, i, j);
    if(Left != NULL && Right != NULL)
        return pRoot;
    if(Left)
        return left;
    else
        return Right;
}
//求两个节点的公共节点（方法2），从左右树中分别先找这两个节点
//如果两个节点在同一侧，则继续往这一侧找
//如果两个节点分别在左侧跟右侧，则找到公共节点，返回这个根节点。
BStree *AncestralNode(BStree *pRoot, int i, int j)
{
    if(pRoot == NULL)
        return NULL;
    if(pRoot->data == i || pRoot->data == j)
        return pRoot;
    BStree *ipLeft = BStreeFind(pRoot->pLeft, i);
    BStree *ipRight= BStreeFind(pRoot->pRight, i);
    BStree *jpLeft = BStreeFind(pRoot->pLeft, j);
    BStree *jpRight= BStreeFind(pRoot->pRight, j);
    if((ipLeft && jpRight) ||(ipRight && jpLeft) )
        return pRoot;
    else if(ipLeft && jpLeft)
        return AncestralNode(pRoot->pLeft, i, j);
    else if(ipRight && jpRight)
        return AncestralNode(pRoot->pRight, i, j);
    else
        return NULL;
}
*/

BStree* arr2[20] = {};
BStree* arr1[20] = {};
//求两个节点的公共节点（方法3），保存根节点到两个节点的路径（节点地址），存到两个数组中
//然后找出两个数组中从根节点往后，最后一个相同的地址，就是最近公共节点了。
void * AncestralNode(BStree *pRoot, int i, int j)
{
    int k;
    BStree *pCur = pRoot;
    BStree *pTop;
    Stack stack;
    BStree *pLast;
    memset(arr1, 0x00, sizeof(arr1));
    memset(arr2, 0x00, sizeof(arr2));
    StackInit(&stack);
    while(pCur || !(StackIsEmpty(&stack)))
    {
        while(pCur)
        {
            StackPush(&stack, pCur);
            pCur = pCur->pLeft;
        }
        pTop = StackTop(&stack);
        if(pTop->pRight == NULL || pTop->pRight == pLast)
        {
            if(pTop->data == i)
            {
                for(k=0; k<(stack.size); k++)
                {
                    arr2[k] = stack.data[k];
                }
            }
            if(pTop->data == j)
            {
                for(k=0; k<(stack.size); k++)
                {
                    arr1[k] = stack.data[k];
                }
            }
            pLast = pTop;
            StackPop(&stack);
            continue;
        }
        pCur = pTop->pRight;
    }
}
//是否为平衡树
int IsBalance(BStree *pRoot)
{
    if(pRoot == NULL)
        return 1;
    int left;
    int right;
    int lefthight = hight(pRoot->pLeft);
    int righthight = hight(pRoot->pRight);
    int balance = lefthight - righthight;
    left = IsBalance(pRoot->pLeft);
    if(left == 0)
        return 0;
    right = IsBalance(pRoot->pRight);
    if(right == 0)
        return 0;
    if(balance==1 || balance==0 || balance==-1)
        return 1;
    else
        return 0;
}

//判断是否为完全二叉树
void IsCompletely(BStree *pRoot)
{
    //层序遍历二叉树，保存所有节点。
    Queue queue;
    BStree *qu[30] = {0};
    int n,m = 0,flag = 0;
    BStree *pTop;
    memset(qu, 0x00, sizeof(qu));
    QueueInit(&queue);
    QueuePush(&queue, pRoot);
    qu[m++] = pRoot;
    while(!(QueueIsEmpty(&queue)))
    {
        pTop = (BStree *)QueueFront(&queue);
        printf("%d ", pTop->data);
        QueuePop(&queue);
        if(pTop->pLeft != NULL)
            QueuePush(&queue, pTop->pLeft),qu[m++] = pTop->pLeft;
        else qu[m++] = NULL;
        if(pTop->pRight != NULL)
            QueuePush(&queue, pTop->pRight),qu[m++] = pTop->pRight;
        else qu[m++] = NULL;
    }
    printf("\n");
    //如果遇到空节点，后面如果再出现非空节点则不是完全二叉树
    for(n=0; n<m; n++)
    {
        if(qu[n]!=NULL)
        {
            printf("%p ", qu[n]);
            if(flag == 1)
                flag = 3;
        }
        else
        {
            printf("NULL ");
            if(flag == 0)
            flag = 1;
        }

    }
    printf("\n");
    if(flag == 3)
        printf("NO Comletely\n");
    else printf("is Completely\n");
}
//求两个节点之间的最远距离
int  MostFarNode(BStree *pRoot)
{
    if(pRoot == NULL)
        return 0;
    int lefthight = hight(pRoot->pLeft);
    int righthight = hight(pRoot->pRight);
    int leftAndright = lefthight + righthight;
    int left = MostFarNode(pRoot->pLeft);
    int right = MostFarNode(pRoot->pRight);
    if(leftAndright > left && leftAndright > right)
        return leftAndright;
    else if(left > right && left > leftAndright)
        return left;
    else
        return right;
}
//求二叉树的镜像树
void image(BStree **pHead)
{
    if(*pHead == NULL)
        return;

    BStree *tmp = (*pHead)->pLeft;
    (*pHead)->pLeft = (*pHead)->pRight;
    (*pHead)->pRight = tmp;

    image(&((*pHead)->pLeft));
    image(&((*pHead)->pLeft));
}
//根据前序和中序重建二叉树
BStree *bebulid(char **arr1, char *arr2, int left, int right)
{
    //数组走到最后最后一个节点构造完成  返回一个空指针
    if((**arr1 == '\0'))
        return NULL;
    //在中序中找每个点的左右树， 如果left>=right说明没有左右树，返回空指针
    if(left >= right)
        return NULL;
    int i = left;
    char c = **arr1;
    BStree *p = NULL;
    //在中序中查找当跟节点，以便找出 前序中当前节点 在中序中的左右树，
    while(i < right)
    {
        if(c == arr2[i])
            break;
        i++;
    }
    //构建当前节点
    p = (BStree *)malloc(sizeof(BStree));
    p->data = **arr1;
    (*arr1)++;
    //构建左右树
    p->pLeft = bebulid(arr1, arr2, left, i);
    p->pRight = bebulid(arr1, arr2, i+1, right);
    return p;
}
//打印数组
void printarr(BStree *pHead)
{
    if(pHead == NULL)
        return;
    printf("%c ",pHead->data);
    printarr(pHead->pLeft);
    printarr(pHead->pRight);
}
//搜索二叉树转成有序的双向链表。
BStree *DoubleListHead = NULL;

BStree *DoubleList(BStree *pHead,BStree **prev)
{
    if(pHead == NULL)
        return NULL;
    DoubleList(pHead->pLeft, prev);
    if((*prev) != NULL){
        (*prev)->pRight = pHead;
    }
    pHead->pLeft = *prev;
    if(DoubleListHead == NULL)
        DoubleListHead = pHead;
    (*prev) = pHead;
    DoubleList(pHead->pRight, prev);
}
//打印双向链表
void prinfDoubleList()
{
    BStree *pCur = DoubleListHead;
    while(pCur)
    {
        printf("%d ",pCur->data);
        pCur = pCur->pRight;
    }
    printf("\n");
}

void BStree( void )
{
    int i;
    BStree *pHead = NULL;
    BStree *find = NULL;
    //前中序重建二叉树的俩数组
    char* arr3 = "abdcef";
    char* arr4 = "dbaecf";
    int right = strlen(arr4);
    BStree *prev = NULL;
    BStree* bulid = NULL;
    //插入节点
    BStreePush(&pHead,5);
    BStreePush(&pHead,3);
    BStreePush(&pHead,4);
    BStreePush(&pHead,7);
    BStreePush(&pHead,9);
    BStreePush(&pHead,1);
    BStreePush(&pHead,2);
    BStreePush(&pHead,6);
    BStreePush(&pHead,12);
    BStreePush(&pHead,17);
    BStreePush(&pHead,10);
    BStreePush1(&pHead,8);
    Print(pHead);
    printf("\n");
    //查找
    find = BStreeFind(pHead, 2);
    if(find != NULL) printf("Find it,the num is %d\n",find->data);
    else printf("con't find\n");
    //前中后序遍历
    printf("BStreeOrder\n"),BStreeOrder(pHead);
    printf("MiddleOrder\n"),Middleorder(pHead);
    printf("PreOrder\n"),Preorder(pHead);
    //层序遍历
    printf("sequence\n"),sequence(pHead);
    //两个节点的公共节点  
    AncestralNode(pHead, 2, 17);
    if(find != NULL) printf("Find it,the Ancestral is %d\n",find->data);
    else printf("con't find\n");
    //根节点到两个节点的分别路径
    printf("arr1:");
    for(i=0; arr1[i]!=NULL; i++) {printf("%d ", arr1[i]->data);}
    printf("\n"),printf("arr2:");
    for(i=0; arr2[i]!=NULL; i++) {printf("%d ", arr2[i]->data);} printf("\n");
    //是否为平衡二叉树
    i = IsBalance(pHead);
    if(i == 1)
        printf("yes\n");
    else
        printf("no\n");
    //是否为完全二叉树
    IsCompletely(pHead);
    //最远的两个节点的距离
    printf("MostFarNode is %d\n", MostFarNode(pHead));
    //镜像二叉树
    //image(&pHead);
    //层序遍历
    printf("sequence\n"),sequence(pHead);
    //重建二叉树
    bulid = bebulid(&arr3, arr4, 0, right);
    printarr(bulid);
    printf("\n");
    //搜索二叉树转链表
    DoubleList(pHead, &prev);
    prinfDoubleList();
}

• 二叉树面试题

#pragma once
#include "Stack.h"
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>

typedef char    DataType;

struct BinaryTreeNode {
    DataType    data;
    int left;
    int right;
    struct BinaryTreeNode   *pLeft;
    struct BinaryTreeNode   *pRight;
};

typedef struct BinaryTreeNode BTNode;

//根据数组构建二叉树
BTNode * BuildTree(DataType array[], int size, int *pIndex)
{   
    BTNode *Node;
    if((*pIndex) >= size)
        return NULL;
    if(array[*(pIndex)] == '#')
    {
        (*pIndex)++;
        return NULL;
    }

    Node = (BTNode *)malloc(sizeof(BTNode));
    Node->data = array[*pIndex];
    assert(Node);
    (*pIndex)++;
    Node->pLeft = BuildTree(array, size, pIndex);
    Node->pRight = BuildTree(array, size, pIndex);

    return Node;
}
//前序遍历
void PrintPreOrder(BTNode *pRoot)
{
    if(pRoot == NULL)
        return;
    printf("%c ",pRoot->data);
    PrintPreOrder(pRoot->pLeft);
    PrintPreOrder(pRoot->pRight);
}
//中序遍历
void PrintMiddleOrder(BTNode *pRoot)
{
    if(pRoot == NULL)
        return;
    PrintMiddleOrder(pRoot->pLeft);
    printf("%c ",pRoot->data);
    PrintMiddleOrder(pRoot->pRight);
}
//后序遍历
void PrintPostOrder(BTNode *pRoot)
{
    if(pRoot == NULL)
        return;
    PrintPostOrder(pRoot->pLeft);
    PrintPostOrder(pRoot->pRight);
    printf("%c ",pRoot->data);
}
//数的节点个数为
int TreeNodes(BTNode *pRoot)
{
    if(pRoot == NULL)
        return 0;
    return 1+TreeNodes(pRoot->pLeft)+TreeNodes(pRoot->pRight);
}
//树的高度
int TreeHight(BTNode *pRoot)
{
    int a,b;
    if(pRoot == NULL)
        return 0;
    //if(pRoot->pLeft == NULL && pRoot->pRight == NULL)
    //  return 1;
    a = TreeHight(pRoot->pLeft)+1;
    b = TreeHight(pRoot->pRight)+1;
    return a>b?a:b;
}
//叶子节点个数
int TreeLeaf(BTNode *pRoot)
{
    if(pRoot == NULL)
        return 0;
    if(pRoot->pLeft==NULL && pRoot->pRight == NULL)
        return 1;
    return TreeLeaf(pRoot->pLeft) + TreeLeaf(pRoot->pRight);
}
//第K层节点数
int TreeOfK(BTNode *pRoot, int k)
{
    if(pRoot == NULL)
        return 0;
    if(pRoot != NULL && k == 1)
        return 1;
    if(pRoot == NULL && k == 1)
        return 0;
    return TreeOfK(pRoot->pLeft, k-1) + TreeOfK(pRoot->pRight, k-1);
}
//非递归中序遍历
void PrintMiddleOder(BTNode *pRoot)
{
    BTNode *cur;
    BTNode *top;
    Stack stack;
    StackInit(&stack);
    cur = pRoot;
    while(cur != NULL || !StackIsEmpty(&stack))
    {
        while(cur != NULL)
        {
            StackPush(&stack,cur);
            cur = cur->pLeft;
        }

        top = StackTop(&stack);
        printf("%c",top->data);
        StackPop(&stack);

        cur = top->pRight;
    }
    printf("\n");
}
//非递归前序遍历
void PrintPreOder(BTNode *pRoot)
{
    BTNode *cur;
    BTNode *top;
    Stack stack;
    StackInit(&stack);
    cur = pRoot;
    while(cur != NULL || !StackIsEmpty(&stack))
    {
        while(cur != NULL)
        {
            printf("%c",cur->data);
            StackPush(&stack,cur);
            cur = cur->pLeft;
        }

        top = StackTop(&stack);
        StackPop(&stack);

        cur = top->pRight;
    }
    printf("\n");
}
//非递归后序遍历
void PrintPostOder(BTNode *pRoot)
{
    BTNode *cur;
    BTNode *top;
    Stack stack;
    BTNode *last;
    StackInit(&stack);
    cur = pRoot;
    while(cur != NULL || !StackIsEmpty(&stack))
    {
        while(cur != NULL)
        {
            StackPush(&stack,cur);
            cur = cur->pLeft;
        }

        top = StackTop(&stack);
        if(top->pRight == NULL || top->pRight == last)
        {
            printf("%c",top->data);
            last = StackTop(&stack);
            StackPop(&stack);
            continue;
        }

        cur = top->pRight;
    }
    printf("\n");
}

//查看一个节点在不在树中
BTNode *IsInTree(BTNode *pRoot,char data)
{
    BTNode *root;
    if(pRoot == NULL)
        return NULL;
    if(pRoot->data == data)
        return pRoot;
    root = IsInTree(pRoot->pLeft,data);
    if(root!=NULL && root->data==data)
        return root;
    return IsInTree(pRoot->pRight,data);
}

//求两个节点的最近公共祖先结点
BTNode *CommonNode(BTNode *pRoot,char data1,char data2)
{
    BTNode *pLeft;
    BTNode *pRight;
    if(pRoot == NULL)
        return NULL;
    if(pRoot->data == data1||pRoot->data ==data2)
        return pRoot;
    pLeft = CommonNode(pRoot->pLeft, data1, data2);
    pRight = CommonNode(pRoot->pRight, data1, data2);
    if(pLeft && pRight)
        return pRoot;
    if(pLeft == NULL)
        return pRight; 
    else
        return pLeft;
}



int max = 0;
//求最远的两个节点之间的距离
void MaxLen(BTNode *pRoot)
{
    int i = 0;
    if(pRoot == NULL)
        return;
    if(pRoot->pLeft == NULL)
        pRoot->left = 0;
    if(pRoot->pRight == NULL)
        pRoot->right = 0;
    if(pRoot->pLeft != NULL)
        MaxLen(pRoot->pLeft);
    if(pRoot->pRight != NULL)
        MaxLen(pRoot->pRight);
    if(pRoot->pLeft != NULL)
    {
        if(pRoot->pLeft->left > pRoot->pLeft->right)
            i = pRoot->pLeft->left;
        else
            i = pRoot->pLeft->right;
        pRoot->left = i+1;
    }
    if(pRoot->pRight != NULL)
    {
        if(pRoot->pRight->left > pRoot->pRight->right)
            i = pRoot->pRight->left;
        else
            i = pRoot->pRight->right;
        pRoot->right = i+1;
    }

    if(pRoot->left + pRoot->right > max)
        max = pRoot->left + pRoot->right;
}
//中序模式下
//二叉树转双链表
void Changed(BTNode *pRoot, BTNode **prev)
{
    if(pRoot == NULL)
        return;
    Changed(pRoot->pLeft, prev);
    if((*prev) != NULL)
        (*prev)->pRight = pRoot;
    pRoot->pLeft = (*prev);
    (*prev) = pRoot;
    Changed(pRoot->pRight, prev);
}
//二叉树转双链表
BTNode *DListForTree(BTNode *pRoot)
{
    BTNode *pHead = pRoot;
    BTNode *prev = NULL;
    Changed(pRoot, &prev);
    while(pHead->pLeft!= NULL)
    {
        pHead = pHead->pLeft;
    }
    return pHead;
}

void BTNode()
{
    BTNode *DList;
    BTNode *pRoot;
    BTNode *pNode;
    BTNode *pComNode;
    char array[] = { 'A', 'B', 'D', 
        '#', '#', '#', 'C', 'E', '#', '#', 'F' };
    int index = 0;
    int k = 3;
    pRoot = BuildTree(array, sizeof(array) / sizeof(char), &index);
    PrintPreOrder(pRoot);
    printf("\n");
    PrintMiddleOrder(pRoot);
    printf("\n");
    PrintPostOrder(pRoot);
    printf("\n");
    printf("数的节点个数为 %d\n",TreeNodes(pRoot));
    printf("树的高度为%d\n",TreeHight(pRoot));
    printf("叶子节点个数为%d\n",TreeLeaf(pRoot));
    printf("第K层的节点个数%d\n",TreeOfK(pRoot,k));
    printf("前序打印为");
    PrintPreOder(pRoot);    
    printf("中序打印为");
    PrintMiddleOder(pRoot);
    printf("后序打印为");
    PrintPostOder(pRoot);
    pNode = IsInTree(pRoot,'F');
    if(pNode !=NULL)
        printf("该节点存在地址为%p\n",pNode);
    pComNode =  CommonNode(pRoot, 'C','D');
    printf("公共祖先节点为%c", pComNode->data);
    MaxLen(pRoot);
    printf("两个节点之间最长的距离为%d\n",max);
    printf("前序打印为\n");
    //将二叉搜索树变为双向链表
    DList = DListForTree(pRoot);
    printf("转为链表后的输出\n");
    while(DList)
    {
        printf("%c", DList->data);
        DList = DList->pRight;
    }
    printf("\n");
}

• 栈头文件

#pragma once

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

#define CAPACITY 6
int k = 0;

typedef void * typedata;

typedef struct Stack
{
    typedata *data;
    int size;
    int capacity;
}Stack;

void StackInit(Stack *stack)
{
    stack->capacity = CAPACITY;
    stack->size = 0;
    stack->data = (typedata *)malloc(sizeof(typedata)*stack->capacity);
    assert(stack->data);
}
void IsDilatation(Stack **stack)
{
    Stack *st = *stack;
    if (st->size == st->capacity)
    {
        typedata *New = (typedata *)malloc(sizeof(typedata)*(st->capacity) * 2);
        free(st->data);
        memcpy(New, st->data, sizeof(typedata)*(st->capacity));
        st->data = New;
        st->capacity *= 2;
    }
}

void StackPush(Stack *stack, typedata data)
{
    IsDilatation(&stack);
    assert(stack);
    stack->data[stack->size++] = data;
}
typedata StackTop(Stack *stack)
{
    return stack->data[stack->size - 1];
}
void StackPop(Stack* stack)
{
    assert(stack->size>0);
    stack->size -= 1;
}

int StackIsEmpty(Stack *stack)
{
    return (stack->size == 0) ? 1 : 0;
}

• 队列头文件

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

typedef void * queuedata;

typedef struct QNode
{
    queuedata data;
    struct QNode *QNext;
}QNode;

typedef struct Queue
{
    QNode *pHead;
    QNode *pNext;
    int size;
}Queue;


void QueueInit(Queue *q)
{
    q->pHead = NULL;
    q->pNext = NULL;
    q->size = 0;
}

void QueueDestory(Queue *q)
{
    QNode *pNode, *pNext;
    assert(q);
    for(pNode = q->pHead; pNode != NULL; pNode = pNext)
    {
        pNext = pNode->QNext;
        free(pNode);
    }
    q->pHead = q->pNext = NULL;
    q->size = 0;
}



void QueuePush(Queue *q, queuedata data)
{
    QNode *New = (QNode *)malloc(sizeof(QNode));
    assert(q);
    assert(New);
    New->data = data;
    New->QNext = NULL;
    q->size++;
    if(q->pHead == NULL)
    {
        q->pHead = q->pNext = New;
        return;
    }
    q->pNext->QNext = New;
    q->pNext = New;
}

void QueuePop(Queue *q)
{
    QNode *Qdel = q->pHead;
    assert(q->pHead);
    q->pHead = Qdel->QNext;
    free(Qdel);
    q->size--;
    if(q->size == 0)
    {
        q->pHead = q->pNext = NULL;
    }
}

queuedata QueueFront(Queue *q)
{
    if(q->pHead == NULL)
        return NULL;
    return q->pHead->data;
}

int QueueSize(Queue *q)
{
    assert(q);
    return q->size;
}

int QueueIsEmpty(Queue *q)
{
    return q->size == 0 ? 1 : 0;
}

int main()
{
    void BStree();
    void void BTNode();
}