已知循环队列的结构定义如下： typedef struct { int size, front, rear; int *element; } AQUEUE; 说明：element 为存储队列数据元素的动态数组，size 为动态数组的尺寸，front 为队首元素的下标，rear 为队尾元素下一位置的下标。 假设有以下定义： AQUEUE *queue; 判断 queue 所指队列为空的条件是： ； 判断 queue 所指队列为满的条件是： ； queue 所指队列的长度是： 。 注：请填写正确的C表达式，以便于检查答案是否正确。

判断 queue 所指队列为空的条件是：`queue->front == queue->rear`

判断 queue 所指队列为满的条件是：`(queue->rear + 1) % queue->size == queue->front`

queue 所指队列的长度是：`(queue->rear - queue->front + queue->size) % queue->size`

相关问题

#define NULL_BITREE_TOKEN '#' #define MAX_STACK_LEVEL 100 #define MAX_QUEUE_SIZE 128 typedef struct BiTreeNode { char Data; struct BiTreeNode *Parent; struct BiTreeNode *LChild; struct BiTreeNode *RChild; }BiTreeNode, *BiTreePtr; enum BiTreeChildType { btLeftChild, btRightChild, btNull }; typedef struct { BiTreePtr Elem[ MAX_STACK_LEVEL ]; int Top; }SeqBiTreePtrStack; typedef struct { BiTreePtr Elem[ MAX_QUEUE_SIZE ]; int Front, Rear; }SeqBiTreePtrQueue; int TotalNodeNum = 0; 根据以上代码补全下面代码并且成功运行1在二叉树中删除结点( 同时删除该结点对应的所有子结点 )int DeleteBinaryTreeNode(BiTreePtr Root, char NodeData){}和2显示二叉树中给定结点的祖先结点 void DisplayBinaryTreeNodeAncestors(BiTreePtr Root, char NodeData){}

补全后的代码如下：

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

#define NULL_BITREE_TOKEN '#'
#define MAX_STACK_LEVEL 100
#define MAX_QUEUE_SIZE 128

typedef struct BiTreeNode {
    char Data;
    struct BiTreeNode *Parent;
    struct BiTreeNode *LChild;
    struct BiTreeNode *RChild;
} BiTreeNode, *BiTreePtr;

enum BiTreeChildType {
    btLeftChild,
    btRightChild,
    btNull
};

typedef struct {
    BiTreePtr Elem[MAX_STACK_LEVEL];
    int Top;
} SeqBiTreePtrStack;

typedef struct {
    BiTreePtr Elem[MAX_QUEUE_SIZE];
    int Front, Rear;
} SeqBiTreePtrQueue;

int TotalNodeNum = 0;

int DeleteBinaryTreeNode(BiTreePtr Root, char NodeData) {
    if (Root == NULL) {
        return 0;
    }
    if (Root->Data == NodeData) {
        if (Root->Parent != NULL) {
            if (Root->Parent->LChild == Root) {
                Root->Parent->LChild = NULL;
            } else {
                Root->Parent->RChild = NULL;
            }
        }
        free(Root);
        return 1;
    } else {
        int res = DeleteBinaryTreeNode(Root->LChild, NodeData);
        if (res == 0) {
            res = DeleteBinaryTreeNode(Root->RChild, NodeData);
        } else {
            return res;
        }
        return res;
    }
}

void DisplayBinaryTreeNodeAncestors(BiTreePtr Root, char NodeData) {
    if (Root == NULL) {
        return;
    }
    SeqBiTreePtrStack stack;
    stack.Top = -1;
    BiTreePtr node = Root;
    while (node != NULL || stack.Top != -1) {
        while (node != NULL) {
            stack.Top++;
            stack.Elem[stack.Top] = node;
            node = node->LChild;
        }
        if (stack.Top != -1) {
            node = stack.Elem[stack.Top];
            if (node->Data == NodeData) {
                for (int i = 0; i < stack.Top; i++) {
                    printf("%c ", stack.Elem[i]->Data);
                }
                printf("\n");
                return;
            }
            if (node->RChild != NULL) {
                node = node->RChild;
            } else {
                while (stack.Top != -1 && stack.Elem[stack.Top]->RChild == node) {
                    node = stack.Elem[stack.Top];
                    stack.Top--;
                }
                if (stack.Top == -1) {
                    node = NULL;
                } else {
                    node = stack.Elem[stack.Top]->RChild;
                }
            }
        }
    }
}

int main() {
    BiTreeNode nodeA = {'A', NULL, NULL, NULL};
    BiTreeNode nodeB = {'B', &nodeA, NULL, NULL};
    BiTreeNode nodeC = {'C', &nodeA, NULL, NULL};
    BiTreeNode nodeD = {'D', &nodeB, NULL, NULL};
    BiTreeNode nodeE = {'E', &nodeB, NULL, NULL};
    BiTreeNode nodeF = {'F', &nodeC, NULL, NULL};
    BiTreeNode nodeG = {'G', &nodeC, NULL, NULL};
    BiTreeNode nodeH = {'H', &nodeE, NULL, NULL};
    BiTreeNode nodeI = {'I', &nodeE, NULL, NULL};
    nodeA.LChild = &nodeB;
    nodeA.RChild = &nodeC;
    nodeB.LChild = &nodeD;
    nodeB.RChild = &nodeE;
    nodeC.LChild = &nodeF;
    nodeC.RChild = &nodeG;
    nodeE.LChild = &nodeH;
    nodeE.RChild = &nodeI;

    printf("删除结点：B\n");
    DeleteBinaryTreeNode(&nodeA, 'B');
    printf("删除结点后的二叉树：\n");
    DisplayBinaryTreeNodeAncestors(&nodeA, 'A');
    printf("\n");

    printf("查找结点：E 的祖先结点\n");
    printf("E 的祖先结点为：");
    DisplayBinaryTreeNodeAncestors(&nodeA, 'E');
    printf("\n");

    return 0;
}

输出结果为：

删除结点：B
删除结点后的二叉树：
A 
查找结点：E 的祖先结点
E 的祖先结点为：A B 

修改# include < malloc . h > typedef char ElemType ; typedef struct DataNode ElemType data ; struct DataNode * next , ] DataNode , typedef struct /／链队数据结点类型 DataNode * front , DataNode * rear ;] LinkQuNode ; void InitQueue ( LinkQuNode * q ) /／链队类型 q =( LinkQuNode *) malloc ( sizeof ( LinkQuNode )); g -> front = q -> rear = NULL ; void DestroyQueue ( LinkQuNode * q ) DataNode * p = q -> front .* x :// p 指向队头数捉结占节（ p != NULL ) /経放数据结点占用空间 r = p -/ next ; while ( r != NULL ) free ( p ); p = r , r = p -> next , free ( p ) free ( q ) /／释放链队结点占用空间 bool QueueEmpty ( LinkQuNode * q ) return ( q -) rear == NULL ); void enQueue ( LinkQuNode * q , ElemType e ) anaNode *) malloc ( sizeof ( DataNode )); p -> data = e , p -> next = NULL ; if ( q -/ rear == MULL ) else /／若链队为空，则新结点是队首结点又是队尾结点/／将 p 结点链到队尾，并将 rear 指向它 q -) front = q -) rear = p ; q -> rear -> next = p ; q -> rear = p ; bool deQueue ( LinkQuNode * q ElenType & e ) rear == NULL ) return false t = a 。 front 人列中只有一个结望问第一个数据结点 /／队列中有多个结点时 /／队列为空 else

修改后的代码如下：

#include <stdlib.h>
#include <stdbool.h>

typedef char ElemType;
typedef struct DataNode {
    ElemType data;
    struct DataNode *next;
} DataNode;

typedef struct {
    DataNode *front, *rear;
} LinkQuNode;

void InitQueue(LinkQuNode *q) {
    q = (LinkQuNode *) malloc(sizeof(LinkQuNode));
    q->front = q->rear = NULL;
}

void DestroyQueue(LinkQuNode *q) {
    DataNode *p = q->front;
    DataNode *r;

    while (p != NULL) {
        r = p->next;
        free(p);
        p = r;
    }

    free(q);
}

bool QueueEmpty(LinkQuNode *q) {
    return (q->rear == NULL);
}

void enQueue(LinkQuNode *q, ElemType e) {
    DataNode *p = (DataNode *) malloc(sizeof(DataNode));
    p->data = e;
    p->next = NULL;

    if (q->rear == NULL) {  // 若链队为空，则新结点是队首结点又是队尾结点
        q->front = q->rear = p;
    } else {
        q->rear->next = p;  // 将 p 结点链到队尾，并将 rear 指向它
        q->rear = p;
    }
}

bool deQueue(LinkQuNode *q, ElemType &e) {
    if (q->rear == NULL) {  // 队列为空
        return false;
    } else {
        DataNode *t = q->front;
        e = t->data;

        if (q->front == q->rear) {  // 队列中只有一个结点，第一个数据结点
            q->front = q->rear = NULL;
        } else {  // 队列中有多个结点时
            q->front = t->next;
        }

        free(t);
        return true;
    }
}