吉林大学 超星慕课 高级语言程序设计 实验09 动态数据组织（2022级）

最新推荐文章于 2023-11-24 19:59:44 发布
最新推荐文章于 2023-11-24 19:59:44 发布
阅读量3.2k 收藏 34
点赞数 13
文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72113406/article/details/127889895
版权

本人能力有限，发出只为帮助有需要的人。

建议同学们自己写完后再进行讨论。

1. (程序题)

题目编号：Exp09-Basic01

题目名称：创建单链表

题目描述：请填写缺失代码完成程序，实现如下功能：

根据从键盘随机输入以0结束的若干非零整数，建立一个单链表；之后将此链表中保存的数字顺次输出，相邻数字间以一个西文空格间隔，最后一个数字后无任何字符；若是空链表，则输出NULL。

例如， 

输入:5 4 2 1 3 0 

输出:5 4 2 1 3

输入:0 5 4 2 1 3 0 

输出:NULL

***注意***：

提交答案时，需粘贴完整的源代码，仅粘贴填空处的代码将被判错。

#include <stdio.h>
#include <malloc.h>
struct cell { //单链表结点结构体定义
 int x;
 struct cell* next;
};
struct cell* build(void) { //新建单链表，并将建好的单链表首结点地址返回
 struct cell* head,*tmp,*p;
 head = tmp = p = NULL;
 int n;
 /*请在以下位置补充完整，实现函数build的功能
       ......
       ......
       ......
   */
 return head;//返回单链表头
}
void print(struct cell* head) {//打印整个单链表,head是指向单链表首结点的指针
 /*请在以下位置补充完整，实现函数print的功能
       ......
       ......
       ......
   */
}
void release(struct cell* head) {//释放单链表空间,head是指向单链表首结点的指针
 /*请在以下位置补充完整，实现函数release的功能
       ......
       ......
       ......
   */
}
int main(void) {
 struct cell* head;
 head = build();
 if(head!=NULL)
        print(head);
    else
        printf("NULL");
 release(head);
}
#include <stdio.h>
#include <malloc.h>
struct cell { //单链表结点结构体定义
    int x;
    struct cell* next;
};
struct cell* build(void) { //新建单链表，并将建好的单链表首结点地址返回
    struct cell* head, * tmp, * p;
    head = tmp = p = NULL;
    int n;
    scanf("%d",&n);
    head=(struct cell*)malloc(sizeof(struct cell));
    if(n==0)//当第一个数就是0时的情况
        return NULL;
    head->x=n;
    head->next=NULL;//确保当只有两个数输入时，输出不会进入死循环
    p=head;
    while(1)
    {
        scanf("%d",&n);
        if(n==0)//循环的出口
            return head;
        else
        {
            tmp=(struct cell*)malloc(sizeof(struct cell));//每次都向系统多要一块内存
            tmp->x=n;
            tmp->next=NULL;//使得输出不会陷入死循环
            p->next=tmp;//将head与tmp连接(p在其中进行传导)
            p=tmp;
        }
    }
    return head;//返回单链表头
}
void print(struct cell* head) {//打印整个单链表,head是指向单链表首结点的指针
    struct cell *p;
    int flag=0;
    p=head;
    while(p!=NULL)
    {
        if(flag)//控制空格数量
            printf(" ");
        flag=1;
        printf("%d",p->x);
        p=p->next;
    }
}
void release(struct cell* head) {//释放单链表空间,head是指向单链表首结点的指针
    struct cell *p,*tmp;
    p=head;
    while(p!=NULL)
    {
        tmp=p;
        p=p->next;//先将p指向下一个结构体，再清空tmp
        free(tmp);
    }
}
int main(void) {
    struct cell* head;
    head = build();//返回值类型为结构体指针
    if (head != NULL)
        print(head);
    else
        printf("NULL");
    release(head);
    return 0;
}

2. (程序题)

题目编号：Exp09-Basic02，GJBook3-13-06

题目名称：删除单链表重复结点

题目描述：请填写缺失代码完成程序，实现如下功能：

首先根据键盘随机输入，以0结束的若干非零整数建立单链表；然后删除此链表中值重复的结点仅保留一个，且不改变原有结点顺序；最后将删除后链表中各结点值输出，相邻数字间以一个西文空格间隔，最后一个数字后无任何字符；若是空链表，则输出NULL。

例如，

输入:5 4 2 1 3 0 输出：5 4 2 1 3

输入: 4 2 1 3 3 2 0 输出：4 2 1 3

输入: 0 4 2 3 2 0 输出：NULL

***注意***：

提交答案时，需粘贴完整的源代码，仅粘贴填空处的代码将被判错。

#include <stdio.h>
#include <malloc.h>
struct cell {//单链表结点结构体定义
int x;
struct cell* next;
};
struct cell* build(void) {//新建单链表，并将建好的单链表首结点地址返回
struct cell* head, * tmp, * p;
head = tmp = p = NULL;
int n;
/*请在以下位置补充完整，实现函数build的功能
      ......
      ......
      ......
  */
return head;//返回单链表头
}
struct cell* del2one(struct cell* head) {//删除重复结点只保留一个，head是单链表首结点指针
/*请在以下位置补充完整，实现函数del2one的功能
      ......
      ......
      ......
  */
return head;//返回删除重复结点的单链表头
}
void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
/*请在以下位置补充完整，实现函数print的功能
      ......
      ......
      ......
  */
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
/*请在以下位置补充完整，实现函数release的功能
      ......
      ......
      ......
  */
}
int main(void) {
struct cell* head;
head = build();
head=del2one(head);
if(head!=NULL)
       print(head);
   else
       printf("NULL");
release(head);
}
#include <stdio.h>
#include <malloc.h>
struct cell //单链表结点结构体定义
{
    int x;
    struct cell* next;
};
struct cell* build(void)//新建单链表，并将建好的单链表首结点地址返回
{
    struct cell* head, * tmp, * p;
    head = tmp = p = NULL;
    int n;
    head=(struct cell*)malloc(sizeof(struct cell));
    scanf("%d",&n);
    if(n==0)
        return NULL;
    else
    {
        head->x=n;
        head->next=NULL;
        p=head;
        while(1)
        {
            scanf("%d",&n);
            if(n==0)
                return head;
            tmp=(struct cell*)malloc(sizeof(struct cell));
            tmp->x=n;
            tmp->next=NULL;
            p->next=tmp;
            p=p->next;
        }
    }
    return head;//返回单链表头
}
struct cell* del2one(struct cell* head)//删除重复结点只保留一个，head是单链表首结点指针
{
    struct cell *p,*tmp;
    p=tmp=head;
    if(p==NULL)//当链表为空时直接返回NULL
        return NULL;
    while(p!=NULL)//两层循环找到所有重复
    {
        tmp=p;
        while(tmp->next!=NULL)//用tmp->next遍历
        {
            if(tmp->next->x==p->x)
                tmp->next=tmp->next->next;
            else//此处如果链表进行了删除，就不要再让tmp往后移动了
                tmp=tmp->next;
        }
        p=p->next;
    }
    return head;//返回删除重复结点的单链表头
}
void print(struct cell* head) //打印整个单链表,head是单链表首结点指针
{
    struct cell *p;
    p=head;
    int flag=0;
    while(p!=NULL)
    {
        if(flag)
            printf(" ");
        flag=1;
        printf("%d",p->x);
        p=p->next;
    }
}
void release(struct cell* head)//释放单链表空间,head是单链表首结点指针
{
    struct cell *p,*tmp;
    p=head;
    while(p!=NULL)
    {
        tmp=p;
        p=p->next;
        free(tmp);
    }
}
int main(void)
{
    struct cell* head;
    head = build();
    head=del2one(head);
    if(head!=NULL)
        print(head);
    else
        printf("NULL");
    release(head);
    return 0;
}

3. (程序题)

题目编号 ：Exp09-Basic03

题目名称：求单链表中间结点

题目描述：请填写缺失代码完成程序，实现如下功能：

首先根据键盘随机输入，以0结束的若干非零整数建立单链表；

然后寻找处于链表中间位置的结点，若中间结点有两个，则设定前一个为中间位置结点；

最后将从中间结点开始到链表尾各结点值输出，相邻数字间以一个西文空格间隔，最后一个数字后无任何字符。

若是空链表，则输出NULL。

例如，

输入:5 4 2 1 3 0 

输出：2 1 3

输入: 4 2 1 3 3 2 0 

输出：1 3 3 2

***注意***：

提交答案时，需粘贴完整的源代码，仅粘贴填空处的代码将被判错。


#include <stdio.h>

#include <malloc.h>
struct cell {//单链表结点结构体定义
 int x;
 struct cell* next;
};
struct cell* build(void) {//新建单链表，并将建好的单链表首结点地址返回
 struct cell* head, * tmp, * p;
 head = tmp = p = NULL;
 int n;
 /*请在以下位置补充完整，实现函数build的功能
       ......
       ......
       ......
   */
 return head;//返回单链表头
}
struct cell* mid(struct cell* head) {//寻找链表中间位置结点地址并返回，head是单链表首结点指针
 /*请在以下位置补充完整，实现函数mid的功能
       ......
       ......
       ......
   */
}
void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
 /*请在以下位置补充完整，实现函数print的功能
       ......
       ......
       ......
   */
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
 /*请在以下位置补充完整，实现函数release的功能
       ......
       ......
       ......
   */
}
int main(void) {
 struct cell* head,*half;
 head = build();
 half = mid(head);
 if(half!=NULL)
        print(half);
    else
        printf("NULL");
 release(head);
}
#include <stdio.h>

#include <malloc.h>
struct cell {//单链表结点结构体定义
 int x;
 struct cell* next;
};
struct cell* build(void) {//新建单链表，并将建好的单链表首结点地址返回
    struct cell* head, * tmp, * p;
    head = tmp = p = NULL;
    int n;
    scanf("%d",&n);
    if(n==0)
        return NULL;
    head=(struct cell*)malloc(sizeof(struct cell));
    head->x=n;
    head->next=NULL;
    p=head;
    while(1)
    {
        scanf("%d",&n);
        if(n==0)
            return head;
        tmp=(struct cell*)malloc(sizeof(struct cell));
        tmp->x=n;
        tmp->next=NULL;
        p->next=tmp;
        p=p->next;
    }
    return head;//返回单链表头
}
struct cell* mid(struct cell* head) {//寻找链表中间位置结点地址并返回，head是单链表首结点指针
    struct cell *p,*tmp;
    int flag=0;
    p=head;
    tmp=head;
    while(p!=NULL)//得到链表中的元素个数
    {
        flag++;
        p=p->next;
    }
    for(int i=0;i<((flag-1)/2);i++)//将链表的头移动到中间节点
        tmp=tmp->next;
    return tmp;
}
void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
    struct cell*p;
    int flag=0;
    p=head;
    while(p!=NULL)
    {
        if(flag)
            printf(" ");
        flag=1;
        printf("%d",p->x);
        p=p->next;
    }
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
    struct cell *p,*tmp;
    p=head;
    while(p!=NULL)
    {
        tmp=p;
        p=p->next;
        free(tmp);
    }
}
int main(void) {
    struct cell* head,*half;
    head = build();
    half = mid(head);
    if(half!=NULL)
        print(half);
    else
        printf("NULL");
    release(head);
    return 0;
}

4. (程序题)

题目编号：Exp09-Basic04

题目名称：单链表交换两结点

题目描述：请填写缺失代码完成程序，实现如下功能：

首先根据键盘随机输入，以0结束的若干非零整数建立单链表；

然后根据输入的两个索引位置交换链表上的两个结点（链表首元素索引为1,且要交换的两个索引位置不相邻）；

最后链表各结点值输出，相邻数字间以一个西文空格间隔，最后一个数字后无任何字符。

若是空链表，则输出NULL。

例如，

输入:1 2 3 4 5 6 0 1 5

输出：5 2 3 4 1 6

输入:0 1 2 3 4 5 6 0 1 5

输出：NULL

***注意***：

提交答案时，需粘贴完整的源代码，仅粘贴填空处的代码将被判错。

#include <stdio.h>
#include <malloc.h>
struct cell {//单链表结点结构体定义
 int x;
 struct cell* next;
};
struct cell* build(void) {//新建单链表，并将建好的单链表首结点地址返回
 struct cell* head, * tmp, * p;
 head = tmp = p = NULL;
 int n;
 /*请在以下位置补充完整，实现函数build的功能
       ......
       ......
       ......
   */
 return head;//返回单链表头
}
struct cell* swap(struct cell* head,int m,int n) {//交换索引为m和n的两个结点，head是单链表首结点指针
 if(head==NULL) return NULL;
    struct cell* pm=head, * pn=head;
 struct cell* pm0 = NULL, * pn0 = NULL;
 struct cell* tmp;
 int i;
 for (i = 1;i < m && pm != NULL;i++) { 
  pm0 = pm;
  pm = pm->next;
 }
 for (i = 1;i < n && pn != NULL;i++) {
  pn0 = pn;
  pn = pn->next;
 }
 if (pm != NULL && pn != NULL && m != n) {//索引为m,n的结点位于链表中间
        /*请在以下位置补充完整，实现函数swap的功能
       ......
       ......
       ......
    */  
  if (pm0 != NULL && pn0 != NULL) {
   /*请在以下位置补充完整，实现函数swap的功能
       ......
       ......
       ......
     */ 
  }
  if (pm0 == NULL && pn0 != NULL) {
   /*请在以下位置补充完整，实现函数swap的功能
       ......
       ......
       ......
     */
  }
  if (pm0 != NULL && pn0 == NULL) {
   /*请在以下位置补充完整，实现函数swap的功能
       ......
       ......
       ......
     */
  }
 }
 return head;
}
void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
 /*请在以下位置补充完整，实现函数print的功能
       ......
       ......
       ......
   */
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
 /*请在以下位置补充完整，实现函数release的功能
       ......
       ......
       ......
   */
}
int main(void) {
 struct cell* head;
 int m, n;
 head = build();
 scanf("%d%d", &m, &n);
 head = swap(head,m,n);
 if(head!=NULL)
        print(head);
    else
        printf("NULL");
 release(head);
}
#include <stdio.h>
#include <malloc.h>
struct cell {//单链表结点结构体定义
 int x;
 struct cell* next;
};
struct cell* build(void) {//新建单链表，并将建好的单链表首结点地址返回
    struct cell* head, * tmp, * p;
    head = tmp = p = NULL;
    int n;
    scanf("%d",&n);
    if(n==0)
        return NULL;
    head=(struct cell*)malloc(sizeof(struct cell));
    head->x=n;
    head->next=NULL;
    p=head;
    while(1)
    {
        scanf("%d",&n);
        if(n==0)
            return head;
        tmp=(struct cell*)malloc(sizeof(struct cell));
        tmp->x=n;
        tmp->next=NULL;
        p->next=tmp;
        p=p->next;
    }
    return head;//返回单链表头
}
struct cell* swap(struct cell* head,int m,int n) {//交换索引为m和n的两个结点，head是单链表首结点指针
    if(head==NULL)
        return NULL;
    struct cell* pm=head, * pn=head;
    struct cell* pm0 = NULL, * pn0 = NULL;
    struct cell* tmp;
    int i;
    for (i = 1;i < m && pm != NULL;i++) {
        pm0 = pm;
        pm = pm->next;
    }
    for (i = 1;i < n && pn != NULL;i++) {
        pn0 = pn;
        pn = pn->next;
    }
    if (pm != NULL && pn != NULL && m != n) {
        if (pm0 != NULL && pn0 != NULL) {//pm,pn都不是第一个元素，则进行交换
            tmp=pm->next;
            pm0->next=pn;
            pm->next=pn->next;
            pn->next=tmp;
            pn0->next=pm;
        }
        if (pm0 == NULL && pn0 != NULL) {
            head=pn;//将链表的头变为pn
            tmp=pn->next;
            pn->next=pm->next;
            pn0->next=pm;
            pm->next=tmp;
        }
        if (pm0 != NULL && pn0 == NULL) {
            head=pm;//将链表的头变为pm
            tmp=pm->next;
            pm->next=pn->next;
            pm0->next=pn;
            pn->next=tmp;
        }
 }
 return head;
}
void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
    struct cell* p;
    p=head;
    int flag=0;
    while(p!=NULL)
    {
        if(flag)
            printf(" ");
        flag=1;
        printf("%d",p->x);
        p=p->next;
    }
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
    struct cell*p,*tmp;
    p=head;
    while(p!=NULL)
    {
        tmp=p;
        p=p->next;
        free(tmp);
    }
}
int main(void) {
 struct cell* head;
 int m, n;
 head = build();
 scanf("%d%d", &m, &n);
 head = swap(head,m,n);
 if(head!=NULL)
        print(head);
    else
        printf("NULL");
 release(head);
}

5. (程序题)

题目编号 ：Exp09-Basic05，GJBook3例-13-04

题目名称：单链表存储法雷序列

题目描述：请填写缺失代码完成程序，实现如下功能：

给定一个正整数n，用单链表递增存储n阶法雷序列各项值。n阶法雷序列是把所有不可约分的分数j/i(0<i≤n; 0≤j≤i)递增排序的序列。

输入一个正整数n；输出n阶法雷序列各项分数形式，分数的分子和分母间以/连接，各个分数间以一个西文空格间隔，最后一个数字后无任何字符。若是空链表或n不符合要求，则输出NULL。

例如，

输入:3 

输出：0/1 1/3 1/2 2/3 1/1

***注意***：

提交答案时，需粘贴完整的源代码，仅粘贴填空处的代码将被判错。


 

#include <stdio.h>
#include <malloc.h>
struct  farlei_item {
 int   numerator, denominator;   // 分子、分母
 struct  farlei_item* next;   // 连接部分
};
typedef  struct  farlei_item* farleipointer;
int  gcd(int x, int y) {    /*  求最大公约数 */
 /*请在以下位置补充完整，实现函数gcd的功能
       ......
       ......
       ......
   */
}
/*构造法雷序列,并返回序列头指针*/
farleipointer farlei(int n) {
 int i, j;
 farleipointer fn, r, r0, p;
 fn = r = r0 = p = NULL;
 if (n < 1)return NULL; //如果n<=0,则没有法雷序列
 fn = (farleipointer)malloc(sizeof(struct farlei_item));  //构造0/1
 fn->numerator = 0;
 fn->denominator = 1;
 p = (farleipointer)malloc(sizeof(struct farlei_item));   //构造1/1
 p->numerator = 1;
 p->denominator = 1;
 fn->next = p;
 p->next = NULL;
 /*请在以下位置补充完整，实现函数farlei的功能
       ......
       ......
       ......
   */
 return fn;
}
void print(farleipointer fn) {//输出fn引导的法雷序列
 /*请在以下位置补充完整，实现函数print的功能
       ......
       ......
       ......
   */
}
void release(farleipointer head) {//释放单链表空间,head是单链表首结点指针
 /*请在以下位置补充完整，实现函数release的功能
       ......
       ......
       ......
   */
}
int main(void) {
 int n;
 farleipointer fn;
 scanf("%d", &n);
 fn = farlei(n); //生成n级法雷序列
 if(fn!=NULL)
        print(fn);
    else
        printf("NULL");
 release(fn);
 return 0;
}
#include <stdio.h>
#include <malloc.h>
struct  farlei_item {
 int   numerator, denominator;   // 分子、分母
 struct  farlei_item* next;   // 连接部分
};
typedef  struct  farlei_item* farleipointer;
int  gcd(int x, int y) {    /*  求最大公约数 */
    if(y==0)
        return x;
    int r;
    r=x%y;
        return gcd(y,r);
}
/*构造法雷序列,并返回序列头指针*/
farleipointer farlei(int n) {
 int i, j;
 farleipointer fn, r, r0, p;
 fn = r = r0 = p = NULL;
 if (n < 1)return NULL; //如果n<=0,则没有法雷序列
 fn = (farleipointer)malloc(sizeof(struct farlei_item));  //构造0/1
 fn->numerator = 0;
 fn->denominator = 1;
 p = (farleipointer)malloc(sizeof(struct farlei_item));   //构造1/1
 p->numerator = 1;
 p->denominator = 1;
 fn->next = p;
 p->next = NULL;
 for(i=2;i<=n;i++)
     for(j=1; j<i; j++)
         if(gcd(i,j)==1) {//找到新分数的位置
             r=fn;
             while((1.0*j)/i>(1.0*r->numerator)/r->denominator){
                    r0=r;
                    r=r->next ;
              }
          p=(farleipointer)malloc(sizeof(struct farlei_item));//插入新的分数
          p->numerator=j;
          p->denominator=i;
          r0->next=p;
          p->next=r;
        }

 return fn;
}
void print(farleipointer fn) {//输出fn引导的法雷序列
    struct farlei_item *p;
    p=fn;
    int flag=0;
    while(p!=NULL)
    {
        if(flag)
            printf(" ");
        flag=1;
        printf("%d/%d",p->numerator,p->denominator);
        p=p->next;
    }
}
void release(farleipointer head) {//释放单链表空间,head是单链表首结点指针
    struct farlei_item *p,*tmp;
    p=head;
    while(p!=NULL)
    {
        tmp=p;
        p=p->next;
        free(tmp);
    }
}
int main(void) {
 int n;
 farleipointer fn;
 scanf("%d", &n);
 fn = farlei(n); //生成n级法雷序列
 if(fn!=NULL)
        print(fn);
    else
        printf("NULL");
 release(fn);
 return 0;
}

6. (程序题)

题目编号：Exp09-Enhance03

题目名称：合并单链表

题目描述：请填写缺失代码完成程序，实现如下功能：

    首先从键盘输入一行以0结束的若干非零整数，建立一个单链表，输入的整数顺序为数字非递减顺序；

    然后以同样的方式，仍在第一行继续输入并建立第二个单链表；

    之后将两个链表合并形成一个新链表，使得新链表依然保持数字非递减顺序；

    最后验证输出新链表所有值，相邻数字间以一个西文空格间隔，最后一个数字后无任何字符。若是空链表，则输出NULL。

例如，

    输入：2 3 4 4 5 6 0 1 3 4 6 7 0

    输出：1 2 3 3 4 4 4 5 6 6 7

    输入：0 0

    输出：NULL

***注意***：

    提交答案时，需粘贴完整的源代码，仅粘贴填空处的代码将被判错。


  #include <stdio.h>

#include <malloc.h>
struct cell {//单链表结点结构体定义
 int x;
 struct cell* next;
};
struct cell* build(void) {//新建单链表，并将建好的单链表首结点地址返回
 struct cell* head, * tmp, * tail;
 head = tmp = tail = NULL;
 int n, i;
 /*请在以下位置补充完整，实现函数build的功能
       ......
       ......
       ......
   */
 return head;//返回单链表头
}
struct cell* combine(struct cell* p, struct cell* q) {//合并两个链表p和q
 struct cell* head= NULL,*p0=NULL,*q0=NULL,*r=NULL;
 if (p == NULL && q!= NULL) return q;
 if (p != NULL && q == NULL) return p;
 if (p == NULL && q == NULL) return NULL;
 /*请在以下位置补充完整，实现函数combine的功能
       ......
       ......
       ......
   */
}
void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
 /*请在以下位置补充完整，实现函数print的功能
       ......
       ......
       ......
   */
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
 /*请在以下位置补充完整，实现函数release的功能
       ......
       ......
       ......
   */
}
int main(void) {
 struct cell* head1,*head2, *result;
 head1 = build();
 head2 = build();
 result = combine(head1,head2);
 if (result != NULL)
  print(result);
 else
  printf("NULL");
 release(result);
 return 0;
}
#include <stdio.h>
#include <malloc.h>
struct cell {//单链表结点结构体定义
 int x;
 struct cell* next;
};
struct cell* build(void) {//新建单链表，并将建好的单链表首结点地址返回
    struct cell* head, * tmp, * tail;
    head = tmp = tail = NULL;
    int n, i;
    scanf("%d",&n);
    if(n==0)
        return NULL;
    head=(struct cell*)malloc(sizeof(struct cell));
    head->x=n;
    head->next=NULL;
    tail=head;
    while(1)
    {
        scanf("%d",&n);
        if(n==0)
            return head;
        tmp=(struct cell*)malloc(sizeof(struct cell));
        tmp->x=n;
        tmp->next=NULL;
        tail->next=tmp;
        tail=tail->next;
    }
 return head;//返回单链表头
}
struct cell* combine(struct cell* p, struct cell* q) {//合并两个链表p和q
    struct cell* head= NULL,*p0=NULL,*q0=NULL,*r=NULL;
    if (p == NULL && q!= NULL) return q;
    if (p != NULL && q == NULL) return p;
    if (p == NULL && q == NULL) return NULL;
    struct cell* r0;
    if (p!=NULL&&q!=NULL)
    {
        head=p;
        while(p!=NULL)//将两链表连接
        {
            p0=p;
            p=p->next;
        }
        p0->next=q;
        p=head;
        p0=NULL;
        while(p!=NULL)//将链表进行插入排序
        {
            r=head;
            while((r->x<p->x)&&(r!=p))
            {
                r0=r;
                r=r->next;
            }
            if(r!=p)
            {
                q=p;
                p0->next=p->next;
                p=p0;
                if(r==head)
                {
                    q->next=head;
                    head=q;
                }
                else
                {
                    q->next=r;
                    r0->next=q;
                }
            }
            p0=p;
            p=p->next;
        }
    }
    return head;
}
void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
    struct cell*p;
    int flag=0;
    p=head;
    while(p!=NULL)
    {
        if(flag)
            printf(" ");
        flag=1;
        printf("%d",p->x);
        p=p->next;

    }
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
    struct cell*p=head,*tmp;
    while(p!=NULL)
    {
        tmp=p;
        p=p->next;
        free(tmp);
    }
}
int main(void) {
 struct cell* head1,*head2, *result;
 head1 = build();
 head2 = build();
 result = combine(head1,head2);
 if (result != NULL)
  print(result);
 else
  printf("NULL");
 release(result);
 return 0;
}

7. (程序题)

题目编号：Exp09-Enhance04，GJBook3例-13-02

题目名称：排序单链表

题目描述：请填写缺失代码完成程序，实现如下功能：

    首先根据键盘随机输入一行以0结束的若干非零整数建立单链表；

    然后递增排序链表；

    最后验证输出排序后链表中所有值，相邻数字间以一个西文空格间隔，最后一个数字后无任何字符。

    若是空链表，则输出NULL。

例如，

    输入:2 3 6 4 5 0 

    输出：2 3 4 5 6

    输入:0 2 3 4 

    输出：NULL

***注意***：

    提交答案时，需粘贴完整的源代码，仅粘贴填空处的代码将被判错。

#include <stdio.h>
#include <malloc.h>
struct cell {//单链表结点结构体定义
 int x;
 struct cell* next;
};
struct cell* build(void) {//新建单链表，并将建好的单链表首结点地址返回
 struct cell* head, * tmp, * tail;
 head = tmp = tail = NULL;
 int n;
 /*请在以下位置补充完整，实现函数build的功能
       ......
       ......
       ......
   */
 return head;//返回单链表头
}
struct cell * sort(struct cell* head) {//递增排序链表，head是单链表首结点指针
 struct cell* p, * p0, * r, * r0, * q;
 p = p0 = r = r0 = q = NULL;
 p = head;
 /*请在以下位置补充完整，实现函数sort的功能
       ......
       ......
       ......
   */
 return head;
}   /*  sort */


void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
 /*请在以下位置补充完整，实现函数print的功能
       ......
       ......
       ......
   */
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
 /*请在以下位置补充完整，实现函数release的功能
       ......
       ......
       ......
   */
}
int main(void) {
 struct cell* head;
 head= build();
 if (head != NULL) {
  head = sort(head);
  print(head);
 }else
  printf("NULL");
 release(head);
 return 0;
}
#include <stdio.h>
#include <stdlib.h>


#include <stdio.h>
#include <malloc.h>
struct cell {//单链表结点结构体定义
 int x;
 struct cell* next;
};
struct cell* build(void) {//新建单链表，并将建好的单链表首结点地址返回
 struct cell* head, * tmp, * tail;
 head = tmp = tail = NULL;
 int n;
 scanf("%d",&n);
 if(n==0)
    return NULL;
 head=(struct cell*)malloc(sizeof(struct cell));
 head->x=n;
 head->next=NULL;
 tail=head;
 while(1)
 {
     scanf("%d",&n);
     if(n==0)
        return head;
     tmp=(struct cell*)malloc(sizeof(struct cell));
     tmp->x=n;
     tmp->next=NULL;
     tail->next=tmp;
     tail=tail->next;
 }
 return head;//返回单链表头
}
struct cell * sort(struct cell* head) {//递增排序链表，head是单链表首结点指针
 struct cell* p, * p0, * r, * r0, * q;
 p = p0 = r = r0 = q = NULL;
 p = head;
 while(p!=NULL)
 {
     r=head;
     while((r->x<p->x)&&(r!=p))
     {
         r0=r;
         r=r->next;
     }
     if(r!=p)
     {
         q=p;
         p0->next=p->next;
         p=p0;
         if(r==head)
         {
             q->next=head;
             head=q;
         }
         else
         {
             q->next=r;
             r0->next=q;
         }
     }
     p0=p;
     p=p->next;
 }
 return head;
}   /*  sort */


void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
    struct cell *p=head;
    int flag=0;
    while(p!=NULL)
    {
        if(flag)
            printf(" ");
        flag=1;
        printf("%d",p->x);
        p=p->next;
    }
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
    struct cell *p=head,*tmp;
    while(p!=NULL)
    {
        tmp=p;
        p=p->next;
        free(tmp);
    }
}
int main(void) {
 struct cell* head;
 head= build();
 if (head != NULL) {
  head = sort(head);
  print(head);
 }else
  printf("NULL");
 release(head);
 return 0;
}

陈驰水
关注
  • 13
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
基于MOOC SPOC模式的“高级语言程序设计”课程线上线下混合模式教学实践探究.pdf
12-02
在"高级语言程序设计"的混合模式教学实践中，超星网络平台被选作线上教学工具，学生可通过各种数据终端访问。教学过程分为课前、课中和课后三个阶段： 1. **课前**：教师设定线上学习标准，分解课程内容，制作不...
吉林大学超星高级语言程序设计 实验09 动态数据组织
Felon233的博客
12-27 6081
填空题，不怎么难，比较懒直接给程序，自己对着填，给与参考，欢迎大家一起交流 ：-） 1 题目编号：Exp09-Basic01 题目名称：创建单链表 题目描述：请填写缺失代码完成程序，实现如下功能： 根据从键盘随机输入以0结束的若干非零整数，建立一个单链表；之后将此链表中保存的数字顺次输出，相邻数字间以一个西文空格间隔，最后一个数字后无任何字符；若是空链表，则输出NULL。 例如， 输入:5 4 2 1 3 0 输出:5 4 2 1 3 输入:0 5 4 2 1 3 0 输出:NULL #include&l
吉林大学超星MOOC学习通高级语言程序设计 C++ 实验02 分支与循环程序设计（2021级）（4）
S_CuRrY666的博客
11-20 1908
13.倍数 题目编号：Exp02-Basic07，GJBook3-03-07 题目名称：倍数 题目描述：任意一个整数n，如果n能同时被3、5、7整除，则n是3、5、7的倍数，如果n只能同时被其中的两个数整除，则n是两个数的倍数，如果n只能被其中一个数整除，则n是一个数的倍数，否则n不是3、5、7的倍数。 输入：输入一个整数。 输出：按照是否是倍数输出。 样例1： 输入：105 输出：3,5,7 样例2： 输入：30 输出：3,5 样例3： 输入：21 输出：3..
实验09动态数据组织（2023级）吉林大学高级语言程序设计作业
最新发布
weixin_46307958的博客
11-24 180
欢迎校友+q3023225096进行讨论交流。
吉林大学超星MOOC高级语言程序设计 实验09(2021级）
qq_57791219的博客
12-15 3600
程设的最后一次作业了，哈哈哈，我的代码其实不是补全的代码，基本都是重写的。我不太喜欢一堆*****的写法。然后祝大家机试的ak，笔试的满绩！ 1.(程序题) 题目编号：Exp09-Enhance01 题目名称：单链表倒数第K个结点 题目描述：请填写缺失代码完成程序，实现如下功能： 首先根据键盘随机输入，以0结束的若干非零整数建立单链表； 然后根据输入的整数K，输出链表倒数第K个结点的值，相邻数字间以一个西文空格间隔，最后一个数字后无任何字符； 若不存在则输出NULL。...
实验07递归程序设计（2023级）吉林大学高级语言程序设计作业
weixin_46307958的博客
11-14 444
编写程序，用递归方法计算一个长度为n的木条，当规定长度为k时，其经过上述截断过程会得到多少根木条。其中：n、k均为正整数，且假设木条截断所得短木条长度四舍五入为正整数，长木条长度为总长减去短木条长度。给定一个长度为n的木条，将其在大致2/5的位置截断，得到2个长度仍为整数的木条；如果新得到的木条的长度仍旧超过规定长度k，将继续按照上述方法处理得到的木条，直到所有木条的长度都不大于k。输入：一行输入两个非负整数，分别是十进制的 N 和 b ，其中 0 <=N <=2^31 ，2 <=b <= 36。
工程认证背景下高级语言程序设计教学改革.docx
06-24
在工程认证背景下，高级语言程序设计教学改革是一项重要的任务，旨在提升教学质量，培养具有工程实践能力和创新精神的人才。传统的教学模式通常以教师为中心，忽视了学生的自主学习能力和创新能力的培养。针对这一...
程序设计基础Python语言-教学大纲2022版.docx
03-11
程序设计基础 Python 语言-教学大纲2022版.docx 本课程教学大纲是为非计算机专业学生设计的 Python 语言程序设计课程，旨在使学生系统...2. 中国大学慕课 Python 语言程序设计 - 在线学习中心超星平台 3. 线上考试系统
《单片机高级语言c51应用程序设计》书450页，徐爱钧等编。
07-28
《单片机高级语言C51应用程序设计》是一本由徐爱钧和彭秀华等人编著的专业技术书籍，共计450页。这本书详细介绍了使用C51语言进行单片机程序设计的方法和技巧。C51是针对8051系列单片机的一种高级编程语言，它在保留...
计算机语言类课程教学模式改革与实践——以“VB程序设计”为例.pdf
12-02
【VB程序设计课程教学改革】本文探讨了计算机语言类课程，特别是VB程序设计课程的教学模式改革，以适应新时代教育需求。传统的"课堂讲授+机房上机"模式因笔记本电脑普及和学生学习习惯变化而逐渐失去吸引力。作者...
吉林大学《高级语言程序设计》课程设计（代码、实验报告）
08-11
吉林大学《高级语言程序设计》课程设计VS2010工程代码、实验报告。
吉林大学-高级语言程序设计-期末考试答案.pdf
12-19
吉林大学高级语言程序设计期末考试答案。程序题代码可以直接从pdf上抠下来。答案在手，满分我有~~~~
吉林大学本科生C++高级语言程序设计课件
03-15
吉林大学本科生C++高级语言程序设计课件
吉林大学 中国大学MOOC 高级语言程序设计 期末考试——编程题（2022级）
m0_72113406的博客
12-02 2899
吉林大学 中国大学MOOC 高级语言程序设计 期末考试——编程题（2022级） 本人能力有限，发出只为帮助有需要的人。 建议同学们自己写完后再进行讨论。
吉林大学超星MOOC高级语言程序设计 实验09(2022级）
m0_74078627的博客
11-22 1895
最后将删除后链表中各结点值输出，相邻数字间以一个西文空格间隔，最后一个数字后无任何字符；若是空链表，则输出NULL。之后将此链表中保存的数字顺次输出，相邻数字间以一个西文空格间隔，最后一个数字后无任何字符；输出n阶法雷序列各项分数形式，分数的分子和分母间以/连接，各个分数间以一个西文空格间隔，最后一个数字后无任何字符。最后将从中间结点开始到链表尾各结点值输出，相邻数字间以一个西文空格间隔，最后一个数字后无任何字符。最后验证输出排序后链表中所有值，相邻数字间以一个西文空格间隔，最后一个数字后无任何字符。
C++上机实验1-1
Vircccccc的博客
03-10 407
一、问题及代码 /* * 文件名称：qwe.cpp * 作 者： 柳青雨 * 完成日期： 2016年 03 月 10 日 * 版 本 号：v1.0 * 对任务及求解方法的描述部分:求两数和差 * 输入描述： 两个整数 * 问题描述： 求两数和差 * 程序输出： 和差 * 问题分析： 略 * 算法设计： 略 */ #include using na
根据输入的整数k（0＜k＜10），输出k行 乘法表，每行的乘法式子逐行加1。乘法式子左边数字和*号之间没有空格，结果左对齐，宽度为3。如果k不在上述范围内，则输出：输入有误
m0_49018281的博客
04-16 386
#include <stdio.h> int main ( ) { int k; scanf("%d",&k); if(k<=0||k>=10) { printf("输入有误！"); } else { int i,j; for(i=1; i<=k; i++) { for(j=1; j<=i; j++) { if(j==i) { printf("%d*%d=%d",j,i,i*j); } else printf(.
C语言程序设计学习笔记
少侠PSY的博客
03-19 3596
C语言程序设计学习笔记
超星实验03 模块化程序设计（2020级）（部分题解）
qq_51519554的博客
01-05 3053
1 题目编号：Exp03-Basic01，GJBook3-05-02 题目名称：组合问题 题目描述：编写程序，输入m，n的值，计算并输出函数f的值。 GJBook3-05-02.jpg 输入：一个整数m和一个整数n（m,n≤20）。 输出：函数f的值。 样例1： 输入：-1 2 输出：-1 样例2： 输入：2 2 输出：1 #include <stdio.h> int main() { long long a=1,b=1,c=1; int k; int m,n; scanf("%d %d",
吉林大学超星mooc高级语言程序设计
03-16
您好，吉林大学超星mooc高级语言程序设计是一门高级编程语言课程，主要涵盖了C++语言的基础知识和高级应用。通过学习这门课程，学生可以掌握C++语言的基本语法、面向对象编程、数据结构与算法等知识，为以后的编程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陈驰水

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值