数据结构第三次上机题

最新推荐文章于 2022-11-13 14:35:32 发布
最新推荐文章于 2022-11-13 14:35:32 发布
阅读量3.4k 收藏 51
点赞数 8
分类专栏： 笔记 基础知识 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52326703/article/details/120808955
版权

第三次上机题

1.链表基础概念

2-1

链表不具有的特点是______B_____?
A.插入、删除不需要移动元素
B.可随机访问任意元素
C.不必事先估计存储空间
D.所需空间与线性长度成正比
2-2

设单链表中结点的结构为（data，next）。若在指针p所指结点后插入由指针s指向的结点，则应执行__B__操作。
A.p ->next=s; s ->next=p;
B.s ->next=p ->next; p ->next=s;
C.s-> next=p; s=p;
D.p ->next=s; s ->next=p ->next;

2-3

在双向链表指针p的指针前插入一个指针q的结点，操作是______C_______。
(2分)
A.p->prior=q; q->next=p; p->prior->next=q; q->prior =q;
B.p->prior=q; p->prior->next=q; q->next=p; q->prior =p->prior;
C.q->next=p; q->prior =p->prior; p->prior->next=q; p->prior =q;
D.q->prior =p->prior; q->next=q; p->prior=q; p->prior =q;

2-4

对于一个具有n个结点的单链表，在已知的结点 *p 后面插入一个新结点的时间复杂度和在给定值为x 的结点后插入一个新结点的时间复杂度分别是____B_____。
(2分)
A.O(n)，O(n)
B.O(1)，O(n)
C.O(1)，O(1)
D.O(n)，O(1)

2-5

以下错误的是_____B______。

（1）静态链表既有顺序存储的优点，又有动态链表的优点。所以，它存取表中第 i 个元素的时间与i无关。

（2）静态链表中能够容纳的元素个数的最大数在表定义时就确定了，以后不能增加。

（3）静态链表与动态链表在元素的插入、删除上类似，不需要做元素的移动。
(2分)
A.（1），（2）
B.（1）
C.（1），（2），（3）
D.（2）

2. 顺序表逆置 (10 分))

6-1 顺序表逆置 (10 分))

设有一线性表e={e1,e2,…,en-1,en)，其逆线性表定义为e’={en,en-1,…,e2,e1}。请设计一个算法，将线性表逆置，要求逆线性表仍占用原线性表的空间，并且用顺序表来表示，写出逆置函数。
函数接口定义：

void reverse(SeqList *q );

其中 q 是用户传入的参数，为指向顺序表的指针。其中类型定义如下：


#define MAXSIZE 100
typedef int ElemType;
typedef struct
{
    ElemType elem[MAXSIZE];
    int length;
}SeqList;

裁判测试程序样例：

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
typedef int ElemType;
typedef struct
{
    ElemType elem[MAXSIZE];
    int length;
}SeqList;

SeqList * CreatList();
void PrintList(SeqList *q);
void reverse(SeqList *q );

main()
{
    SeqList *q;
    q=CreatList();
    reverse(q);
    PrintList(q);
}

SeqList * CreatList()
{
    SeqList *sq = (SeqList*)malloc(sizeof(SeqList));
    scanf("%d",&(sq->length));
    for(int i=0;i<sq->length;i++)
    {
        scanf("%d",&(sq->elem[i]));
    }
    return sq;
}
void PrintList(SeqList *sq)
{
    for(int i=0;i<sq->length;i++)
        printf("%d ",sq->elem[i]);
}

/* 请在这里填写答案 */

输入样例：

在这里给出一组输入。例如：

6
1 2 3 4 5 6
结尾无空行

输出样例：

在这里给出相应的输出。例如：

6 5 4 3 2 1
结尾无空行

void reverse(SeqList *q){
    int i=0,t,l=q->length;
    while(i<l/2){
        t=q->elem[i];
        q->elem[i]=q->elem[l-1-i];
        q->elem[l-1-i]=t;
        i++;
    }
}

3. 单链表逆置 (10 分)

设有一线性表e={e1,e2,…,en-1,en)，其逆线性表定义为e’={en,en-1,…,e2,e1}。请设计一个算法，将线性表逆置，要求逆线性表仍占用原线性表的空间，并且用单链表来表示，写出逆置函数。
函数接口定义：

void Reverse( LinkList head );

q 是用户传入的参数，为单链表的头指针。其中类型定义如下：

typedef int DataType;
typedef struct node
{
    DataType data;
    struct node *next;
}LNode,*LinkList;

裁判测试程序样例：

#include<stdio.h>
#include<stdlib.h>
typedef int DataType;
typedef struct node
{
    DataType data;
    struct node *next;
}LNode,*LinkList;

LinkList CreatList(); 
void PrintList(LinkList head );
void Reverse( LinkList head );

main()
{
    LinkList q;
    q=CreatList();
    Reverse(q);
    PrintList(q);
}


LinkList  CreatList()
{
    LinkList h = (LinkList)malloc(sizeof(LNode));
    LNode *p,*tail= h;
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {   
        p=(LNode*)malloc(sizeof(LNode));
        scanf("%d",&(p->data));
        tail->next = p;
        tail = p;
    }
    tail->next=NULL;
    return h;
}
void PrintList(LinkList head )
{
     LNode *p = head->next;
     while (p) 
     {
         printf("%d ", p->data);
         p = p->next;
     }
}


/* 请在这里填写答案 */

输入样例：

在这里给出一组输入。例如：

5
1 2 3 4 5
结尾无空行

输出样例：

在这里给出相应的输出。例如：

5 4 3 2 1
结尾无空行

void Reverse(LinkList H){
	LNode *p,*q;
	p=H->next;
	H->next=NULL;
	while(p)
	{
		q=p;
		p=p->next;
		q->next=H->next;
		H->next=q;
	}
}

4.找出顺序表中的最小值 (15 分)

已知长度为n的线性表采用顺序存储结构，请设计一个算法，找出该线性表中值最小的数据元素。 顺序表的存储结构如下：

#define MAXSIZE 100
typedef int ElemType;
typedef struct
{
    ElemType elem[MAXSIZE]; 
    int length;
}SeqList;

函数接口定义：

int FindMin(SeqList *q );

其中 q 是用户传入的参数，为指向顺序表的指针。函数返回值最小元素的下标。（注意，下标从0开始）
裁判测试程序样例：

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
typedef int ElemType;
typedef struct
{
    ElemType elem[MAXSIZE];
    int length;
}SeqList;

SeqList * CreatList();
int FindMin(SeqList *q );

main()
{
    SeqList *q;
    q=CreatList();
    int min=FindMin(q);
    printf("最小值为第%d个，其值为%d。",min+1,q->elem[min]);
}

SeqList * CreatList()
{
    SeqList *sq = (SeqList*)malloc(sizeof(SeqList));
    scanf("%d",&(sq->length));
    for(int i=0;i<sq->length;i++)
    {
        scanf("%d",&(sq->elem[i]));
    }
    return sq;
}


/* 请在这里填写答案 */

输入样例：

在这里给出一组输入。例如：

5
12 45 8 345 67
结尾无空行

输出样例：

在这里给出相应的输出。例如：

最小值为第3个，其值为8。
结尾无空行

int FindMin(SeqList *q ){
	int i=0;
	int t=q->elem[i];
	for(i=1;i<q->length;i++)
	{
		if(t>q->elem[i])
		t=q->elem[i];
	}
	for(i=0;i<q->length;i++){
		if(q->elem[i]==t)break;
	}
	return i;
}

5.删除顺序表中指定值元素 (15 分)

删除给定顺序表中值为x的元素。

其中顺序表定义如下：

#define MAXSIZE 100
typedef int ElemType;
typedef struct
{
    ElemType elem[MAXSIZE];
    int length;
}SeqList;

函数接口定义：

void DeleteX(SeqList *q,ElemType x);

其中 q 和 x 都是用户传入的参数。 q 为指向顺序表的指针； x为待删除元素。
裁判测试程序样例：

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
typedef int ElemType;
typedef struct
{
    ElemType elem[MAXSIZE];
    int length;
}SeqList;

SeqList * CreatList();
void PrintList(SeqList *sq);
void DeleteX(SeqList *q,ElemType x);


main()
{
    SeqList *q;
    ElemType x;
    q=CreatList();
    scanf("%d",&x);
    DeleteX(q,x);
    PrintList(q);
}

SeqList * CreatList()
{
    SeqList *sq = (SeqList*)malloc(sizeof(SeqList));
    scanf("%d",&(sq->length));
    for(int i=0;i<sq->length;i++)
    {
        scanf("%d",&(sq->elem[i]));
    }
    return sq;
}

void PrintList(SeqList *sq)
{
    for(int i=0;i<sq->length;i++)
        printf("%d ",sq->elem[i]);
}

/* 请在这里填写答案 */

输入样例：

在这里给出一组输入。例如：

8
2 4 6 2 7 2 2 8
2
结尾无空行

输出样例：

在这里给出相应的输出。例如：

4 6 7 8
结尾无空行

void DeleteX(SeqList *q,ElemType x){
 int i,j,k=q->length;//i为待删除元素的位置 
 for(i=0;i<k;i++){
  if(q->elem[i]==x){
   for(j=i;j<=q->length-1;j++){
    if(q->elem[j+1]==x){
     int t=1;
     while(q->elem[j+t]==x){
      t++;
     }
     q->elem[j]=q->elem[j+t];
     j=j+t-1;
    }else q->elem[j]=q->elem[j+1];
   }
   q->length--;
  }
 }
}

6.删除循环链表中已知结点的前驱 (10 分)

假设有一个循环链表的长度大于1，且表中既无头节点也无头指针。已知s为指向链表中某结点的指针，试编写算法，在链表中删除指针s所指结点的前驱结点。
函数接口定义：

void DelPrior (Node * s );

其中 s 是传入的参数，函数要求删除s所指结点的前驱结点。其中类型定义如下：

typedef int DataType;
typedef struct node
{
    DataType data;
    struct node *next;
}LNode,*LinkList;

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>
typedef int DataType;
typedef struct node 
{
    DataType data;
    struct node *next;
}LNode,*LinkList;

LinkList Creat_CircularList();  //创建无头结点循环单链表,并返回头指针。
LNode * SetPointerS(LinkList H,int x);//返回指向第x个结点的指针。
void PrintCircularList(LNode *S);//从指针S所指结点开始，依次输出各个结点的值。
void DelPrior(LNode *S);
main()
{
    LNode *s;
    LinkList H;
    int x;
    H = Creat_CircularList();
    scanf("%d",&x);
    s=SetPointerS(H,x);
    DelPrior(s);
    PrintCircularList(s);
}

LinkList Creat_CircularList()
{
    int n,i;
    LNode *nw,*rear=NULL,*head=NULL;
    scanf("%d",&n);//接收结点总数
    for(i=0;i<n;i++)
    {
        nw=(LNode*)malloc(sizeof(LNode));
        scanf("%d",&nw->data);
        if(rear==NULL)
            rear=head=nw;
        else
        {
            rear->next=nw;
            rear=nw;
        }
    }
    if(rear)
        rear->next=head;
    return head;
}

void PrintCircularList(LinkList s)
{
    LNode *p;
    for(p=s;p->next!=s;p=p->next)
        printf("%d ",p->data);
    printf("%d",p->data);
}

LNode * SetPointerS(LinkList H,int x)
{
    int i;
    LNode *s=H;
    for(i=1;i<x;i++)
        s=s->next;
    return s;
 }


/* 请在这里填写答案 */

输入样例：

在这里给出一组输入。例如：

5
1 2 3 4 5
4
结尾无空行

输出样例：

在这里给出相应的输出。例如：

4 5 1 2
结尾无空行

void DelPrior(LNode *s){
	int a;
	LNode *p,*q;//q为要删除结点，即s的前驱；p为q的前驱结点 
	p=q=s;
	while(q->next!=s){
		q=q->next;
	}
	while(p->next!=q)
	p=p->next;
	a=q->data;
	p->next=s;
	free(q);
}

7. 从单链表LA指定位置删除连续n个元素并插入单链表LB的指定位置 (15 分)

设指针la和lb分别指向两个无头结点单链表中的首元结点，试编写算法，从表la中删除自第i个元素起共len个元素，并将它们插入表lb的第j个元素之后。
函数接口定义：

void MoveLaToLb(LinkList *pa,int i,int len,LinkList *pb,int j);

其中 pa 和 pb 分别为两个单链表的头指针la和lb的指针。 i, j, len的意义与题目描述部分相同。注意：对参数的合法性进行必要的判断，以下几种情况认为参数不合法，不进行移动。 （1）当la表中不存在第i个元素，或者自第i个元素起后面不足 len个元素。 （2）当lb表中不存在第j个元素。（特别注意：当j值为0时，为合法参数，则在lb表第1个元素之前进行插入）

类型定义如下：

typedef int DataType;
typedef struct node 
{
    DataType data;
    struct node *next;
}LNode,*LinkList;

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>
typedef int DataType;
typedef struct node 
{
    DataType data;
    struct node *next;
}LNode,*LinkList;

LinkList CreatLinkList();  //创建无头结点单链表,并返回头指针。
void PrintLinkList(LinkList H);//依次输出无头结点单链表H中各个元素结点，若为空表则输出NONE。
void MoveLaToLb(LinkList *pa,int i,int len,LinkList *pb,int j);
main()
{
    LinkList la,lb;
    int i,j,len;
    la = CreatLinkList();
    lb = CreatLinkList();
    scanf("%d %d %d",&i,&j,&len);
    MoveLaToLb(&la,i,len,&lb,j);
    PrintLinkList(la);
    PrintLinkList(lb);
}

LinkList CreatLinkList()
{
    int n,i;
    LNode *nw,*rear=NULL,*head=NULL;
    scanf("%d",&n);//接收结点总数
    for(i=0;i<n;i++)
    {
        nw=(LNode*)malloc(sizeof(LNode));
        scanf("%d",&nw->data);
        if(rear==NULL)
            rear=head=nw;
        else
        {
            rear->next=nw;
            rear=nw;
        }
    }
    if(rear)
        rear->next=NULL;
    return head;
}

void PrintLinkList(LinkList H)
{
    LNode *p;
    if(!H)
    {    
        printf("NONE\n");
        return;
    }
    for(p=H;p;p=p->next)
        printf("%d ",p->data);
    printf("\n");
}


/* 请在这里填写答案 */

输入样例1：

7
1 2 3 4 5 6 7
6
11 22 33 44 55 66
3 4 2
结尾无空行

输出样例1：

1 2 5 6 7
11 22 33 44 3 4 55 66
结尾无空行

输入样例2：

7
1 2 3 4 5 6 7
6
11 22 33 44 55 66
1 0 4
结尾无空行

输出样例2：

5 6 7
1 2 3 4 11 22 33 44 55 66
结尾无空行

输入样例3：

7
1 2 3 4 5 6 7
6
11 22 33 44 55 66
6 2 4
结尾无空行

输出样例3：

1 2 3 4 5 6 7
11 22 33 44 55 66
结尾无空行

输入样例4：

3
1 2 3
4
11 22 33 44
1 4 3
结尾无空行

输出样例4：

NONE
11 22 33 44 1 2 3
结尾无空行

int Count(LinkList h)
{
 int n=0;
 LNode *p;
 p=h;
 while(p){
  n++;
  p=p->next;
 }
 return n;
}
void MoveLaToLb(LinkList *pa,int i,int len,LinkList *pb,int j)
{
 int n1,n2;
 int k=1;
 LinkList p1,p2,p3,p4,p5;
 n1=Count(*pa);
 n2=Count(*pb);
 if(n1<i || n1<i+len-1 || n2<j)  return ;
 else{
  p1=*pa;
  while(k<i-1){  //在第i-1结点停止 
   p1=p1->next;
   k++;
  }
  k=1;
  p2=*pb;
  while(k<j){ //在第j结点停止 
   p2=p2->next;
   k++;
  }
  k=1;
  p3=*pa;
  while(k<i+len-1){ //在第i+len-1结点停止 
   p3=p3->next;
   k++;
  } 
  if(n1==i+len-1){
   p4=p2->next;
   p2->next=p1;
   p3->next=p4;
   *pa=NULL;
  }
  else if(j){
      p4=p2->next;//该移动的头
      p5=p3->next; //pa该重连的头
      if(i==1){
       p2->next=p1;
       p3->next=p4;
       *pa=p5;
   }
      else{
       p2->next=p1->next; 
       p3->next=p4;
          p1->next=p5;
   }
      p3->next=p4;
      p1->next=p5;
  }
  else if(!j){
   p5=p3->next;
   p3->next=*pb;
   if(i==1){
    *pb=p1;
    *pa=p5;
   }
      else{
       *pb=p1->next;
       p1->next=p5;
   }
  } 
 }
}

8. 两个单链表元素交叉合并 (15 分)

设带头结点的线性单链表A={a1,a2,…,am}，B={b1,b2,…,bn} 。试编写算法按下列规则合并A、B为线性单链表C，使得

 C={a1,b1,a2,b2,...am,bm,...,bn} ，  m<=n
 或者
 C={b1,a1,b2,a2,...,bn,an,...,am} ,   m>n

函数接口定义：

LinkList CombineList(LinkList La,LinkList Lb);

其中 La 和 Lb 都是用户传入的参数，分别为待合并单链表的头指针。函数须返回合并后的单链表的头指针。
裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>
typedef int DataType;
typedef struct node 
{
    DataType data;
    struct node *next;
}LNode,*LinkList;

LinkList CreatLinkList();  //创建带头结点单链表,并返回头指针。
void PrintLinkList(LinkList H);//依次输出单链表H中各个元素结点，若为空表则输出NONE。
LinkList CombineList(LinkList La,LinkList Lb);
main()
{
    LinkList la,lb;
    la = CreatLinkList();
    lb = CreatLinkList();
    la=CombineList(la,lb);
    PrintLinkList(la);
}

LinkList CreatLinkList()
{
    int n,i;
    LNode *nw,*rear=NULL,*head=NULL;
    head=(LNode*)malloc(sizeof(LNode));
    rear=head;
    scanf("%d",&n);//接收结点总数
    for(i=0;i<n;i++)
    {
        nw=(LNode*)malloc(sizeof(LNode));
        scanf("%d",&nw->data);
        rear->next=nw;
        rear=nw;
    }
    rear->next=NULL;
    return head;
}

void PrintLinkList(LinkList H)
{
    LNode *p;
    if(!(H->next))
    {    
        printf("NONE\n");
        return;
    }
    for(p=H->next;p;p=p->next)
        printf("%d ",p->data);
    printf("\n");
}


/* 请在这里填写答案 */

输入样例：

在这里给出一组输入。例如：

4
1 2 3 4
6
11 22 33 44 55 66
结尾无空行

输出样例：

在这里给出相应的输出。例如：

1 11 2 22 3 33 4 44 55 66
结尾无空行

int Count(LinkList h)
{
 int n=0;
 LNode *p;
 p=h;
 while(p){
  n++;
  p=p->next;
 }
 return n;
}
LinkList CombineList(LinkList La,LinkList Lb)
{
 int n1,n2;
 LNode *h,*p,*q,*k1,*k2;
 n1=Count(La);
 n2=Count(Lb);
 if(n1<=n2){
  h=La;
  p=h->next;
  q=Lb->next;
 }
 else{
  h=Lb;
  p=h->next;
  q=La->next;
 }
 while(p&&q){
  k1=p->next;
  p->next=q;
  if(!k1) break;
  k2=q->next;
  q->next=k1;
  q=k2;
  p=k1; 
 }
 return h;
}
西邮彭于晏
关注
  • 8
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言数据结构单链表
m0_51579489的博客
04-09 1134
#include<stdio.h> #include<stdlib.h> typedef int elemtype; typedef struct LNode { elemtype data; struct LNode* next; }LNode,*Listlink; LNode* Creatlist1(Listlink& l, elemtype n) //头插法创建链表 { LNode* q; int x; l = (LNode*)m...
顺序表实验笔记
J2102303914的博客
11-11 1053
顺序表 声明顺序表类型 #define MaxSize 100 typedef int ElemType;//假设顺序表中的元素类型 typedef struct { ElemType data[MaxSize];//存放元素 int length;//长度 }SqList;//类型 一、顺序表的基本运算方法 1、初始化 void InitList(SqList &L) 2、销毁 void DestroyList(SqList L) 3、求长度 int GetLength(SqLi
P32 例2-3 编程实现和例2-1相同的任务，即建立一个线性表，首先依次输入数据元素1，2，3，...，10，然后删除数据元素5，最后依次显示当前表中的数据元素。要求使用单链表。
AKK188888881的博客
10-08 2503
P32 例2-3 编程实现和例2-1相同的任务，即建立一个线性表，首先依次输入数据元素1，2，3，…，10，然后删除数据元素5，最后依次显示当前表中的数据元素。要求使用单链表。 头文件：LinList.h #include<stdio.h> #include<stdlib.h> typedef int DataType; typedef struct Node { DataType data; struct Node *next; }SLNode; void ListIni
C语言基础编程——链表（一）
weixin_43958845的博客
05-25 1512
一、静态链表 #include<stdio.h> #include<stdlib.h> typedef struct node { int data;///数据域 struct node* next;///指针域 }; int main() { system("color 7D");//背景颜色 struct node node1={1,NULL}; struct node node2={2,NULL}; struct node n
线性表的逆置
nidie508的博客
09-23 4795
写的比较简单，语法上的细节没有做过多的处理，一般数据是可以处理的，之后会多考虑细节的。 问题： 设有一线性表e=(e1 , e2 , … , en-1 , en)，其逆线性表定义为e’=( en , en-1 , … , e2 , e1)，请设计一个算法，将线性表逆置，要求逆线性表仍占用原线性表的空间，并且用顺序表和单链表两种方法来表示，写出不同的处理函数。 顺序表 #include "stdio...
数据结构上机第二次答案
10-01
在本场景中，我们关注的是大连理工大学数据结构课程的第二次上机实验，重点涉及顺序栈和顺序队列的实现。这些是两种基本的数据结构，对于理解和掌握更复杂的算法至关重要。 顺序栈是一种线性数据结构，其中元素按照...
数据结构上机试题.docx
12-13
数据结构上机试题 本文档提供了数据结构上机试题的解决方案，涵盖顺序表的操作、顺序栈上实现将非负十进制数转换成二进制数以及在顺序表中采用顺序查找算法和折半查找算法寻找关键字X在顺序表中的位置。 一、顺序...
第二次上机实验_数据结构算法_
09-30
在“第二次上机实验_数据结构算法_”这个主题中，我们可以深入探讨数据结构与算法在C语言中的应用。数据结构是计算机科学的基础，它研究如何有效地存储和组织数据，以便进行高效的检索、操作和分析。C语言是一种强大...
2016年数据结构第一次上机1
08-08
在样例输入`10 77 19999999 47 -5 64 -65536 89 9 -214 4344 2 1 3`和查询`2 1 3`的情况下，输出应为`64 89 19999999`，分别对应数列中第2大、第1大和第3大的数。 二、查询 查询任务是判断给定的k个整数bi是否出现...
西电数据结构第六次上机简单排序代码
11-12
题目一 简单排序方法 ...（3）用直接插入排序法对数组A排序； 将上述排序算法分别用函数实现，观察每种排序过程中元素的比较次数、交换（或移动）次数，以及排序过程所消耗的时间（以s或ms为单位）。
实验3-带头结点的单链表
weixin_30502157的博客
11-03 2805
实验1： 1 /*编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。 2 并构造测试用例进行测试。 3 */ 4 /**********************************/ 5 /*文件名称：lab3_01.c */ 6 /**********...
C语言（十三）
waittttttttttt的博客
03-13 1241
二叉树: #include <stdio.h> #include <stdlib.h> typedef struct BTNode { int data; struct BTNode *lchild; struct BTNode *rchild; }BTNode,*BTree; BTree CreatBTree();//前序遍历生成二叉树 void PrtOrderTraverse(BTree T);//前序遍历二叉树 void InOrderTraver
数据结构实验一 线性表（顺序表单链表逆置及单链表分解）
沧浪之水
02-05 4468
一、 实验目的 1． 熟悉线性表的顺序和链式存储结构 2． 掌握线性表的基本运算 3． 能够利用线性表的基本运算完成线性表应用的运算 二、 实验内容 1． 设有一个线性表E={e1, e2, … , en-1, en}，设计一个算法，将线性表逆置，即使元素排列次序颠倒过来，成为逆线性表E’={ en , en-1 , … , e2 , e1 }，要求逆线性表占用原线性表空间，
数据结构（C语言版实验代码实现）--第二章 线性表
qq_50574166的博客
10-13 949
2.1 顺序表（静态分配内存） #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<math.h> #include<time.h> //顺序表的存储结构定义 #define MaxSize 100 typedef int DataType; typedef struct { DataType data[MaxSize];//存放数据元素的数组
《程序设计基础》 第五章 函数 例题5-6 数字金字塔 (15 分)
OchiaMalu的博客
11-08 1828
本题要求实现函数输出n行数字金字塔。 函数接口定义： void pyramid( int n ); 其中n是用户传入的参数，为[1, 9]的正整数。要求函数按照如样例所示的格式打印出n行数字金字塔。注 意每个数字后面跟一个空格。 裁判测试程序样例： #include <stdio.h> void pyramid( int n ); int main() { int n; scanf("%d", &n); pyramid(n);
练习5-3 数字金字塔（15 分）
热门推荐
pinguo的博客
07-17 1万+
本题要求实现函数输出n行数字金字塔。 函数接口定义： void pyramid( int n ); 其中n是用户传入的参数，为[1, 9]的正整数。要求函数按照如样例所示的格式打印出n行数字金字塔。注 意每个数字后面跟一个空格。 裁判测试程序样例： #include &lt;stdio.h&gt; void pyramid( int n ); int main() { ...
2021计算导论第十一次练习题目
qq_60437248的博客
12-19 1257
二维数组相关练习 作者 scs 单位 北京邮电大学
6-1 用函数实现插入数到数列指定位置
i_kun_的博客
11-13 1287
PTA6-1 用函数实现插入数到数列指定位置
buaa数据结构第四次上机
最新发布
04-24
很抱歉，我无法提供关于具体学校或课程的第四次上机内容。但是，我可以为您提供一些关于数据结构的基本知识和常见的上机题目类型。 数据结构是计算机科学中非常重要的一门课程，它研究如何组织和存储数据以及如何有效地操作和管理数据。第四次上机可能涉及以下内容之一： 1. 树和图的应用：树和图是常见的数据结构，可以用于解决各种实际问题，比如搜索、排序、最短路径等。在上机中，您可能需要实现树或图的基本操作，如插入、删除、遍历等。 2. 排序算法：排序是数据结构中的一个重要问题，常见的排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序等。您可能需要实现其中一个排序算法，并对给定的数据进行排序。 3. 查找算法：查找是另一个常见的问题，常见的查找算法有线性查找、二分查找、哈希查找等。您可能需要实现其中一个查找算法，并根据给定的条件查找特定的数据。 4. 动态规划：动态规划是一种解决最优化问题的方法，它将问题分解为子问题，并通过保存子问题的解来避免重复计算。您可能需要使用动态规划来解决给定的问题，并实现相应的算法。 以上只是一些可能的内容，具体的上机要求可能会根据课程教学大纲和教师的要求而有所不同。如果您有具体的问题或需要更详细的帮助，请提供更多信息，我将尽力回答您的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值