广东工业大学anyview数据结构(2024)第二章参考答案

已于 2024-10-13 10:22:57 修改
阅读量3.6k 收藏 45
点赞数 16
文章标签： 数据结构 c++ 算法 c语言
于 2024-08-31 10:29:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79320558/article/details/141748451
版权

注：请注意对应题号，以下内容仅为个人代码，不代表最终答案，仅供参考。

其他章节参考答案

目录

DC02PE03 实现顺序栈判空操作

DC02PE05 实现顺序栈取栈顶元素操作

DC02PE07 实现顺序栈出栈操作

DC02PE11 构建初始容量和扩容增量分别为size和inc的空顺序栈S

DC02PE13 实现顺序栈的判空操作

DC02PE15 实现顺序栈入栈操作

DC02PE17 实现顺序栈出栈操作

DC02PE19 借助辅助栈，复制顺序栈S1得到S2

DC02PE20 数制转换：将十进制数转换为指定进制的数

DC02PE21 判断一个括号串中的括号是否匹配

DC02PE23 求循环队列的长度

DC02PE25 编写入队列和出队列的算法

DC02PE27 写出循环队列的入队列和出队列的算法

DC02PE32 利用循环队列编写求k阶斐波那契序列中第n+1项fn的算法

DC02PE33 比较两个有序顺序表的大小

DC02PE35 试写一算法，实现顺序表的就地逆置

DC02PE45 试写一算法，求并集A＝A∪B。

DC02PE53 试写一算法，实现链栈的判空操作

DC02PE55 试写一算法，实现链栈的取栈顶元素操作

DC02PE61 实现链队列的判空操作

DC02PE63 实现链队列的求队列长度操作

DC02PE68编写队列初始化、入队列和出队列的算法

DC02PE71实现带头结点单链表的判空操作。

DC02PE73实现带头结点单链表的销毁操作

DC02PE75实现带头结点单链表的清空操作

DC02PE77实现带头结点单链表的求表长度操作

DC02PE82在带头结点单链表L的第i个位置插入e

DC02PE84在带头结点单链表删除第i元素到e

DC02PE86将带头结点单链表的第i元素起的所有元素移除，并构成一个带头结点的新链表

DC02PE88试写一算法，在带头结点单链表删除第i元素起的所有元素

DC02PE90删除带头结点单链表中所有值为x的元素

DC02PE91删除带头结点单链表中所有值小于x的元素

DC02PE93删除双向链表中的重复结点

DC02PE94将一条双向链表逆置

DC02PE95将一条双向循环链表逆置

DC02PE97双向交错遍历一条双向循环链表

DC02PE98判断一条类似链表的结构是否为合法的双向循环链表

DC02PE03 实现顺序栈判空操作
Status StackEmpty_Sq(SqStack S) { 
    // Add your code here
    return !S.top;
}
DC02PE05 实现顺序栈取栈顶元素操作
Status GetTop_Sq(SqStack S, ElemType &e) 
{// Add your code here
    if(!S.top) return ERROR;
    e = S.elem[S.top-1];
    return OK;
}
DC02PE07 实现顺序栈出栈操作
Status Pop_Sq(SqStack &S, ElemType &e) { 
    // Add your code here
    if(S.top<=0) return ERROR;
    e = S.elem[--S.top];
}
DC02PE11 构建初始容量和扩容增量分别为size和inc的空顺序栈S
Status InitStack_Sq2(SqStack2 &S, int size, int inc) { 
    // Add your code here
    if(size<=0 or inc<=0) return ERROR;
    S.elem = (ElemType *)malloc(size*sizeof(ElemType));
    S.top = S.elem;
    S.size = size;
    S.increment = inc;
}
DC02PE13 实现顺序栈的判空操作
Status StackEmpty_Sq2(SqStack2 S) { 
    // Add your code here
    return S.top<=S.elem;
}
DC02PE15 实现顺序栈入栈操作
Status Push_Sq2(SqStack2 &S, ElemType e) { 
    // Add your code here
    ElemType *p;
    if(S.top>=S.elem+S.size){
        p=(ElemType *)realloc(S.elem,(S.size+S.increment)*sizeof(ElemType));
        if(!p) return ERROR;
        S.elem = p;
        S.top = S.elem+S.size;
        S.size+=S.increment;
    }
    *S.top++=e;
    return OK;
}
DC02PE17 实现顺序栈出栈操作
Status Pop_Sq2(SqStack2 &S, ElemType &e) { 
    // Add your code here
    if(S.top <= S.elem) return ERROR;
    e=*(--S.top);
    return OK;
}
DC02PE19 借助辅助栈，复制顺序栈S1得到S2
Status CopyStack_Sq(SqStack S1, SqStack &S2) { 
    // Add your code here
    S2.elem = S1.elem;
    S2.top = S1.top;
    S2.size = S1.size;
    S2.increment = S1.increment;
    return 1;
}
DC02PE20 数制转换：将十进制数转换为指定进制的数
void Conversion(int N, int rd)
{  // Add your code here
    string s="";
    while(N){
        s=char(N%rd+'0')+s;
        N/=rd;
    }
    for(int i=0;i<s.size();i++) printf("%c",s[i]);
}
DC02PE21 判断一个括号串中的括号是否匹配
Status matchBracketSequence(char* exp, int n)
{  // Add your code here
    int j,k,l;
    j=k=l=0;
    for(int i=0;i<n;i++){
        if(exp[i] == '{') j++;
        else if(exp[i] == '[') k++;
        else if(exp[i] == '(') l++;
        else if(exp[i] == '}') {
            j--;
            if(j<0) return 0;
        }
        else if(exp[i] == ']') {
            k--;
            if(k<0) return 0;
        }
        else {
            l--;
            if(l<0) return 0;
        }
    }
    return (j==0 and k==0) and l==0;
}
DC02PE23 求循环队列的长度
int QueueLength_Sq(SqQueue Q) { 
    // Add your code here
    return (Q.rear-Q.front+Q.maxSize)%Q.maxSize;
}
DC02PE25 编写入队列和出队列的算法
Status EnCQueue(CTagQueue &Q, ElemType x) { 
    // Add your code here
    if(Q.tag==1) return ERROR;
    Q.elem[Q.rear++] = x;
    if(Q.front == Q.rear) Q.tag = 1;
    return OK;
}

Status DeCQueue(CTagQueue &Q, ElemType &x){
   // Add your code here
    if(Q.tag==0 and Q.front==Q.rear) return ERROR;
    x = Q.elem[Q.front++];
    if(Q.front == Q.rear) Q.tag = 0;
    return OK;
}
DC02PE27 写出循环队列的入队列和出队列的算法
Status EnCQueue(CLenQueue &Q, ElemType x) { 
    // Add your code here
    if(Q.length>=MAXQSIZE) return 0;
    Q.length++;
    Q.elem[++Q.rear] = x;
    return OK;
}

Status DeCQueue(CLenQueue &Q, ElemType &x){
    // Add your code here
    if(Q.length==0) return ERROR;
    Q.rear++;
    Q.rear--; Q.length--;
    return OK;
}
DC02PE32 利用循环队列编写求k阶斐波那契序列中第n+1项fn的算法
#include <iostream>
const int N=1e5;
long Fib(int k, int n) {
    // Add your code here
    if(n==k-1 or n==k) return 1;
    if(n<k) return 0;
    int a[N];
    memset(a,0,sizeof(a));
    a[0]=a[1]=1;
    int t=n-k,m=2;
    while(t--){
        long long sum=0;
        for(int i=(m-k>=0?m-k:0);i<m;i++) sum+=a[i];
        a[m]=sum;
        m++;
    }
    return a[m-1];
}
DC02PE33 比较两个有序顺序表的大小
#include <math.h>
char Compare(SqList A, SqList B) 
{ // Add your code here
    if(A.length==0 and B.length==0) return '=';
    else if(A.length==0) return '<';
    else if(B.length==0) return '>';
    int minn = min(A.length,B.length);
    for(int i=0;i<minn;i++){
        if(A.elem[i]>B.elem[i]) return '>';
        else if(A.elem[i]<B.elem[i]) return '<';
    }
    if(A.length>B.length) return '>';
    else if(A.length<B.length) return '<';
    else return '=';
}
DC02PE35 试写一算法，实现顺序表的就地逆置
​
void Inverse(SqList &L) 
{ // Add your code here
   for(int i=0;i<L.length/2;i++){
        ElemType *e = (ElemType *)malloc(sizeof(ElemType));
        *e = L.elem[i];
        L.elem[i] = L.elem[L.length-1-i];
        L.elem[L.length-1-i] = *e;
   }
}

​
DC02PE45 试写一算法，求并集A＝A∪B。
void Union(SqList &La, List Lb)
{     // Add your code here
    for(int i=0;i<Lb.length;i++)
        if(Search_Sq(La,Lb.elem[i])==-1) La.elem[La.length++]=Lb.elem[i];
}
DC02PE53 试写一算法，实现链栈的判空操作
Status StackEmpty_L(LStack S) 
{    // Add your code here
    return S==NULL;
}
DC02PE55 试写一算法，实现链栈的取栈顶元素操作
Status GetTop_L(LStack S, ElemType &e) 
{    // Add your code here
    if(S==NULL) return ERROR;
    e = S->data;
    return OK;
}
DC02PE61 实现链队列的判空操作
Status QueueEmpty_LQ(LQueue Q)
{    // Add your code here
    return Q.front==NULL;
}
DC02PE63 实现链队列的求队列长度操作
int QueueLength_LQ(LQueue Q) 
{   // Add your code here
    if(Q.front == NULL) return 0;
    int res=1;
    while(Q.front!=Q.rear){
        res++;
        Q.front=Q.front->next;
    }
    return res;
}
DC02PE68编写队列初始化、入队列和出队列的算法
Status InitCLQueue(CLQueue &rear) 
{   // Add your code here
    rear=(CLQueue)malloc(sizeof(CLQueue));
    rear->data = NULL;
    rear->next = rear;
    return OK;
} 

Status EnCLQueue(CLQueue &rear, ElemType x)
{   // Add your code here
    if(rear==NULL){
        InitCLQueue(rear);
        rear->data = x;
        return OK;
    }
    CLQNode *node = (CLQNode *)malloc(sizeof(CLQNode));
    node->data = x;
    node->next = rear->next;
    rear->next = node;
    rear=rear->next;
    return OK;
}

Status DeCLQueue(CLQueue &rear, ElemType &x)
{    // Add your code here
    if(rear->data==NULL) return ERROR;
    CLQNode *p = (CLQNode *)malloc(sizeof(CLQNode));
    p = rear->next->next;
    rear->next = p;
    return OK;
}
DC02PE71实现带头结点单链表的判空操作。
Status ListEmpty_L(LinkList L) 
{    // Add your code here
    return L->data==NULL and L->next==NULL;
}
DC02PE73实现带头结点单链表的销毁操作
Status DestroyList_L(LinkList &L) 
{    // Add your code here
    L=NULL;
    return OK;
}
DC02PE75实现带头结点单链表的清空操作
Status ClearList_L(LinkList &L)
{    // Add your code here
    if(L==NULL) return ERROR;
    while(L->next != NULL){
        L->data = NULL;
        L = L->next;
    }
    return OK;
}
DC02PE77实现带头结点单链表的求表长度操作
int ListLength_L(LinkList L) 
{   // Add your code here
    if(L==NULL) return -1;
    int res = 0;
    while(L->next){
        res++;
        L=L->next;
    }
    return res;
}
DC02PE82在带头结点单链表L的第i个位置插入e
Status Insert_L(LinkList L, int i, ElemType e) 
{   // Add your code here
    if(i<=0 or L==NULL) return ERROR;
    LNode *p = L;
    int pos = 1;
    while(pos<i and p->next){
        pos++;
        p=p->next;
    }
    if(pos!=i) return ERROR;
    LNode *node = (LNode *)malloc(sizeof(LNode));
    node->data = e;
    node->next = p->next;
    p->next = node;
    return OK;
}
DC02PE84在带头结点单链表删除第i元素到e
Status Delete_L(LinkList L, int i, ElemType &e) 
{   // Add your code here
    if(L==NULL or i<=0) return ERROR;
    int pos = 0;
    LNode *pre = (LNode*)malloc(sizeof(LNode));
    LNode *las = L;
    while(pos<i and las->next){
        pos++;
        pre = las;
        las=las->next;
    }
    if(pos!=i) return ERROR;
    e=las->data;
    pre->next = las->next;
    return OK;
}
DC02PE86将带头结点单链表的第i元素起的所有元素移除，并构成一个带头结点的新链表
Status Split_L(LinkList L, LinkList &Li, int i)
{   // Add your code here
    if(L==NULL  or i<=0){
        Li=NULL;
        return ERROR;
    }
    int pos = 0;
    LinkList p = L;
    while(pos<i-1 and p->next){
        pos++;
        p=p->next;
    }
    
    if(pos < i-1 or p->next==NULL){
        Li = NULL;
        return ERROR;
    }
    Li = (LinkList)malloc(sizeof(LinkList));
    Li->next = p->next;
    p->next = NULL;
    return OK;
}
DC02PE88试写一算法，在带头结点单链表删除第i元素起的所有元素
Status Cut_L(LinkList L, int i)
{   // Add your code here
    if(i<=0 or L->next == NULL) return ERROR;
    if(i==1){
        L->next = NULL;
        L=L->next;
        return OK;
    }
    int pos = 0;
    i--;
    LinkList p = L;
    while(pos<i and p->next!=NULL){
        pos++;
        p=p->next;
    }
    if(pos!=i or p->next == NULL) return ERROR;
    p->next=NULL; 
    return OK;
}
DC02PE90删除带头结点单链表中所有值为x的元素
Status DeleteX_L(LinkList L, ElemType x)  
{   // Add your code here
    if(L->next == NULL) return ERROR;
    LinkList p = L;
    int num=0;
    while(p->next != NULL){
        LinkList node = p->next;
        if(node->data == x) {
            num++;
            if(node->next) p->next = node->next;
            else p->next = NULL;
            free(node);
        }
        else p=p->next;
    }
    return num;
}
DC02PE91删除带头结点单链表中所有值小于x的元素
Status DeleteSome_L(LinkList L, ElemType x)  
{   // Add your code here
    if(L->next == NULL) return ERROR;
    LinkList p = L;
    int num=0;
    while(p->next != NULL){
        LinkList node = p->next;
        if(node->data < x) {
            num++;
            if(node->next) p->next = node->next;
            else p->next = NULL;
            free(node);
        }
        else p=p->next;
    }
    return num;
}
DC02PE93删除双向链表中的重复结点
#include <map>
DuLinkList delDuplicateDuLNodes(DuLinkList L)
{   // Add your code here
    if(L == NULL) return L;
    map<char,int>mp;
    DuLinkList p = L;
    mp[p->data] = 1;
    while(p->next){
        DuLNode *node = p->next;
        if(!mp[node->data]) {
            mp[node->data] = 1;
            p=p->next;
        }
        else {
            if(node->next == NULL) {
                p->next = NULL;
                break;
            }
            else {
                DuLNode *no = node->next;
                p->next = no;
                no->prior = p;
            }
        }
    }
    return L;
}
DC02PE94将一条双向链表逆置
void reverseDuLinkList(DuLinkList L)
{   // Add your code here
    if(!L) return;
    auto node = L->next;
    while(node){
        auto t = node->next;
        node->next = node->prior;
        if(t) {
            node->prior = t;
            node = t;
        }
        else {
            L->next->next = NULL;
            node->prior = L;
            L->next = node;
            return;
        }
    }
}
DC02PE95将一条双向循环链表逆置
void reverseDuCirLinkList(DuCirLinkList L)
{   // Add your code here
    if(!L or L->next == L->prior) return;
    DuLNode *p,*q;
    p=L;
    do{
        q=p->next;  
        p->next=p->prior;
        p->prior=q;
        p=q;
    }while(p!=L);
}
DC02PE97双向交错遍历一条双向循环链表
void InterleavedTravelDuCirLinkList(DuCirLinkList L, DuLNode* p)
{   // Add your code here
    if (!p) return;
    auto las = p->next, pre = p->prior;
    while (las or pre) {
        if (las == pre) {
            if (las != L) printf("%c", las->data);
            break;
        }
        if (las == L) las = las->next;
        if (pre == L) pre = pre->prior;
        if (las == pre) {
            if (las != L) printf("%c", las->data);
            break;
        }
        if (las) {
            printf("%c", las->data);
            las = las->next;
        }
        if (pre) {
            printf("%c", pre->data);
            pre = pre->prior;
        }
        if (las->prior == pre) break;
    }
    if (p != L) printf("%c", p->data);
}
DC02PE98判断一条类似链表的结构是否为合法的双向循环链表
Status isLeagalDuCirLinkList(DuCirLinkList L)
{   // Add your code here
    if(L==NULL) return 1;
    auto node = L->next, pre = L;
    do{
        if((!node or !pre) or !node->next) return 0;
        if(node->prior != pre or pre->next!=node) return 0;
        pre = node;
        node = node->next;
    }while(pre!=L);
    return 1;
}

街里丶
关注
广工anyview数据结构-6
geek_jerome的博客
11-26 2970
/**** 【题目】试按依次对每个元素递归分解的分析方法重写求广义表的深度的递归算法。 广义表类型GList的定义： typedef enum {ATOM,LIST} ElemTag; typedef struct GLNode{ ElemTag tag; union { char atom; struct { G
（持续更新）造福GDUT计院的小伙伴们，数据结构anyview题目+答案，代码搓大牛们勿喷
男人就应该默默地努力--某一男人
06-12 4772
GDUT数据结构anyview题目+答案，代码搓大牛们勿喷，大家随意就好！/********** 【题目】试写一算法，实现链栈的判空操作。 链栈的类型定义为： typedef struct LSNode { ElemType data; // 数据域 struct LSNode *next; // 指针域 } LSNode, *LStack; // 结点和链栈类型 ******
广工anyview数据结构答案
05-08
广东工业大学数据结构anyview答案，对于广工的学子来说是很好的参考读物，方便大家完成作业的同时，完善自己写的代码！
广东工业大学 数据结构 anyview 作业系统 第二章答案
11-18
广东工业大学 数据结构 anyview 作业系统 第二章答案
广工 AnyviewC 数据结构习题 第二章
雁过留痕的博客
12-28 1万+
广工 AnyviewC 数据结构习题 第二章广工 AnyviewC 数据结构习题 第一章Anyview 数据结构 第二章1【题目】试写一算法，实现顺序栈的判空操作2【题目】试写一算法，实现顺序栈的取栈顶元素操作3【题目】试写一算法，实现顺序栈的出栈操作4 【题目】若顺序栈的类型重新定义如下。试编写算法，5【题目】若顺序栈的类型重新定义如下。试编写算法，6【题目】若顺序栈的类型重新定义如下。试编写算...
广工anyview数据结构第2章
戮漠
01-04 4431
第二章 PE03 /********** 【题目】试写一算法，实现顺序栈的判空操作 StackEmpty_Sq(SqStack S)。 顺序栈的类型定义为： typedef struct { ElemType *elem; // 存储空间的基址 int top; // 栈顶元素的下一个位置，简称栈顶位标 int size; // 当前分配的存储容量 int increme...
广工anyview数据结构第二章(2021.12)
热门推荐
凛_Lin~~的博客
01-20 1万+
广工anyview数据结构第二章 （2021.12）
广东工业大学数据结构AnyView参考答案
m0_54241235的博客
09-05 9948
广东工业大学数据结构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数据结构-2
geek_jerome的博客
10-27 2218
/**** 【题目】试写一算法，实现顺序栈的判空操作 StackEmpty_Sq(SqStack S)。 顺序栈的类型定义为： typedef struct { ElemType *elem; // 存储空间的基址 int top; // 栈顶元素的下一个位置，简称栈顶位标 int size; // 当前分配的存储容量 int increme
数据结构第二章作业
04-04
数据结构第二章作业，数据结构第二章作业，数据结构第二章作业，
广工数据结构anyview2019最新完整参考答案(含题目).docx
01-11
本人手写广工数据结构anyview的答案，测试通过率100%。内容包含基本数据结构，包括链表，队列，栈，树，图等，约100题。
2016最新广工anyview数据结构答案[归纳].pdf
10-12
2016最新广工anyview数据结构答案[归纳].pdf
广东工业大学数据结构anyview代码第二章
01-25
广东工业大学的数据结构课程是计算机科学与技术专业的重要基础课程，主要涵盖了数据的组织、存储和操作方法。在第二章的学习中，通常会涉及到一系列的核心概念和算法，这些内容对于理解和解决实际编程问题至关重要。...
广东工业大学 数据结构 anyview 作业系统 第五章答案
11-18
本文将针对广东工业大学数据结构课程中AnyView作业系统第五章的答案，具体讨论稀疏矩阵的三元组表示和二元组表示，并实现矩阵相加和元素访问的算法。 一、稀疏矩阵的三元组表示 在数据结构中，稀疏矩阵通常使用...
广东工业大学 数据结构 anyview 作业系统 第六章答案
11-18
"数据结构算法设计" 在数据结构中，二叉树是一种常见的数据结构形式，它在计算机科学和软件工程中有着广泛的应用。以下是对给定文件信息的知识点总结： 一、判别结点 u 是否为结点 v 的子孙 在给定的问题中，我们...
厂工数据结构Anyview（C语言版）第二章答案
CV工程师的博客
01-20 4756
第二章一、实现顺序栈的判空操作二、实现顺序栈的取栈顶元素操作三、实现顺序栈的出栈操作四、构建初始容量和扩容增量分别为size和inc的空顺序栈S五、实现顺序栈的判空操作六、实现顺序栈的入栈操作七、实现顺序栈的出栈操作八、借助辅助栈，复制顺序栈S1得到S2九、求循环队列的长度十、编写入队列和出队列的算法十一、写出循环队列的入队列和出队列的算法十二、利用循环队列编写求k阶斐波那契序列中第n+1项fn的算法十三、试写一个比较A和B大小的算法十四、试写一算法，实现顺序表的就地逆置十五、试写一算法，求并集A＝A∪B十
anyview 数据结构 第二章 双向链表(2023-09-16)
最新发布
2201_75484543的博客
09-16 1113
注意：在本道题目中，会打印该结构中所有有关联的DuLNode结点的data值，但由于条件限制，不会打印这些结点的前驱和后继关系。因此需要通过单步调试，观察该结构的任意结点的前驱和后继情况。试写一算法，判断采用双向循环链表定义的、类似链表的结构是否为合法的双向循环链表。试写一算法，删除一条带头结点的链表中所有data域重复的结点，但每种重复的结点都需要保留一个。】试写一算法，从某个结点p开始，双向交错遍历一条双向循环链表…试写一算法，将一条带头结点的双向链表逆置。
广东工业大学数据结构第二章Anyview练习代码解析
"这些代码是广东工业大学数据结构课程中关于栈操作的部分练习，涉及了创建、初始化、检查栈是否为空、获取栈顶元素以及出栈等基本操作。" 在数据结构中，栈是一种非常重要的线性数据结构，遵循“后进先出”（Last ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值