（持续更新）造福GDUT计院的小伙伴们，数据结构anyview题目+答案，代码搓大牛们勿喷

最新推荐文章于 2022-01-17 13:16:46 发布
置顶 最新推荐文章于 2022-01-17 13:16:46 发布
阅读量4.7k 收藏 10
点赞数 3
分类专栏： Something
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ACMWONDER/article/details/46471953
版权

GDUT数据结构anyview题目+答案，代码搓大牛们勿喷，大家随意就好！

/**********
【题目】试写一算法，实现链栈的判空操作。
链栈的类型定义为：
typedef struct LSNode {
 ElemType data;       // 数据域
 struct LSNode *next; // 指针域
} LSNode, *LStack;    // 结点和链栈类型
***********/
Status StackEmpty_L(LStack S)
/* 对链栈S判空。若S是空栈，则返回TRUE；否则返回FALSE */
{
    if(S == NULL) return TRUE;
    else return FALSE;
}

/**********
【题目】试写一算法，实现链栈的取栈顶元素操作。
链栈的类型定义为：
typedef struct LSNode {
  ElemType data;       // 数据域
  struct LSNode *next; // 指针域
} LSNode, *LStack;    // 结点和链栈类型
***********/
Status GetTop_L(LStack S, ElemType &e)
/* 取链栈S的栈顶元素到e，并返回OK; */
/* 若S是空栈，则失败，返回ERROR。  */
{
    if(S == NULL) return ERROR;
    else
    {
        e = S->data;
        return OK;
    }
}

/**********
【题目】试写一算法，实现链队列的判空操作。
链队列的类型定义为：
typedef struct LQNode {
  ElemType  data;
  struct LQNode  *next;
} LQNode, *QueuePtr; // 结点和结点指针类型
typedef struct {
  QueuePtr  front;  // 队头指针
  QueuePtr  rear;   // 队尾指针
} LQueue;  // 链队列类型
***********/
Status QueueEmpty_LQ(LQueue Q)
/* 判定链队列Q是否为空队列。           */
/* 若Q是空队列，则返回TRUE，否则FALSE。*/
{
    if(Q.front==NULL && Q.rear==NULL) return TRUE;
    else return FALSE;
}

/**********
【题目】试写一算法，实现链队列的求队列长度操作。
链队列的类型定义为：
typedef struct LQNode {
  ElemType  data;
  struct LQNode  *next;
} LQNode, *QueuePtr; // 结点和结点指针类型
typedef struct {
  QueuePtr  front;  // 队头指针
  QueuePtr  rear;   // 队尾指针
} LQueue;  // 链队列类型
***********/
int QueueLength_LQ(LQueue Q)
/* 求链队列Q的长度并返回其值 */
{
    int count = 0;
    LQNode* p;
    p = Q.front;
    if(Q.front == NULL && Q.rear == NULL) return count;
    while(p != NULL)
    {
        count++;
        p = p->next;
    }
    return count;
}

/**********
【题目】假设以带头结点的循环链表表示队列，并且
只设一个指针指向队尾元素结点(注意不设头指针)，
试编写相应的队列初始化、入队列和出队列的算法。
带头结点循环链队列CLQueue的类型定义为：
typedef struct LQNode {
  ElemType data;
  struct LQNode *next;
} LQNode, *CLQueue;
**********/
Status InitCLQueue(CLQueue &rear) // 初始化空队列
{
    LQNode *head;

    head = (LQNode*)malloc(sizeof(LQNode));
    rear = head;
    head->next = rear;
    return OK;
}

Status EnCLQueue(CLQueue &rear, ElemType x) // 入队
{
    LQNode *head = rear->next;
    LQNode *p;
    p = (LQNode*)malloc(sizeof(LQNode));
    p->data = x;
    p->next = head;
    rear->next = p;
    rear = p;
    return OK;
}

Status DeCLQueue(CLQueue &rear, ElemType &x) // 出队
{
    LQNode *p;
    LQNode *head;
    head = rear->next;
    if(rear == NULL || head->next == rear->next) return ERROR;
    p = head->next;
    x = p->data;
    head->next = p->next;
    free(p);

    return OK;
}
/**********
【题目】试写一算法，实现带头结点单链表的判空操作。

单链表的类型定义为：
typedef struct LNode {
  ElemType  data;
  struct LNode  *next;
} LNode, *LinkList; // 结点和结点指针类型
***********/
Status ListEmpty_L(LinkList L)
/* 判定带头结点单链表L是否为空链表。   */
/* 若L是空链表，则返回TRUE，否则FALSE。*/
{
    if(L == NULL || L->next == NULL)  return TRUE;
    else return FALSE;
}

/**********
【题目】试写一算法，实现带头结点单链表的销毁操作。
单链表的类型定义为：
typedef struct LNode {
  ElemType  data;
  struct LNode  *next;
} LNode, *LinkList; // 结点和结点指针类型
***********/
Status DestroyList_L(LinkList &L)
/* 销毁带头结点单链表L，并返回OK。*/
{

    LNode *q;
    if(!L) return OK;
    while(L != NULL)
    {
        q = L;
        L = L->next;
        free(q);

    }
    return OK;
}


/**********
【题目】试写一算法，实现带头结点单链表的清空操作。

单链表的类型定义为：
typedef struct LNode {
  ElemType  data;
  struct LNode  *next;
} LNode, *LinkList; // 结点和结点指针类型
***********/
Status ClearList_L(LinkList &L)
/* 将带头结点单链表L置为空表，并返回OK。*/
/* 若L不是带头结点单链表，则返回ERROR。 */
{
    if(L == NULL) return ERROR;
    else
    {
        L->next = NULL;
        return OK;
    }
}


/**********
【题目】试写一算法，实现带头结点单链表的求表长度操作。
单链表的类型定义为：
typedef struct LNode {
  ElemType  data;
  struct LNode  *next;
} LNode, *LinkList; // 结点和结点指针类型
***********/
int ListLength_L(LinkList L)
/* 求带头结点单链表L的长度，并返回长度值。*/
/* 若L不是带头结点单链表，则返回-1。      */
{
    int count = 0;
    LNode *p = L;
    if(L == NULL) return -1;
    while(p->next != NULL)
    {
        count++;
        p = p->next;
    }
    return count;

}


/**********
【题目】试写一算法，在带头结点单链表L插入第i元素e。
带头结点单链表的类型定义为：
typedef struct LNode {
  ElemType      data;
  struct LNode *next;
} LNode, *LinkList;
**********/
Status Insert_L(LinkList L, int i, ElemType e)
/* 在带头结点单链表L插入第i元素e，并返回OK。*/
/* 若参数不合理，则返回ERROR。              */
{
    int count = 0;
    LNode* p ;
    LNode* q;
    q = (LNode*)malloc(sizeof(LNode));
    p = L;
    while(p!=NULL && count<i-1)
    {
        p = p->next;
        count++;
    }
    if(!p || count>i-1) return ERROR;
    q->data = e;
    q->next = p->next;
    p->next = q;

    return OK;
}

/**********
【题目】试写一算法，在带头结点单链表删除第i元素到e。
带头结点单链表的类型定义为：
typedef struct LNode {
  ElemType      data;
  struct LNode *next;
} LNode, *LinkList;
**********/
Status Delete_L(LinkList L, int i, ElemType &e)
/* 在带头结点单链表L删除第i元素到e，并返回OK。*/
/* 若参数不合理，则返回ERROR。                */
{
    LNode* p = L;
    LNode* q;
    int count = 0;
    while(p->next != NULL && count<i-1)
    {
        p = p->next;
        count++;
    }
    if(p->next == NULL || count>=i) return ERROR;
    e = p->next->data;
    q = p->next;
    p->next = q->next;
    free(q);
    return OK;
}

/**********
【题目】试写一算法，在带头结点单链表的第i元素起的
所有元素从链表移除，并构成一个带头结点的新链表。
带头结点单链表的类型定义为：
typedef struct LNode {
  ElemType      data;
  struct LNode *next;
} LNode, *LinkList;
**********/
Status Split_L(LinkList L, LinkList &Li, int i)
/* 在带头结点单链表L的第i元素起的所有元素 */
/* 移除，并构成带头结点链表Li，返回OK。   */
/* 若参数不合理，则Li为NULL，返回ERROR。  */
{
    int count = 0;
    LNode* head;
    LNode* p;
    head = (LNode*)malloc(sizeof(LNode));
    p = L;
    while(p->next && count<i-1)
    {
        p = p->next;
        count++;
    }
    if(!(p->next)|| count>=i)
    {
        Li = NULL;
        return ERROR;
    }
    head->next = p->next;
    p->next = NULL;
    Li = head;
    return OK;
}

/**********
【题目】试写一算法，在带头结点单链表删除第i元素
起的所有元素。
带头结点单链表的类型定义为：
typedef struct LNode {
  ElemType      data;
  struct LNode *next;
} LNode, *LinkList;
**********/
Status Cut_L(LinkList L, int i)
/* 在带头结点单链表L删除第i元素起的所有元素，并返回OK。*/
/* 若参数不合理，则返回ERROR。                         */
{
    int count = 0;
    LNode* p;
    //head = (LNode*)malloc(sizeof(LNode));
    p = L;
    while(p->next && count<i-1)
    {
        p = p->next;
        count++;
    }
    if(!(p->next)|| count>=i)
    {
        return ERROR;
    }
    p->next = NULL;
    return OK;
}

/**********
【题目】试写一算法，删除带头结点单链表中所有值
为x的元素，并释放被删结点空间。
单链表类型定义如下：
typedef struct LNode {
  ElemType      data;
  struct LNode *next;
} LNode, *LinkList;
**********/
Status DeleteX_L(LinkList L, ElemType x)
/* 删除带头结点单链表L中所有值为x的元素，      */
/* 并释放被删结点空间，返回实际删除的元素个数。*/
{
    LNode* p;
    LNode* q;
    p = L;
    int count = 0;
    if(!L) return 0;
    while(p->next)
    {
        if(p->next->data == x)
        {
            q = p->next;
            p->next = q->next;
            free(q);
            count++;
        }
        else p = p->next;
    }
    return count;
}


/**********
【题目】试写一算法，删除带头结点单链表中所有值
小于x的元素，并释放被删结点空间。
单链表类型定义如下：
typedef struct LNode {
  ElemType      data;
  struct LNode *next;
} LNode, *LinkList;
**********/
Status DeleteSome_L(LinkList L, ElemType x)
/* 删除带头结点单链表L中所有值小于x的元素，    */
/* 并释放被删结点空间，返回实际删除的元素个数。*/
{
    LNode* p;
    LNode* q;
    p = L;
    int count = 0;
    if(!L) return 0;
    while(p->next)
    {
        if(p->next->data < x)
        {
            q = p->next;
            p->next = q->next;
            free(q);
            count++;
        }
        else p = p->next;
    }
    return count;
}

/**********
【题目】试以顺序表L的L.rcd[L.length+1]作为监视哨，
改写教材5.2节中给出的升序直接插入排序算法。
顺序表的类型RcdSqList定义如下：
typedef struct {
   KeyType key;
   ...
} RcdType;
typedef struct {
   RcdType rcd[MAXSIZE+1]; // r[0]闲置
   int length;
} RcdSqList;
**********/
int a[100];
int cmp (int a,int b)
{
    return a<b;
}
void swap(int x,int y)
{
    int t=a[x];
    a[x]=a[y];
    a[y]=t;
}
void InsertSort(RcdSqList &L)
{
    int i,j;
    int cnt=0;
    for(i=1; i<=L.length; i++)
    {
        a[i]=L.rcd[i].key;
    }
    for(i=1; i<L.length; i++)
    {
        for(j=i+1; j<=L.length; j++)
        {
            if(a[i]>a[j])
            {
                swap(i,j);
            }
        }
    }
    for(i=1; i<=L.length; i++)
    {
        L.rcd[i].key=a[i];
    }
}

/**********
【题目】如下所述，改写教材1.5节的冒泡排序算法：
将算法中用以起控制作用的布尔变量change改为一个整型
变量，指示每一趟排序中进行交换的最后一个记录的位置，
并以它作为下一趟起泡排序循环终止的控制值。
顺序表的类型RcdSqList定义如下：
typedef struct {
   KeyType key;
   ...
} RcdType;
typedef struct {
   RcdType rcd[MAXSIZE+1]; // r[0]闲置
   int length;
} RcdSqList;
**********/
void BubbleSort(RcdSqList &L)
/* 元素比较和交换必须调用如下定义的比较函数和交换函数：*/
/* Status LT(RedType a, RedType b);   比较："<"        */
/* Status GT(RedType a, RedType b);   比较：">"        */
/* void Swap(RedType &a, RedType &b); 交换             */
{
    int i,j,final = L.length+1,k;
    for(i = 1; i < L.length; i++)
    {
        for(j = 2,k = 0; j < final; j++)
        {
            if(GT(L.rcd[j-1],L.rcd[j]))
            {
                Swap(L.rcd[j-1],L.rcd[j]);
                k = j;
            }
        }
        final = k;
        if(final <= 2)break;
    }
}

/**********
【题目】已知记录序列L.rcd[1..L.length]中的关键
字各不相同，可按如下所述实现计数排序：另设数组
c[1..n]，对每个记录a[i]， 统计序列中关键字比它
小的记录个数存于c[i]，则c[i]=0的记录必为关键字
最小的记录，然后依c[i]值的大小对序列中记录进行
重新排列。试编写算法实现上述排序方法。
顺序表的类型RcdSqList定义如下：
typedef struct {
   KeyType key;
   ...
} RcdType;
typedef struct {
   RcdType r[MAXSIZE+1]; // r[0]闲置
   int     length;
} RcdSqList;
**********/
void CountSort(RcdSqList &L)
/* 采用顺序表存储结构，在函数内自行定义计数数组c */
{
    int c[MAXSIZE + 1];
    int i,j,k,tempI;
    RcdType temp;

    for(i = 1; i <= L.length; i++)
    {
        for(j = 1; j<=L.le
最低0.47元/天 解锁文章
wintermelon27
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
2015年广工数据结构Anyview参考答案
07-06
总结，2015年广工数据结构Anyview参考答案可能涉及了数据结构的基本概念、常见类型、应用案例以及与算法的结合。考生需要深入理解各种数据结构，掌握其在实际问题中的运用，同时理解并熟悉Anyview可能代表的可视化...
广工Anyview数据结构习题
Kaho的博客
01-25 3万+
建议直接访问这里👉数据结构习题永久地址 试写一算法，如果三个整数a，b和c的值不是依次非递增的，则通过交换，令其为非递增。 要求实现下列函数： void Descend(int &a, int &b, int &c); /* 通过交换，令 a >= b >= c */ DC01PE08 求一元多项式的值 试编写算法求一元多项式 P(x) = a0 + a1x + a2x^2 + … + anx^n 的值P(x0)，并确定算法中每一语句的执行次数和整个算法的时间复杂度。 要求实现下列函数： float Po
广工Anyview数据结构2021-C语言版--第一章
m0_53106380的博客
09-13 990
第一章 eg1： 算法思考： //首先随机比较三选二 /* 算法实现原理： 若a<b,则交换a，b，使得a>b,进而继续比较a、c，若a<c,则交换a，c使得a>c，此时有a>b&&a>c. 接着，比较b、c大小即可得到a >= b >= c */ PS：本人菜鸟一枚，欢迎各位大佬与我共同探讨更多思路~。 ...
广工anyview数据结构第一章(2021.12)
凛_Lin~~的博客
01-17 1万+
广工anyview数据结构第一章(2021.12)
广东工业大学数据结构AnyView参考答案
m0_54241235的博客
09-05 9599
广东工业大学数据结构AnyView参考答案 1、第一章 #include "allinclude.h" //DO NOT edit this line void Descend(int &a, int &b, int &c) // 通过交换，令 a >= b >= c { // Add your code here if(a < b){ swap(a, b); } if(a < c){ swap(a
广工AnyView数据结构-1
geek_jerome的博客
10-24 4524
/**** 【题目】试写一算法，如果三个整数a，b和c的值 不是依次非递增的，则通过交换，令其为非递增。 */void Descend(int &a, int &b, int &c) /* 通过交换，令 a >= b >= c */ { int temp; if(c>=b) { temp=b; b=c; c=temp;
gdutday-wechat:gdutday日在广工小程序前端代码,gdut广东工业大学 校内服务小程序
05-05
这里的内容和项目的结构没什么关系,主要说下之后 gdutday 维护问题.目前 gdutday 由广东工业大学电子科技协会(后文简称电协)负责后期运营,具体小程序运营和最高权限管理由电协网络组 负责.gdutday-wechat 承诺一年内...
广东工业大学计算机系统结构试卷+习题答案
07-16
这份"广东工业大学计算机系统结构试卷+习题答案"涵盖了该课程的重要知识点，旨在帮助学生深入理解和掌握计算机体系的基本原理。 一、计算机系统概述 计算机系统由硬件和软件两大部分组成，硬件包括中央处理器（CPU...
本项目是全国大学生智能车竞赛GDUT 2022年极速越野组的项目文件。.zip
最新发布
01-23
本项目是全国大学生智能车...云计算与大数据：数据集、包括云计算平台、大数据分析、人工智能、机器学习等，云计算是一种基于互联网的计算方式，通过这种方式，共享的软硬件资源和信息可以按需提供给计算机和其他设备。
GDUT-DB.rar_gdut
09-14
广东工业大学（GDUT）的数据库实验报告，围绕“数据库安全性”、“数据库完整性”以及“SQL语言的使用”三大主题展开，为我们揭示了数据库技术的深度与广度。 首先，我们关注的是“数据库安全性”。在这个数字化的...
广工离散数学anyview通过代码
07-01
广东工业大学离散数学anyview作业系统答案，代码经过测试可以通过。
2015广工数据结构anyview题库
热门推荐
lzc394049722的博客
07-06 3万+
/********** 【题目】试写一算法，如果三个整数a，b和c的值 不是依次非递增的，则通过交换，令其为非递增。 ***********/ void Descend(int &a, int &b, int &c) /* 通过交换，令 a >= b >= c */ {   int d;    if(a      {        d=a;        a=b;b=d;
广工 AnyviewC 数据结构习题 第二章
雁过留痕的博客
12-28 9612
广工 AnyviewC 数据结构习题 第二章广工 AnyviewC 数据结构习题 第一章Anyview 数据结构 第二章1【题目】试写一算法，实现顺序栈的判空操作2【题目】试写一算法，实现顺序栈的取栈顶元素操作3【题目】试写一算法，实现顺序栈的出栈操作4 【题目】若顺序栈的类型重新定义如下。试编写算法，5【题目】若顺序栈的类型重新定义如下。试编写算法，6【题目】若顺序栈的类型重新定义如下。试编写算...
广工anyview数据结构-09~10（乱码不贴）
clr_lr的博客
07-10 3551
广工anyview数据结构
广工anyview数据结构-04~06（乱码不贴）
clr_lr的博客
07-10 2266
广工anyview数据结构
[算法第一轮复习] 并查集 + 路径压缩
王骕的专栏
04-04 626
关于路径压缩的问题： 这是朴素查找的代码,适合数据量不大的情况： int findx(int x){ int r=x; while(parent[r] !=r) r=parent[r]; return r;}         下面是采用路径压缩的方法查找元素： int find(int x) //查找x元素所在的集合,回溯时
ch09_ex33 从大到小输出给定二叉排…
镜子蓝玉的专栏
08-29 2377
9.33③ 编写递归算法，从大到小输出给定二叉排序树 中所有关键字不小于x的数据元素。要求你的算法的时 间复杂度为O(log2n+m)，其中n为排序树中所含结点数， m为输出的关键字个数。 实现下列函数： void OrderOut(BiTree t, KeyType x, void(*visit)(TElemType)); 二叉树的类型BiTree定义如下： typedef struct {
二叉树T先序遍历时，第k个访问的结点的值。（有两种解法）
qq_43141661的博客
10-05 2561
/********* 第一种 *********/ /********** 【题目】编写递归算法，求对二叉树T先序遍历时 第k个访问的结点的值。 二叉链表类型定义： typedef struct BiTNode { TElemType data; struct BiTNode *lchild, *rchild; } BiTNode, *BiTree; **********/ in...
数据结构 P38 算法实现 在带头结点的单链表的第i个元素插入元素e
bo_1997_2017的博客
10-11 1万+
/*算法2.20*/ #include using namespace  std; struct node                           //创建节点 { int date;          node *next; }; class list                                //创建链表 { int Length;
gdut软件工程课设
12-31
广东工业大学软件工程课设是本专业的重要课程之一，旨在培养学生动手能力和团队协作能力。该课程通常会要求学生在小组内完成一个软件项目，从项目规划、需求分析、系统设计、编码实现到测试和评审，全程参与项目的...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值