厂工数据结构Anyview（C语言版）第二章答案

最新推荐文章于 2024-07-23 20:38:48 发布
最新推荐文章于 2024-07-23 20:38:48 发布
阅读量4k 收藏 46
点赞数 8
分类专栏： 数据结构Anyview答案 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48928539/article/details/112889285
版权

第二章

一、实现顺序栈的判空操作

【题目】试写一算法，实现顺序栈的判空操作
StackEmpty_Sq(SqStack S)。

要求实现下列函数：
Status StackEmpty_Sq(SqStack S);
/* 对顺序栈S判空。 /
/ 若S是空栈，则返回TRUE；否则返回FALSE */

顺序栈的类型定义为：
typedef struct {
ElemType *elem; // 存储空间的基址
int top; // 栈顶元素的下一个位置，简称栈顶位标
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack; // 顺序栈

#include "allinclude.h"  //DO NOT edit this line
Status StackEmpty_Sq(SqStack S) { 
    //Add your code here
    
    return S.top == 0;
}

二、实现顺序栈的取栈顶元素操作

【题目】试写一算法，实现顺序栈的取栈顶元素操作
GetTop_Sq(SqStack S, ElemType &e)。

要求实现下列函数：
Status GetTop_Sq(SqStack S, ElemType &e);
/* 取顺序栈S的栈顶元素到e，并返回OK； /
/ 若失败，则返回ERROR。 */

顺序栈的类型定义为：
typedef struct {
ElemType *elem; // 存储空间的基址
int top; // 栈顶元素的下一个位置，简称栈顶位标
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack; // 顺序栈

#include "allinclude.h"  //DO NOT edit this line
Status GetTop_Sq(SqStack S, ElemType &e) { 
    // Add your code here
    
    if(S.top == 0) return ERROR;
    
    e = S.elem[S.top - 1];
    
    return OK;
}

三、实现顺序栈的出栈操作

【题目】试写一算法，实现顺序栈的出栈操作
Pop_Sq(SqStack &S, ElemType &e)。

要求实现下列函数：
Status Pop_Sq(SqStack &S, ElemType &e);
/* 顺序栈S的栈顶元素出栈到e，并返回OK；/
/ 若失败，则返回ERROR。 */

顺序栈的类型定义为：
typedef struct {
ElemType *elem; // 存储空间的基址
int top; // 栈顶元素的下一个位置，简称栈顶位标
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack; // 顺序栈

#include "allinclude.h"  //DO NOT edit this line
Status Pop_Sq(SqStack &S, ElemType &e) { 
    // Add your code here
    
    //判空
    if(S.top == 0) return ERROR;
    
    e = S.elem[S.top - 1];
    
    S.top = S.top - 1;
    
    return OK;
}

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

【题目】若顺序栈的类型重新定义如下。试编写算法，构建初始容量和扩容增量分别为size和inc的空顺序栈S。
typedef struct {
ElemType *elem; // 存储空间的基址
ElemType *top; // 栈顶元素的下一个位置
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack2;

要求实现下列函数：
Status InitStack_Sq2(SqStack2 &S, int size, int inc);
/* 构建初始容量和扩容增量分别为size和inc的空顺序栈S。/
/ 若成功，则返回OK；否则返回ERROR。 */

#include "allinclude.h"  //DO NOT edit this line
Status InitStack_Sq2(SqStack2 &S, int size, int inc) { 
    // Add your code here
    
    S.elem = (ElemType *)malloc(size*sizeof(ElemType));
    
    if(NULL == S.elem||size <= 0||inc <= 0) return ERROR;
    
    S.top = S.elem;//置S为空栈，这里不能写S.top = 0，S.top是指针变量
    
    S.size = size;
    
    S.increment = inc;
    
    return OK;
}

五、实现顺序栈的判空操作

【题目】若顺序栈的类型重新定义如下。试编写算法，
实现顺序栈的判空操作。
typedef struct {
ElemType *elem; // 存储空间的基址
ElemType *top; // 栈顶元素的下一个位置
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack2;

要求实现下列函数：
Status StackEmpty_Sq2(SqStack2 S);
/* 对顺序栈S判空。 /
/ 若S是空栈，则返回TRUE；否则返回FALSE */

#include "allinclude.h"  //DO NOT edit this line
Status StackEmpty_Sq2(SqStack2 S) { 
    // Add your code here
    
    return S.top == S.elem;
}

六、实现顺序栈的入栈操作

【题目】若顺序栈的类型重新定义如下。试编写算法，实现顺序栈的入栈操作。
typedef struct {
ElemType *elem; // 存储空间的基址
ElemType *top; // 栈顶元素的下一个位置
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack2;

要求实现下列函数：
Status Push_Sq2(SqStack2 &S, ElemType e);
/* 若顺序栈S是满的，则扩容，若失败则返回ERROR。/
/ 将e压入S，返回OK。 */

#include "allinclude.h"  //DO NOT edit this line
Status Push_Sq2(SqStack2 &S, ElemType e) { 
    // Add your code here
    
    ElemType *newbase;
    
    //if(S.increment <= 0) return ERROR;//可有可无
    
    if(*(S.top) >= S.size){
      
      newbase = (ElemType *)realloc(S.elem,(S.size + S.increment)*sizeof(ElemType));
      
      if(!newbase) return ERROR;
    
      S.elem = newbase;
      
      S.size += S.increment;
    }
    
    *(S.top) = e;//由于S.top也是指针（地址），故不用写S.elem[]
    
    S.top++;
    
    return OK;
}

七、实现顺序栈的出栈操作

【题目】若顺序栈的类型重新定义如下。试编写算法，实现顺序栈的出栈操作。
typedef struct {
ElemType *elem; // 存储空间的基址
ElemType *top; // 栈顶元素的下一个位置
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack2;

要求实现下列函数：
Status Pop_Sq2(SqStack2 &S, ElemType &e);
/* 若顺序栈S是空的，则返回ERROR； /
/ 否则将S的栈顶元素出栈到e，返回OK。*/

#include "allinclude.h"  //DO NOT edit this line
Status Pop_Sq2(SqStack2 &S, ElemType &e) { 
    // Add your code here
    
    //判空
    if(S.top == S.elem) return ERROR;
    
    e = *(S.top - 1);
    
    S.top--;//出栈后栈顶位标要下移
    
    return OK;
}

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

【题目】试写一算法，借助辅助栈，复制顺序栈S1得到S2。
Status CopyStack_Sq(SqStack S1, SqStack &S2)。

要求实现下列函数：
Status CopyStack_Sq(SqStack S1, SqStack &S2);
/* 借助辅助栈，复制顺序栈S1得到S2。 /
/ 若复制成功，则返回TRUE；否则FALSE。 */

顺序栈的类型定义为：
typedef struct {
ElemType *elem; // 存储空间的基址
int top; // 栈顶元素的下一个位置，简称栈顶位标
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack; // 顺序栈
可调用顺序栈接口中下列函数：
Status InitStack_Sq(SqStack &S, int size, int inc); // 初始化顺序栈S
Status DestroyStack_Sq(SqStack &S); // 销毁顺序栈S
Status StackEmpty_Sq(SqStack S); // 栈S判空，若空则返回TRUE，否则FALSE
Status Push_Sq(SqStack &S, ElemType e); // 将元素e压入栈S
Status Pop_Sq(SqStack &S, ElemType &e); // 栈S的栈顶元素出栈到e

#include "allinclude.h"  //DO NOT edit this line
Status CopyStack_Sq(SqStack S1, SqStack &S2) { 
    // Add your code here
    
    SqStack S0;//创建辅助栈
    
    InitStack_Sq(S0,S1.size,S1.increment);//初始化辅助栈
    InitStack_Sq(S2,S1.size,S1.increment);
    
    S0.top = 0;//把辅助栈置空
    S2.top = 0;
    
    int i,l;
    ElemType e;
    
    l = S1.top;//用l记住S1原始的元素个数，因为下面用Pop_Sq函数后，top会改变
    
    if(StackEmpty_Sq(S1)) return TRUE;
    
    //先把S1复制到S0
    for(i = 0;i < l;i++){
      
      Pop_Sq(S1,e);
      Push_Sq(S0,e);
    }
    
    //在把辅助栈S0复制到S2
    for(i = 0;i < l;i++){
      
      Pop_Sq(S0,e);
      Push_Sq(S2,e);
    }
    
    DestroyStack_Sq(S0);
    
    return TRUE;
}

九、求循环队列的长度

【题目】试编写算法，求循环队列的长度。
循环队列的类型定义为：
typedef struct {
ElemType *base; // 存储空间的基址
int front; // 队头位标
int rear; // 队尾位标，指示队尾元素的下一位置
int maxSize; // 最大长度
} SqQueue;

要求实现下列函数：
int QueueLength_Sq(SqQueue Q);
/* 返回队列Q中元素个数，即队列的长度。*/

#include "allinclude.h"  //DO NOT edit this line
int QueueLength_Sq(SqQueue Q) { 
    // Add your code here
    
    return (Q.rear-Q.front+Q.maxSize)%Q.maxSize;
}

十、编写入队列和出队列的算法

【题目】如果希望循环队列中的元素都能得到利用，
则可设置一个标志域tag，并以tag值为0或1来区分尾
指针和头指针值相同时的队列状态是"空"还是"满"。
试编写与此结构相应的入队列和出队列的算法。

本题的循环队列CTagQueue的类型定义如下：
typedef struct {
ElemType elem[MAXQSIZE];
int tag;
int front;
int rear;
} CTagQueue;

实现下列函数：
Status EnCQueue(CTagQueue &Q, ElemType x);
/* 将元素x加入队列Q，并返回OK；/
/ 若失败，则返回ERROR。 /
Status DeCQueue(CTagQueue &Q, ElemType &x);
/ 将队列Q的队头元素退队到x，并返回OK；/
/ 若失败，则返回ERROR。 */

#include "allinclude.h"  //DO NOT edit this line

//入队
Status EnCQueue(CTagQueue &Q, ElemType x) { 
    // Add your code here
    
    if(Q.tag == 1&&Q.front == Q.rear) return ERROR;
    
    Q.elem[Q.rear] = x;
    Q.rear = (Q.rear + 1)%MAXQSIZE;
    
    Q.tag = 1;
    
    return OK;
}

//出队
Status DeCQueue(CTagQueue &Q, ElemType &x){
  
  if(Q.tag == 0&&Q.front == Q.rear) return ERROR;
  
  x = Q.elem[Q.front];
  Q.front = (Q.front + 1)%MAXQSIZE;
  
  Q.tag = 0;
  
  return OK;
}

十一、写出循环队列的入队列和出队列的算法

【题目】假设将循环队列定义为：以域变量rear和length分别指示循环队列中队尾元素的位置和内含元素的个数。试给出此循环队列的队满条件，并写出相应的入队列和出队列的算法（在出队列的算法中要返回队头元素）。

本题的循环队列CLenQueue的类型定义如下：
typedef struct {
ElemType elem[MAXQSIZE];
int length;
int rear;
} CLenQueue;

实现下列函数：
Status EnCQueue(CLenQueue &Q, ElemType x);
/* 将元素x加入队列Q，并返回OK；/
/ 若失败，则返回ERROR。 /
Status DeCQueue(CLenQueue &Q, ElemType &x);
/ 将队列Q的队头元素退队到x，并返回OK；/
/ 若失败，则返回ERROR。 */

#include "allinclude.h"  //DO NOT edit this line

//入队
Status EnCQueue(CLenQueue &Q, ElemType x) { 
    // Add your code here
    
    if(Q.elem == NULL||Q.length == MAXQSIZE) return ERROR;
    
    Q.elem[Q.rear+1] = x;
    
    Q.rear = (Q.rear+1)%MAXQSIZE;
    
    Q.length = Q.length+1;
    
    return OK;
}

//出队
Status DeCQueue(CLenQueue &Q, ElemType &x){
    // Add your code here
    
    if(Q.elem == NULL||Q.length == 0) return ERROR;
    
    if(Q.rear >= Q.length-1) x = Q.elem[Q.rear-Q.length+1];
    else x = Q.elem[MAXQSIZE+1-Q.length+Q.rear];
    
    Q.length = Q.length-1;
    
    return OK;
}

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

【题目】已知k阶斐波那契序列的定义为:
f0=0, f1=0, …, fk-2=0, fk-1=1;
fn=fn-1+fn-2+…+fn-k, n=k,k+1,…
试利用循环队列编写求k阶斐波那契序列中第n+1项fn的算法。

本题的循环队列的类型定义如下：
typedef struct {
ElemType *base; // 存储空间的基址
int front; // 队头位标
int rear; // 队尾位标，指示队尾元素的下一位置
int maxSize; // 最大长度
} SqQueue;

要求实现下列函数：
long Fib(int k, int n);
/* 求k阶斐波那契序列的第n+1项fn */

#include "allinclude.h"  //DO NOT edit this line
long Fib(int k, int n) { 
    // Add your code here
    
    //if(k < 2||n < -1) return 0;
    
    int sum,i,j;
    SqQueue *Q = (SqQueue *)malloc(sizeof(SqQueue));
    
    //初始化队列Q
    Q->maxSize = n+2;
    Q->base = (ElemType *)malloc(Q->maxSize*sizeof(ElemType));
    //if(NULL == Q.base) return 0;..
    Q->rear = Q->front = 0;
    
    if(n+1 < k) return 0;
    else{
      
      if(n+1 == k) return 1;
      else{
        
        for(i = 0;i < k-1;i++){
          
          Q->base[Q->rear] = 0;
          Q->rear++;
        }
        
        Q->base[k-1] = 1;
        Q->rear = Q->rear+1;
        
        for(i = k;i <= n;i++){
          
          sum = 0;
          
          for(j = i-k;j < i;j++) sum += Q->base[j];
          
          Q->base[i] = sum;
          Q->rear = Q->rear+1;
        }
        }
      }

      return Q->base[n];
}

十三、试写一个比较A和B大小的算法

【题目】设A=(a1,…,am)和B=(b1,…,bn)均为有序顺序表，
A’和B’分别为A和B中除去最大共同前缀后的子表（例如，
A=(x,y,y,z,x,z)，B=(x,y,y,z,y,x,x,z)，则两者中最大
的共同前缀为(x,y,y,z)， 在两表中除去最大共同前缀后
的子表分别为A’=(x,z)和B’=(y,x,x,z)）。若A’=B’=空表，
则A=B；若A’=空表，而B’≠ 空表，或者两者均不为空表，
且A’的首元小于B’的首元，则A<B；否则A>B。试写一个比
较A和B大小的算法。（注意：在算法中，不要破坏原表A
和B，也不一定先求得A’和B’才进行比较）。

顺序表类型定义如下：
typedef struct {
ElemType *elem;
int length;
int size;
int increment;
} SqList;

要求实现下列函数：
char Compare(SqList A, SqList B);
/* 比较顺序表A和B, /
/ 返回’<’, 若A<B; /
/ ‘=’, 若A=B; /
/ ‘>’, 若A>B */

#include "allinclude.h"  //DO NOT edit this line
char Compare(SqList A, SqList B) { 
    // Add your code here
    
    int L,i;
    
    L = (A.length < B.length)?A.length:B.length;
    
    for(i = 0;i < L;i++){
      
      if(A.elem[i] == B.elem[i]) continue;
      else break;
    }
    
    //刚好遍历完长度较小那个表
    if(i == L){
      
      if(B.length == A.length) return '=';
      else 
      if(L == A.length) return '<';
      else return '>';
    }else{//没遍历完
      
      if(A.elem[i] > B.elem[i]) return '>';
      else return '<';
    }
}

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

【题目】试写一算法，实现顺序表的就地逆置，即利用原表的存储空间将线性表(a1,a2,…,an)逆置为(an,an-1,…,a1)。

顺序表类型定义如下：
typedef struct {
ElemType *elem;
int length;
int size;
int increment;
} SqList;

实现下列函数：
void Inverse(SqList &L);

#include "allinclude.h"  //DO NOT edit this line
void Inverse(SqList &L) { 
    // Add your code here
    
    ElemType t;
    
    for(int i = 0;i < L.length/2;i++){
      
      t = L.elem[i];
      L.elem[i] = L.elem[L.length-i-1];
      L.elem[L.length-i-1] = t;
    }
}

十五、试写一算法，求并集A＝A∪B

【题目】假设有两个集合A和B分别用两个线性表LA和LB
表示(即：线性表中的数据元素即为集合中的成员），
试写一算法，求并集A＝A∪B。

顺序表类型定义如下
typedef struct {
ElemType *elem; // 存储空间的基址
int length; // 当前长度
int size; // 存储容量
int increment; // 空间不够增加空间大小
} SqList; // 顺序表

可调用顺序表的以下接口函数：
Status InitList_Sq(SqList &L, int size, int inc); // 初始化顺序表L
int ListLength_Sq(SqList L); // 返回顺序表L中元素个数
Status GetElem_Sq(SqList L, int i, ElemType &e);
// 用e返回顺序表L中第i个元素的值
int Search_Sq(SqList L, ElemType e);
// 在顺序表L顺序查找元素e，成功时返回该元素在表中第一次出现的位置，否则返回-1
Status Append_Sq(SqList &L, ElemType e); // 在顺序表L表尾添加元素e

实现如下算法：
void Union(SqList &La, List Lb)。

#include "allinclude.h"  //DO NOT edit this line
void Union(SqList &La, List Lb){ 
    // Add your code here
    
    int lb,i;
    ElemType m;
    
    lb = ListLength_Sq(Lb);
    
    for(i = 1;i <= lb;i++){//i从1到lb开始，不是从0开始
      
      GetElem_Sq(Lb,i,m);
      
      if(Search_Sq(La,m) == -1) Append_Sq(La,m);
      else continue;
    }
}

十六、试写一算法，实现链栈的判空操作

【题目】试写一算法，实现链栈的判空操作。
链栈的类型定义为：
typedef struct LSNode {
ElemType data; // 数据域
struct LSNode *next; // 指针域
} LSNode, *LStack; // 结点和链栈类型

要求实现下列函数：
Status StackEmpty_L(LStack S);
/* 对链栈S判空。若S是空栈，则返回TRUE；否则返回FALSE */

#include "allinclude.h"  //DO NOT edit this line
Status StackEmpty_L(LStack S){ 
    // Add your code here
    
    return S == NULL;
}

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

【题目】试写一算法，实现链栈的取栈顶元素操作。
链栈的类型定义为：
typedef struct LSNode {
ElemType data; // 数据域
struct LSNode *next; // 指针域
} LSNode, *LStack; // 结点和链栈类型

要求实现下列函数：
Status GetTop_L(LStack S, ElemType &e);
/* 取链栈S的栈顶元素到e，并返回OK; /
/ 若S是空栈，则失败，返回ERROR。 */

#include "allinclude.h"  //DO NOT edit this line
Status GetTop_L(LStack S, ElemType &e){ 
    // Add your code here
    
    LStack t;
    
    if(!S) return ERROR;
    
    t = S;
    e = S->data;
    S = S->next;
    //free(t);不知道为啥写free就不行
    t = NULL;
    
    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。*/

#include "allinclude.h"  //DO NOT edit this line
Status QueueEmpty_LQ(LQueue Q){ 
    // Add your code here
    
    return !Q.front&&!Q.rear;
}

十九、实现链队列的求队列长度操作

【题目】试写一算法，实现链队列的求队列长度操作。

链队列的类型定义为：
typedef struct LQNode {
ElemType data;
struct LQNode *next;
} LQNode, *QueuePtr; // 结点和结点指针类型
typedef struct {
QueuePtr front; // 队头指针
QueuePtr rear; // 队尾指针
} LQueue; // 链队列类型

要求实现下列函数：
int QueueLength_LQ(LQueue Q);
/* 求链队列Q的长度并返回其值 */

#include "allinclude.h"  //DO NOT edit this line
int QueueLength_LQ(LQueue Q){ 
    // Add your code here
    
    QueuePtr p;
    int sum = 0;
    
    p = Q.front;
    
    while(p){
      
      sum++;
      p=p->next;
    }
    
    return sum;
}

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

【题目】假设以带头结点的循环链表表示队列，并且
只设一个指针指向队尾元素结点(注意不设头指针)，
试编写相应的队列初始化、入队列和出队列的算法。

带头结点循环链队列CLQueue的类型定义为：
typedef struct LQNode {
ElemType data;
struct LQNode *next;
} LQNode, *CLQueue;

实现下列函数：
Status InitCLQueue(CLQueue &rear); // 初始化空队列
Status EnCLQueue(CLQueue &rear, ElemType x); // 入队
Status DeCLQueue(CLQueue &rear, ElemType &x); // 出队

#include "allinclude.h"  //DO NOT edit this line
Status InitCLQueue(CLQueue &rear){//初始化 
    // Add your code here
    
    rear = (CLQueue)malloc(sizeof(CLQueue));
    if(NULL == rear) return ERROR;
    
    rear->next = rear;//因为是循环链表，所以不是rear->next = NULL
    
    return OK;
} 

Status EnCLQueue(CLQueue &rear, ElemType x){//入队 
    // Add your code here
    
    CLQueue p;
    p = (CLQueue)malloc(sizeof(CLQueue));
    
    if(NULL == p) return ERROR;
    
    p->data = x;
    p->next = rear->next;//因为是循环链表，所以不可以写p->next = NULL:
    
    rear->next = p;
    rear = p;
    
    return OK;
}

Status DeCLQueue(CLQueue &rear, ElemType &x){//出队 
    // Add your code here
    
    CLQueue p;
    
    if(rear == rear->next) return ERROR;//判空操作，不是用NULL
    
    p = rear->next->next;
    rear->next->next = p->next;
    x = p->data;
    p = NULL;
    
    return OK;
}

二十一、实现带头结点单链表的判空操作

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

单链表的类型定义为：
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList; // 结点和结点指针类型

要求实现下列函数：
Status ListEmpty_L(LinkList L);
/* 判定带头结点单链表L是否为空链表。 /
/ 若L是空链表，则返回TRUE，否则FALSE。*/

#include "allinclude.h"  //DO NOT edit this line
Status ListEmpty_L(LinkList L){ 
    // Add your code here
    
    return !L||!L->next;
}

二十一、实现带头结点单链表的销毁操作

【题目】试写一算法，实现带头结点单链表的销毁操作。

单链表的类型定义为：
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList; // 结点和结点指针类型

要求实现下列函数：
Status DestroyList_L(LinkList &L);
/* 销毁带头结点单链表L，并返回OK。*/

#include "allinclude.h"  //DO NOT edit this line
Status DestroyList_L(LinkList &L){ 
    // Add your code here
    
    LinkList p,q;
    
    p = L->next;
    
    if(!p){
      
      //free(L);
      L = NULL;
      return OK;
    }
    
    while(p){
      
      q = p;
      p = p->next;
      free(q);
    }
    
    L = NULL;
    
    //free(L);
    return OK;
}

二十二、实现带头结点单链表的清空操作

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

单链表的类型定义为：
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList; // 结点和结点指针类型

要求实现下列函数：
Status ClearList_L(LinkList &L);
/* 将带头结点单链表L置为空表，并返回OK。/
/ 若L不是带头结点单链表，则返回ERROR。 */

#include "allinclude.h"  //DO NOT edit this line
Status ClearList_L(LinkList &L){ 
    // Add your code here
    
    if(!L) return ERROR;
    
    LinkList p,q;
    
    p = L->next;
    
    //把后面的结点销毁，以免浪费内存
    while(p != NULL){
      
      q = p;
      p = p->next;
      free(q);
    }
    
    L->next = NULL;
    
    return OK;
}

二十三、实现带头结点单链表的求表长度操作

【题目】试写一算法，实现带头结点单链表的求表长度操作。

单链表的类型定义为：
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList; // 结点和结点指针类型

要求实现下列函数：
int ListLength_L(LinkList L);
/* 求带头结点单链表L的长度，并返回长度值。/
/ 若L不是带头结点单链表，则返回-1。 */

#include "allinclude.h"  //DO NOT edit this line
int ListLength_L(LinkList L){ 
    // Add your code here
    
    if(!L) return -1;
    
    int sum = 0;
    LinkList p;
    
    p = L->next;
    
    while(p != NULL){
      
      sum++;
      p = p->next;
    }
    
    return sum;
}

二十四、在带头结点单链表L插入第i元素e

【题目】试写一算法，在带头结点单链表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。 */

#include "allinclude.h"  //DO NOT edit this line
Status Insert_L(LinkList L, int i, ElemType e){ 
    // Add your code here
    
    LinkList p = L;
    LinkList q,m;
    int sum = 0;
    
    if(!L||i<1) return ERROR;
    
    while(p&&sum < i){
      
      q = p;//用q记住p前一个结点
      p = p->next;
      
      sum++;
    }
    
    if(sum < i) return ERROR;
    
    m->data = e;
    q->next = m;
    m->next = p;
      
    return OK;
}

二十五、在带头结点单链表删除第i元素到e

【题目】试写一算法，在带头结点单链表删除第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。 */

#include "allinclude.h"  //DO NOT edit this line
Status Delete_L(LinkList L, int i, ElemType &e){ 
    // Add your code here
    
    if(!L||!L->next||i < 1) return ERROR;
    
    LinkList p,q;
    int sum = 0;
    
    p = L;
    
    while(p->next != NULL&&sum < i){
      
      q = p;
      p = p->next;
      
      sum++;
    }
    
    if(sum < i) return ERROR;
    
    e = p->data;
    q->next = p->next;
    p = NULL;
    
    return OK;
}

二十六、在带头结点单链表的第i元素起的所有元素从链表移除，并构成一个带头结点的新链表

【题目】试写一算法，在带头结点单链表的第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。 */

#include "allinclude.h"  //DO NOT edit this line
Status Split_L(LinkList L, LinkList &Li, int i){ 
    // Add your code here
    
    Li = (LinkList)malloc(sizeof(LinkList));//要先给新头结点申请空间
    
    if(!L||!L->next||i < 1){
      
      Li = NULL;
      return ERROR;
    }
    
    int sum = 0;
    LinkList p,q;
    
    p = L;
    
    while(p->next&&sum < i){
      
      q = p;
      p = p->next;
      
      sum++;
    }
    
    if(sum < i){
      
      Li = NULL;
      return ERROR;
    }
    
    Li->next = p;
    q->next = NULL;
    
    return OK;
}

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

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

带头结点单链表的类型定义为：
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList;

实现下列函数：
Status Cut_L(LinkList L, int i);
/* 在带头结点单链表L删除第i元素起的所有元素，并返回OK。/
/ 若参数不合理，则返回ERROR。 */

#include "allinclude.h"  //DO NOT edit this line
Status Cut_L(LinkList L, int i){ 
    // Add your code here
    
    if(!L||!L->next||i < 1) return ERROR;
    
    LinkList p,q,m;
    int sum = 0;
    
    p = L;
    
    while(p->next&&sum < i){
    
      q = p;
      p = p->next;
      sum++;
    }
    
    if(sum < i) return ERROR;
    
    //把i后面的结点删除掉
    while(p != NULL){
      
      m = p;
      p = p->next;
      
      m = NULL;
    }
    
    q->next = NULL;

    return OK;
}

二十八、删除带头结点单链表中所有值为x的元素

【题目】试写一算法，删除带头结点单链表中所有值为x的元素，并释放被删结点空间。

单链表类型定义如下：
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList;

实现下列函数：
Status DeleteX_L(LinkList L, ElemType x);
/* 删除带头结点单链表L中所有值为x的元素， /
/ 并释放被删结点空间，返回实际删除的元素个数。*/

#include "allinclude.h"  //DO NOT edit this line
Status DeleteX_L(LinkList L, ElemType x) { 
    // Add your code here
    
    LinkList p;
    
    p = L;
    
    if(!p||!p->next) return ERROR;
    
    LinkList m;
    int sum = 0;
    
    while(p->next){
      
      m = p;
      
      if(m->next->data == x){
        
        m = m->next;
        p->next = m->next;
        m = NULL;
        
        sum++;
        
        continue;//删除一个结点后不要后移，不然会漏掉结点
      }
      
      p = p->next;
    }
    
    return sum;
}

二十九、删除带头结点单链表中所有值小于x的元素

【题目】试写一算法，删除带头结点单链表中所有值小于x的元素，并释放被删结点空间。

单链表类型定义如下：
typedef struct LNode {
ElemType data;
struct LNode *next;
} LNode, *LinkList;

实现下列函数：
Status DeleteSome_L(LinkList L, ElemType x);
/* 删除带头结点单链表L中所有值小于x的元素， /
/ 并释放被删结点空间，返回实际删除的元素个数。*/

#include "allinclude.h"  //DO NOT edit this line
Status DeleteSome_L(LinkList L, ElemType x) { 
    // Add your code here
    
    if(!L||!L->next) return ERROR;
    
    LinkList p,m;
    int sum = 0;
    
    p = L;
    
    while(p->next){
      
      m = p;
      
      if(m->next->data < x){
        
        m = p->next;
        p->next = m->next;
        m = NULL;
        
        sum++;
        
        continue;
      }
      
      p = p->next;
    }
    
    return sum;
}
輝长六加1
关注
  • 8
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
广东工业大学数据结构AnyView参考答案
m0_54241235的博客
09-05 9595
广东工业大学数据结构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 作业系统 第二章答案
11-18
"广东工业大学 数据结构 anyview 作业系统 第二章答案" 本资源摘要信息是关于广东工业大学数据结构anyview作业系统第二章的答案，涵盖了顺序表和链表两种数据结构的操作和比较算法。 一、顺序表的插入和比较算法 ...
数据结构anyview答案
06-06
数据结构anyview答案，第五章的，包括必做和选作
广工 Anyview 数据结构习题 第一章
雁过留痕的博客
12-28 5699
广工 AnyviewC 数据结构习题 第一章广工 AnyviewC 数据结构习题 第一章【题目】试写一算法，对序列S的第i个元素赋以值e。【题目】试写一算法，由长度为n的一维数组a构建一个序列S。【题目】链表的结点和指针类型定义如下【题目】链表的结点和指针类型定义如下 广工 AnyviewC 数据结构习题 第一章 作者水平有限，如果读者有更好的实现，可留言。有任何问题，欢迎留言交流。 ##【题目】...
厂工数据结构Anyview（C语言版）第六章答案
CV工程师的博客
01-22 3974
第六章一、判别两棵二叉树是否相似二、编写递归算法，求对二叉树T先序遍历时第k个访问的结点的值三、编写递归算法，计算二叉树T中叶子结点的数目四、试利用栈及其基本操作写出二叉树T的非递归的先序遍历算法五、试利用栈及其基本操作写出二叉树T的非递归的后序遍历算法六、二叉树采用三叉链表的存储结构，试编写不借助栈的非递归中序遍历算法七、编写不用栈辅助的二叉树非递归后序遍历算法八、编写递归算法，将二叉树中所有结点的左、右子树相互交换九、编写递归算法：求二叉树中以元素值为x的结点为根的子树的深度十、 编写递归算法：对于二叉
厂工数据结构Anyview（C语言版）第五章答案
CV工程师的博客
01-21 2320
第五章一、根据给定的递归函数编写递归算法二、根据给定的递归函数F(n)编写递归算法三、利用递归算法求解平方根四、请写出Ackerman函数的递归算法五、试写出求递归函数F(n)的非递归算法六、试写出求解平方根的非递归算法七、将给定点元素同色区域的颜色进行置换八、求广义表的深度九、判别两个广义表是否相等十、输出广义表中所有原子项及其所在的层次 一、根据给定的递归函数编写递归算法 【题目】试编写如下定义的递归函数的递归算法: g(m,n) = 0 当m=0,n>=0 g(m,n)
厂工数据结构Anyview（C语言版）第一章答案
CV工程师的博客
01-19 1659
第一章一、将三个整数按升序重新排列二、求一元多项式的值三、求k阶裴波那契序列的第m项的值四、计算i!×2^i的值五、由一维数组构建一个序列六、构建一个值为x的结点七、构建长度为2且两个结点的值依次为x和y的链表八、构建长度为2的升序链表 一、将三个整数按升序重新排列 【题目】试写一算法，如果三个整数a，b和c的值不是依次非递增的，则通过交换，令其为非递增。 要求实现下列函数： void Descend(int &a, int &b, int &c); /* 通过交换，令 a >
广工Anyview数据结构2021-C语言版--第一章
m0_53106380的博客
09-13 989
第一章 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（C语言版）第三、四章答案
CV工程师的博客
01-20 1539
第三、四章第三章一、改写直接插入排序算法二、改进的冒泡排序三、计数排序第四章一、哈希表中关键字的有序输出二、链地址哈希表的构造 第三章 一、改写直接插入排序算法 【题目】试以顺序表L的L.rcd[L.length+1]作为监视哨，改写教材3.2节中给出的升序直接插入排序算法。 顺序表的类型RcdSqList定义如下： typedef struct { KeyType key; … } RcdType; typedef struct { RcdType rcd[MAXSIZE+1]; // rcd[0]闲置
厂工数据结构Anyview（C语言版）第七、八章答案（完结）
CV工程师的博客
01-23 1461
第七、八章第七章一、试编写算法，对一棵以孩子兄弟链表表示的树统计叶子的个数二、试编写算法，求一棵以孩子兄弟链表表示的树的度三、试编写算法，对以双亲表示法存储的树计算深度四、试编写算法，对以双亲孩子表示法存储的树计算深度五、试编写算法，对以孩子-兄弟链表表示的树计算深度六、试编写非递归算法，实现并查集带路径压缩的查找操作第八章一、编写算法，创建有向图的邻接数组存储结构二、编写算法，在图G中，相对于k顶点的当前邻接顶点m顶点，求下一个邻接顶点三、编写算法，在图G中置顶点v到顶点w的弧或边四、编写算法，计算以邻接
广东工业大学数据结构anyview代码第二章
01-25
在第二章的学习中，通常会涉及到一系列的核心概念和算法，这些内容对于理解和解决实际编程问题至关重要。下面将详细讲解这一章中的关键知识点。 1. **线性表**：线性表是最基础的数据结构之一，它是由n（n≥0）个...
广东工业大学 数据结构 anyview 作业系统 第六章答案
11-18
"数据结构算法设计" 在数据结构中，二叉树是一种常见的数据结构形式，它在计算机科学和软件工程中有着广泛的应用。以下是对给定文件信息的知识点总结： 一、判别结点 u 是否为结点 v 的子孙 在给定的问题中，我们...
广东工业大学 数据结构 anyview 作业系统 第五章答案
11-18
本文将针对广东工业大学数据结构课程中AnyView作业系统第五章的答案，具体讨论稀疏矩阵的三元组表示和二元组表示，并实现矩阵相加和元素访问的算法。 一、稀疏矩阵的三元组表示 在数据结构中，稀疏矩阵通常使用...
广东工业大学数据结构anyview代码第一章
01-25
广东工业大学数据结构anyview代码第一章 本资源摘要信息对应的是广东工业大学数据结构课程的anyview代码第一章，以下是对该资源的详细说明和知识点总结。 标题解释 该资源的标题为“广东工业大学数据结构anyview...
Anyview数据结构第二章（按需自取）
2302_79085918的博客
12-02 474
【代码】Anyview数据结构第二章（按需自取）
c语言（7.23）
fhgfyrsg的博客
07-23 455
【代码】c语言（7.23）
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 780
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构之判断完全二叉树详解与示例（C，C++）
最新发布
qq_35320456的博客
07-23 397
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
广东工业大学数据结构第二章Anyview练习代码解析
"这些代码是广东工业大学数据结构课程中关于栈操作的部分练习，涉及了创建、初始化、检查栈是否为空、获取栈顶元素以及出栈等基本操作。" 在数据结构中，栈是一种非常重要的线性数据结构，遵循“后进先出”（Last ...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值