钾钇 2021-07-07 10:23 采纳率: 100%
浏览 56
已结题

数据结构（队列实现数学上的集合）

只用C，不用C++和java，求具体能运行的代码
用一个队列实现数学上的集合（Set）的元素判定（属于、is a member of）、子集判定（包含于、is a subset of、is contained in）、交（intersection）、并（union）、差（complement、set-theoretic difference）运算，集合元素限定为整数。只能利用队列的入队和出队操作访问队列中元素。

  • 写回答

4条回答 默认 最新

  • bx112233 2021-07-07 17:08
    关注

    #include <stdio.h>
    #include <stdlib.h>
    //数据类型
    #define ElemType int

    typedef struct QueueNode
    {
    ElemType data; //数据域
    struct QueueNode *next; //指针域
    }QueueNode;

    typedef struct LinkQueue
    {
    QueueNode *head; //队头指针
    QueueNode *tail; //队尾指针
    }LinkQueue;

    typedef struct Node {
    int data;
    struct Node *next;
    }Node;

    //创建新节点函数
    Node *CreateNode(int value)
    {
    //为新节点申请空间
    Node new_node = (Node)malloc(sizeof(Node));
    //给新节点赋值
    new_node->data = value;
    //将新节点的next指向空
    new_node->next = NULL;
    return new_node;
    }

    void Emptyqueue(Node **head)//释放队列空间
    {
    Node *cur = *head;
    Node *temp;
    if (head == NULL)
    {
    //空队列无需打印
    return;
    }

    //遍历队列
while (cur != NULL)
{
    temp = cur->next;
    free(cur);
    //移动cur,以达到遍历队列的目的
    cur = temp;
}

*head = NULL;

    }

    //顺序打印队列元素
    void queuePrint(Node *head)
    {
    Node *cur;
    if (head == NULL)
    {
    //空队列无需打印
    return;
    }

    cur = head;
//遍历队列
while (cur != NULL)
{
    //打印元素和其对应的地址
    printf("%d\n", cur->data);
    //移动cur,以达到遍历队列的目的
    cur = cur->next;
}
printf("\n");

    }

    //入队函数，插入链表尾部
    Node *queuePushBack(Node **head, int value)
    {
    Node *cur;
    Node *new_node;
    //非法输入
    if (head == NULL)
    {
    return NULL;
    }
    //空队列
    if (*head == NULL)
    {
    //直接创建一个新的节点完成元素插入
    *head = CreateNode(value);
    return NULL;
    }
    else
    {
    cur = *head;
    //遍历队列，让cur指向最后一个元素
    while (cur->next != NULL)
    {
    cur = cur->next;
    }
    //创建一个新节点
    new_node = CreateNode(value);
    //将最后一个元素的next指向新节点
    cur->next = new_node;
    return new_node;
    }
    }

    //出队函数，从链表头删除
    void queuePop(Node **head)
    {
    //非法输入
    if (head == NULL)
    {
    return;
    }
    //空队列没有可删除的元素
    if (*head == NULL)
    {
    return;
    }
    else
    {
    //创建一个新的指针指向第二个元素
    Node *new_node = (*head)->next;
    //将头结点的next指向空
    (*head)->next = NULL;
    //删除该头结点
    free(*head);
    //将第二个元素设置成新的队头
    *head = new_node;
    }
    return;
    }

    int IN_SET(Node *L, int value)//判断数据是否存在队列中
    {
    int ret = 1;
    Node *p1 = L;
    if (L == NULL) return ret;
    while (p1)
    {
    if (value == p1->data)
    {
    ret = 0;
    break;
    }
    p1 = p1->next;
    }

    return ret;

    }

    int INSERT_SET(Node **L, int value)//插入数据
    {
    int ret = 0;
    if (IN_SET(*L, value))//判断是否存在
    {
    queuePushBack(L, value);//插入
    ret = 1;
    }

    return ret;

    }

    int child(Node * L1, Node * L2)//判断集合1是否为集合2的子集，是返回1，不是返回0
    {
    Node * L, *p1, *p2;
    int find = 0;
    p1 = L1;
    p2 = L2;
    while (p1)//查找集合1
    {
    find = 0;
    p2 = L2;
    while (p2)//查找集合2中是否包含集合1的元素
    {
    if (p1->data == p2->data){//如果找到表示存在，find赋值为1并跳出
    find = 1;
    break;
    }

            p2 = p2->next;
    }

    if (!find) return 0;//一旦存在集合1中元素未包含在集合2，表示集合1非集合2子集，返回0停止判断
    p1 = p1->next;
}

return 1;//集合1全部包含在集合2中，集合1是集合2子集

    }

    Node* intersection(Node * L1, Node * L2)//交集
    {
    Node * L, *p1, *p2;
    p1 = L1;
    p2 = L2;
    L = NULL;
    while (p1)//查找集合1
    {
    p2 = L2;
    while (p2)//查找集合2
    {
    if (p1->data == p2->data){//集合1和集合2都存在的，插入到交集队列
    queuePushBack(&L, p1->data);
    break;
    }

            p2 = p2->next;
    }
    p1 = p1->next;
}

return L;

    }

    Node* Union(Node * L1, Node * L2)//并集
    {
    Node * L, *p1, *p2;
    p1 = L1;
    p2 = L2;
    L = NULL;
    while (p1)//集合1插入并集集合
    {
    queuePushBack(&L, p1->data);
    p1 = p1->next;
    }

    while (p2)//集合2插入并集集合
{
    if (IN_SET(L, p2->data)) queuePushBack(&L, p2->data);//集合2插入时判断是否重复
    p2 = p2->next;
}

return L;

    }

    Node* difference(Node * L1, Node * L2)//差集
    {
    Node *L, *p1, *p2;
    int find;
    p1 = L1;
    p2 = L2;
    L = NULL;
    while (p1)//将集合1减集合2的结果存入差集合
    {
    find = 0;
    p2 = L2;
    while (p2)
    {
    if (p1->data == p2->data){//在集合2中查找集合1中元素是否存在
    find = 1;
    break;
    }

            p2 = p2->next;
    }

    if (!find) queuePushBack(&L, p1->data);//存在集合1不存在集合2的元素插入差集合
    p1 = p1->next;
}

return L;

    }

    int main()
    {
    FILE *fp = NULL; //文件句柄
    int data, t = 1, i = 0;
    Node *A = NULL, *B = NULL, *C = NULL, *D = NULL, *E = NULL;//队列
    int k = 1;//为0时推出创新
    while (k)
    {
    printf("1、创建队列AB\n");
    printf("2、判断子集关系\n");
    printf("3、求AB交集C\n");
    printf("4、求AB并集D\n");
    printf("5、求AB差集E\n");
    printf("0、退出\n");
    printf("请选择：");
    scanf_s("%d", &i);

        switch (i)
    {
    case 1:
        Emptyqueue(&A);
        Emptyqueue(&B);
        printf("开始创建A：\n");
        while (t)
        {
            printf("请输入元素：");
            scanf_s("%d", &data);
            if (!INSERT_SET(&A, data)) printf("数据已经存在，插入失败\n");
            else
            {
                printf("是否继续插入（1继续，0退出）：");
                scanf_s("%d", &t);
            }
        }
        t = 1;
        printf("开始创建B：\n");
        while (t)
        {
            printf("请输入元素：");
            scanf_s("%d", &data);
            if (!INSERT_SET(&B, data)) printf("数据已经存在，插入失败\n");
            else
            {
                printf("是否继续插入（1继续，0退出）：");
                scanf_s("%d", &t);
            }
        }
        break;
    case 2:
        if (child(A, B)) printf("集合A是集合B子集\n");
        else printf("集合A不是集合B子集\n");

        if (child(B, A)) printf("集合B是集合A子集\n");
        else printf("集合B不是集合A子集\n");
        break;
    case 3:
        Emptyqueue(&C);
        C = intersection(A, B);
        printf("集合AB的交集C：\n");
        queuePrint(C);
        break;
    case 4:
        Emptyqueue(&D);
        D = Union(A, B);
        printf("集合AB的并集D：\n");
        queuePrint(D);
        break;
    case 5:
        Emptyqueue(&E);
        E = difference(A, B);
        printf("集合AB的差E：\n");
        queuePrint(E);
        break;
    case 0:  k = 0; break;
    }
}

Emptyqueue(&A);
Emptyqueue(&B);
Emptyqueue(&C);
Emptyqueue(&D);
Emptyqueue(&E);
return 0;

    }#include <stdio.h>
    #include <stdlib.h>
    //数据类型
    #define ElemType int

    typedef struct QueueNode
    {
    ElemType data; //数据域
    struct QueueNode *next; //指针域
    }QueueNode;

    typedef struct LinkQueue
    {
    QueueNode *head; //队头指针
    QueueNode *tail; //队尾指针
    }LinkQueue;

    typedef struct Node {
    int data;
    struct Node *next;
    }Node;

    //创建新节点函数
    Node *CreateNode(int value)
    {
    //为新节点申请空间
    Node new_node = (Node)malloc(sizeof(Node));
    //给新节点赋值
    new_node->data = value;
    //将新节点的next指向空
    new_node->next = NULL;
    return new_node;
    }

    void Emptyqueue(Node **head)//释放队列空间
    {
    Node *cur = *head;
    Node *temp;
    if (head == NULL)
    {
    //空队列无需打印
    return;
    }

    //遍历队列
while (cur != NULL)
{
    temp = cur->next;
    free(cur);
    //移动cur,以达到遍历队列的目的
    cur = temp;
}

*head = NULL;

    }

    //顺序打印队列元素
    void queuePrint(Node *head)
    {
    Node *cur;
    if (head == NULL)
    {
    //空队列无需打印
    return;
    }

    cur = head;
//遍历队列
while (cur != NULL)
{
    //打印元素和其对应的地址
    printf("%d\n", cur->data);
    //移动cur,以达到遍历队列的目的
    cur = cur->next;
}
printf("\n");

    }

    //入队函数，插入链表尾部
    Node *queuePushBack(Node **head, int value)
    {
    Node *cur;
    Node *new_node;
    //非法输入
    if (head == NULL)
    {
    return NULL;
    }
    //空队列
    if (*head == NULL)
    {
    //直接创建一个新的节点完成元素插入
    *head = CreateNode(value);
    return NULL;
    }
    else
    {
    cur = *head;
    //遍历队列，让cur指向最后一个元素
    while (cur->next != NULL)
    {
    cur = cur->next;
    }
    //创建一个新节点
    new_node = CreateNode(value);
    //将最后一个元素的next指向新节点
    cur->next = new_node;
    return new_node;
    }
    }

    //出队函数，从链表头删除
    void queuePop(Node **head)
    {
    //非法输入
    if (head == NULL)
    {
    return;
    }
    //空队列没有可删除的元素
    if (*head == NULL)
    {
    return;
    }
    else
    {
    //创建一个新的指针指向第二个元素
    Node *new_node = (*head)->next;
    //将头结点的next指向空
    (*head)->next = NULL;
    //删除该头结点
    free(*head);
    //将第二个元素设置成新的队头
    *head = new_node;
    }
    return;
    }

    int IN_SET(Node *L, int value)//判断数据是否存在队列中
    {
    int ret = 1;
    Node *p1 = L;
    if (L == NULL) return ret;
    while (p1)
    {
    if (value == p1->data)
    {
    ret = 0;
    break;
    }
    p1 = p1->next;
    }

    return ret;

    }

    int INSERT_SET(Node **L, int value)//插入数据
    {
    int ret = 0;
    if (IN_SET(*L, value))//判断是否存在
    {
    queuePushBack(L, value);//插入
    ret = 1;
    }

    return ret;

    }

    int child(Node * L1, Node * L2)//判断集合1是否为集合2的子集，是返回1，不是返回0
    {
    Node * L, *p1, *p2;
    int find = 0;
    p1 = L1;
    p2 = L2;
    while (p1)//查找集合1
    {
    find = 0;
    p2 = L2;
    while (p2)//查找集合2中是否包含集合1的元素
    {
    if (p1->data == p2->data){//如果找到表示存在，find赋值为1并跳出
    find = 1;
    break;
    }

            p2 = p2->next;
    }

    if (!find) return 0;//一旦存在集合1中元素未包含在集合2，表示集合1非集合2子集，返回0停止判断
    p1 = p1->next;
}

return 1;//集合1全部包含在集合2中，集合1是集合2子集

    }

    Node* intersection(Node * L1, Node * L2)//交集
    {
    Node * L, *p1, *p2;
    p1 = L1;
    p2 = L2;
    L = NULL;
    while (p1)//查找集合1
    {
    p2 = L2;
    while (p2)//查找集合2
    {
    if (p1->data == p2->data){//集合1和集合2都存在的，插入到交集队列
    queuePushBack(&L, p1->data);
    break;
    }

            p2 = p2->next;
    }
    p1 = p1->next;
}

return L;

    }

    Node* Union(Node * L1, Node * L2)//并集
    {
    Node * L, *p1, *p2;
    p1 = L1;
    p2 = L2;
    L = NULL;
    while (p1)//集合1插入并集集合
    {
    queuePushBack(&L, p1->data);
    p1 = p1->next;
    }

    while (p2)//集合2插入并集集合
{
    if (IN_SET(L, p2->data)) queuePushBack(&L, p2->data);//集合2插入时判断是否重复
    p2 = p2->next;
}

return L;

    }

    Node* difference(Node * L1, Node * L2)//差集
    {
    Node *L, *p1, *p2;
    int find;
    p1 = L1;
    p2 = L2;
    L = NULL;
    while (p1)//将集合1减集合2的结果存入差集合
    {
    find = 0;
    p2 = L2;
    while (p2)
    {
    if (p1->data == p2->data){//在集合2中查找集合1中元素是否存在
    find = 1;
    break;
    }

            p2 = p2->next;
    }

    if (!find) queuePushBack(&L, p1->data);//存在集合1不存在集合2的元素插入差集合
    p1 = p1->next;
}

return L;

    }

    int main()
    {
    FILE *fp = NULL; //文件句柄
    int data, t = 1, i = 0;
    Node *A = NULL, *B = NULL, *C = NULL, *D = NULL, *E = NULL;//队列
    int k = 1;//为0时推出创新
    while (k)
    {
    printf("1、创建队列AB\n");
    printf("2、判断子集关系\n");
    printf("3、求AB交集C\n");
    printf("4、求AB并集D\n");
    printf("5、求AB差集E\n");
    printf("0、退出\n");
    printf("请选择：");
    scanf_s("%d", &i);

        switch (i)
    {
    case 1:
        Emptyqueue(&A);
        Emptyqueue(&B);
        printf("开始创建A：\n");
        while (t)
        {
            printf("请输入元素：");
            scanf_s("%d", &data);
            if (!INSERT_SET(&A, data)) printf("数据已经存在，插入失败\n");
            else
            {
                printf("是否继续插入（1继续，0退出）：");
                scanf_s("%d", &t);
            }
        }
        t = 1;
        printf("开始创建B：\n");
        while (t)
        {
            printf("请输入元素：");
            scanf_s("%d", &data);
            if (!INSERT_SET(&B, data)) printf("数据已经存在，插入失败\n");
            else
            {
                printf("是否继续插入（1继续，0退出）：");
                scanf_s("%d", &t);
            }
        }
        break;
    case 2:
        if (child(A, B)) printf("集合A是集合B子集\n");
        else printf("集合A不是集合B子集\n");

        if (child(B, A)) printf("集合B是集合A子集\n");
        else printf("集合B不是集合A子集\n");
        break;
    case 3:
        Emptyqueue(&C);
        C = intersection(A, B);
        printf("集合AB的交集C：\n");
        queuePrint(C);
        break;
    case 4:
        Emptyqueue(&D);
        D = Union(A, B);
        printf("集合AB的并集D：\n");
        queuePrint(D);
        break;
    case 5:
        Emptyqueue(&E);
        E = difference(A, B);
        printf("集合AB的差E：\n");
        queuePrint(E);
        break;
    case 0:  k = 0; break;
    }
}

Emptyqueue(&A);
Emptyqueue(&B);
Emptyqueue(&C);
Emptyqueue(&D);
Emptyqueue(&E);
return 0;

    }#include <stdio.h>
    #include <stdlib.h>
    //数据类型
    #define ElemType int

    typedef struct QueueNode
    {
    ElemType data; //数据域
    struct QueueNode *next; //指针域
    }QueueNode;

    typedef struct LinkQueue
    {
    QueueNode *head; //队头指针
    QueueNode *tail; //队尾指针
    }LinkQueue;

    typedef struct Node {
    int data;
    struct Node *next;
    }Node;

    //创建新节点函数
    Node *CreateNode(int value)
    {
    //为新节点申请空间
    Node new_node = (Node)malloc(sizeof(Node));
    //给新节点赋值
    new_node->data = value;
    //将新节点的next指向空
    new_node->next = NULL;
    return new_node;
    }

    void Emptyqueue(Node **head)//释放队列空间
    {
    Node *cur = *head;
    Node *temp;
    if (head == NULL)
    {
    //空队列无需打印
    return;
    }

    //遍历队列
while (cur != NULL)
{
    temp = cur->next;
    free(cur);
    //移动cur,以达到遍历队列的目的
    cur = temp;
}

*head = NULL;

    }

    //顺序打印队列元素
    void queuePrint(Node *head)
    {
    Node *cur;
    if (head == NULL)
    {
    //空队列无需打印
    return;
    }

    cur = head;
//遍历队列
while (cur != NULL)
{
    //打印元素和其对应的地址
    printf("%d\n", cur->data);
    //移动cur,以达到遍历队列的目的
    cur = cur->next;
}
printf("\n");

    }

    //入队函数，插入链表尾部
    Node *queuePushBack(Node **head, int value)
    {
    Node *cur;
    Node *new_node;
    //非法输入
    if (head == NULL)
    {
    return NULL;
    }
    //空队列
    if (*head == NULL)
    {
    //直接创建一个新的节点完成元素插入
    *head = CreateNode(value);
    return NULL;
    }
    else
    {
    cur = *head;
    //遍历队列，让cur指向最后一个元素
    while (cur->next != NULL)
    {
    cur = cur->next;
    }
    //创建一个新节点
    new_node = CreateNode(value);
    //将最后一个元素的next指向新节点
    cur->next = new_node;
    return new_node;
    }
    }

    //出队函数，从链表头删除
    void queuePop(Node **head)
    {
    //非法输入
    if (head == NULL)
    {
    return;
    }
    //空队列没有可删除的元素
    if (*head == NULL)
    {
    return;
    }
    else
    {
    //创建一个新的指针指向第二个元素
    Node *new_node = (*head)->next;
    //将头结点的next指向空
    (*head)->next = NULL;
    //删除该头结点
    free(*head);
    //将第二个元素设置成新的队头
    *head = new_node;
    }
    return;
    }

    int IN_SET(Node *L, int value)//判断数据是否存在队列中
    {
    int ret = 1;
    Node *p1 = L;
    if (L == NULL) return ret;
    while (p1)
    {
    if (value == p1->data)
    {
    ret = 0;
    break;
    }
    p1 = p1->next;
    }

    return ret;

    }

    int INSERT_SET(Node **L, int value)//插入数据
    {
    int ret = 0;
    if (IN_SET(*L, value))//判断是否存在
    {
    queuePushBack(L, value);//插入
    ret = 1;
    }

    return ret;

    }

    int child(Node * L1, Node * L2)//判断集合1是否为集合2的子集，是返回1，不是返回0
    {
    Node * L, *p1, *p2;
    int find = 0;
    p1 = L1;
    p2 = L2;
    while (p1)//查找集合1
    {
    find = 0;
    p2 = L2;
    while (p2)//查找集合2中是否包含集合1的元素
    {
    if (p1->data == p2->data){//如果找到表示存在，find赋值为1并跳出
    find = 1;
    break;
    }

            p2 = p2->next;
    }

    if (!find) return 0;//一旦存在集合1中元素未包含在集合2，表示集合1非集合2子集，返回0停止判断
    p1 = p1->next;
}

return 1;//集合1全部包含在集合2中，集合1是集合2子集

    }

    Node* intersection(Node * L1, Node * L2)//交集
    {
    Node * L, *p1, *p2;
    p1 = L1;
    p2 = L2;
    L = NULL;
    while (p1)//查找集合1
    {
    p2 = L2;
    while (p2)//查找集合2
    {
    if (p1->data == p2->data){//集合1和集合2都存在的，插入到交集队列
    queuePushBack(&L, p1->data);
    break;
    }

            p2 = p2->next;
    }
    p1 = p1->next;
}

return L;

    }

    Node* Union(Node * L1, Node * L2)//并集
    {
    Node * L, *p1, *p2;
    p1 = L1;
    p2 = L2;
    L = NULL;
    while (p1)//集合1插入并集集合
    {
    queuePushBack(&L, p1->data);
    p1 = p1->next;
    }

    while (p2)//集合2插入并集集合
{
    if (IN_SET(L, p2->data)) queuePushBack(&L, p2->data);//集合2插入时判断是否重复
    p2 = p2->next;
}

return L;

    }

    Node* difference(Node * L1, Node * L2)//差集
    {
    Node *L, *p1, *p2;
    int find;
    p1 = L1;
    p2 = L2;
    L = NULL;
    while (p1)//将集合1减集合2的结果存入差集合
    {
    find = 0;
    p2 = L2;
    while (p2)
    {
    if (p1->data == p2->data){//在集合2中查找集合1中元素是否存在
    find = 1;
    break;
    }

            p2 = p2->next;
    }

    if (!find) queuePushBack(&L, p1->data);//存在集合1不存在集合2的元素插入差集合
    p1 = p1->next;
}

return L;

    }

    int main()
    {
    FILE *fp = NULL; //文件句柄
    int data, t = 1, i = 0;
    Node *A = NULL, *B = NULL, *C = NULL, *D = NULL, *E = NULL;//队列
    int k = 1;//为0时推出创新
    while (k)
    {
    printf("1、创建队列AB\n");
    printf("2、判断子集关系\n");
    printf("3、求AB交集C\n");
    printf("4、求AB并集D\n");
    printf("5、求AB差集E\n");
    printf("0、退出\n");
    printf("请选择：");
    scanf_s("%d", &i);

        switch (i)
    {
    case 1:
        Emptyqueue(&A);
        Emptyqueue(&B);
        printf("开始创建A：\n");
        while (t)
        {
            printf("请输入元素：");
            scanf_s("%d", &data);
            if (!INSERT_SET(&A, data)) printf("数据已经存在，插入失败\n");
            else
            {
                printf("是否继续插入（1继续，0退出）：");
                scanf_s("%d", &t);
            }
        }
        t = 1;
        printf("开始创建B：\n");
        while (t)
        {
            printf("请输入元素：");
            scanf_s("%d", &data);
            if (!INSERT_SET(&B, data)) printf("数据已经存在，插入失败\n");
            else
            {
                printf("是否继续插入（1继续，0退出）：");
                scanf_s("%d", &t);
            }
        }
        break;
    case 2:
        if (child(A, B)) printf("集合A是集合B子集\n");
        else printf("集合A不是集合B子集\n");

        if (child(B, A)) printf("集合B是集合A子集\n");
        else printf("集合B不是集合A子集\n");
        break;
    case 3:
        Emptyqueue(&C);
        C = intersection(A, B);
        printf("集合AB的交集C：\n");
        queuePrint(C);
        break;
    case 4:
        Emptyqueue(&D);
        D = Union(A, B);
        printf("集合AB的并集D：\n");
        queuePrint(D);
        break;
    case 5:
        Emptyqueue(&E);
        E = difference(A, B);
        printf("集合AB的差E：\n");
        queuePrint(E);
        break;
    case 0:  k = 0; break;
    }
}

Emptyqueue(&A);
Emptyqueue(&B);
Emptyqueue(&C);
Emptyqueue(&D);
Emptyqueue(&E);
return 0;

    }

    本回答被题主选为最佳回答 , 对您是否有帮助呢?
    评论
查看更多回答(3条)

报告相同问题？

  • C语言数据结构栈与队列 c语言 数据结构 算法
    2022-04-10 08:49
    回答 1 已采纳 修改处见注释，供参考： // 利用栈和队列的特性设计一个算法，用于判断一个字符串是否为回文。 # include <stdio.h> # include <stdlib.h>
  • C语言数据结构队列题出现了段错误 c语言 数据结构 算法
    2022-03-16 23:16
    回答 1 已采纳 上面已经回复你了。其它问题再说。
  • 关于使用数据结构队列创建贪吃蛇的问题 c++ 数据结构 有问必答 算法
    2022-11-18 20:47
    回答 3 已采纳 代码如下： #include <stdio.h> #define LEN 10 struct queue { int Data[LEN]; int Rear; i
  • 数据结构与算法Java实现.zip
    2024-01-15 21:48
    逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
  • 数据结构循环队列的插入 数据结构 算法 链表
    2023-01-30 18:05
    回答 3 已采纳 循环队列的队尾指针是可以循环的，当队尾指针加一后到达数组长度时需要回到0，再加一，这样就成了循环队列。因此在公式rear=(rear+1)%(m+1)中需要加上m+1，以确保循环队列的正确性。
  • 数据结构的栈和队列相关设计 c++ c语言 数据结构 有问必答
    2022-06-23 17:20
    回答 3 已采纳 使用队列的方法： 代码： #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #define MAXLEN 100 //队列 --
  • 数据结构算法求详细解 数据结构 算法
    2023-02-21 08:47
    回答 3 已采纳 对给定图进行邻接表表示，并利用队列和栈实现广度优先遍历和深度优先遍历的Python代码实现。同时，程序还支持从键盘输入初始出发的顶点序号，并在遍历过程中输出访问过的结点序号 from collecti
  • 基本算法与数据结构的Java实现.zip
    2024-01-14 12:41
    算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
  • 大一新生_数据结构与算法 数据结构
    2022-11-04 10:26
    回答 4 已采纳 线性表，链表，栈，队列以及树等数据结构，不是你理解的 抽象还是真实存在的概念，而是给你这样的例子让你好理解，项目中是肯定有用到的
  • 数据结构中循环队列的入队操作 数据结构 算法
    2023-03-13 16:06
    回答 3 已采纳 看你的 rear 是从下标0开始还是从1开始，从0开始就要+1得到长度。
  • 数据结构中计算队列长度 数据结构
    2022-12-30 22:24
    回答 1 已采纳 队列的下标：8 9 10 11 12 13 14 15 16 17 18 19 20 0 1 2 3
  • 算法与数据结构的Java实现.zip
    2024-01-15 21:49
    逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
  • 基础算法与数据结构 -- Java 实现.zip
    2024-01-14 12:41
    算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
  • 数据结构与算法（Java实现）.zip
    2024-01-15 21:48
    逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
  • 常见的数据结构与算法，Java语言实现.zip
    2024-01-14 12:34
    算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
  • 没有解决我的问题, 去提问

悬赏问题

  • ¥15 DS18B20内部ADC模数转换器
  • ¥15 做个有关计算的小程序
  • ¥15 MPI读取tif文件无法正常给各进程分配路径
  • ¥15 如何用MATLAB实现以下三个公式（有相互嵌套）
  • ¥30 关于#算法#的问题：运用EViews第九版本进行一系列计量经济学的时间数列数据回归分析预测问题 求各位帮我解答一下
  • ¥15 setInterval 页面闪烁，怎么解决
  • ¥15 如何让企业微信机器人实现消息汇总整合
  • ¥50 关于#ui#的问题：做yolov8的ui界面出现的问题
  • ¥15 如何用Python爬取各高校教师公开的教育和工作经历
  • ¥15 TLE9879QXA40 电机驱动