吉林大学超星MOOC高级语言程序设计 实验09(2022级）

已于 2022-11-23 14:33:54 修改
阅读量1.8k 收藏 15
点赞数 5
分类专栏： 作业 文章标签： c语言 链表
于 2022-11-22 20:07:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74078627/article/details/127974462
版权

目录

1. (程序题)创建单链表

2. (程序题)删除单链表重复节点

3. (程序题)求单链表中间结点

4. (程序题)单链表交换两节点

5. (程序题)单链表存储法雷序列

6. (程序题)合并单链表

7. (程序题)排序单链表

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;
    scanf("%d", &n);
    if (n == 0)
        return NULL;
    head = (struct cell*)malloc(sizeof(struct cell));
    head->x = n;
    scanf("%d", &n);
    p = head;
    while (n != 0) {
        tmp=(struct cell*)malloc(sizeof(struct cell));
        tmp->x = n;
        p->next = tmp;
        p = tmp;
        p->next = NULL;
        scanf("%d", &n);
    }
    return head;//返回单链表头
}


void print(struct cell* head) {//打印整个单链表,head是指向单链表首结点的指针
    struct cell* p;
    p = head;
    printf("%d", p->x);
    p = p->next;
    while (p != NULL) {
        printf(" %d", p->x);
        p = p->next;
    }
}
void release(struct cell* head) {//释放单链表空间,head是指向单链表首结点的指针
    struct cell* p;
    while(head!=NULL){
        p = head;
        head = p->next;
        free(p);
    }

}
int main(void) {
    struct cell* head;
    head = build();
    if (head != NULL)
        print(head);
    else
        printf("NULL");
    release(head);
}

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;
    scanf("%d", &n);
    if (n == 0)
        return NULL;
    head = (struct cell*)malloc(sizeof(struct cell));
    head->x = n;
    scanf("%d", &n);
    p = head;
    while (n != 0) {
        tmp = (struct cell*)malloc(sizeof(struct cell));
        tmp->x = n;
        p->next = tmp;
        p = tmp;
        p->next = NULL;
        scanf("%d", &n);
    }
    return head;//返回单链表头
}
struct cell* del2one(struct cell* head) {//删除重复结点只保留一个，head是单链表首结点指针
    struct cell* p,*p0,*r;     //r指向p0之前的节点，p0指向待比较的节点
    p = head;
    while (p != NULL) {
        r = p;
        p0 = p->next;
        while (p0 != NULL) {
            if (p0->x == p->x) {  //当有重复元素
                r->next = p0->next;
                p0 = r ->next;
            }
            else {
                r = r->next;
                p0 = r->next;
            }
        }
        p = p->next;
    }
    return head;//返回删除重复结点的单链表头
}
void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
    struct cell* p;
    printf("%d", head->x);
    p = head->next;
    while (p != NULL) {
        printf(" %d", p->x);
        p = p->next;
    }
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
    struct cell* p;
    while (head != NULL) {
        p = head;
        head = p->next;
        free(p);
    }
}
int main(void) {
    struct cell* head;
    head = build();
    head = del2one(head);
    if (head != NULL)
        print(head);
    else
        printf("NULL");
    release(head);
}

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;
    scanf("%d", &n);
    if (n == 0)
        return NULL;
    head = (struct cell*)malloc(sizeof(struct cell));
    head->x = n;
    p = head;
    p->next = NULL;
    scanf("%d", &n);
    while (n != 0) {
        tmp = (struct cell*)malloc(sizeof(struct cell));
        tmp->x = n;
        p->next = tmp;
        p = tmp;
        p->next = NULL;
        scanf("%d", &n);
    }
    return head;//返回单链表头
}
struct cell* mid(struct cell* head) {//寻找链表中间位置结点地址并返回，head是单链表首结点指针
    int i=0,n;
    struct cell* p;
    p = head;
    while (p != NULL) {
        i++;
        p = p->next;
    }
    if (i % 2 == 0)
        n = i / 2 - 1;
    else
        n = i / 2;
    p = head;
    while (n != 0) {
        p = p->next;
        n--;
    }
    head = p;
    return head;
}
void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
    struct cell* p;
    printf("%d", head->x);
    p = head->next;
    while (p->x != 0) {
        printf(" %d", p->x);
        p = p->next;
    }
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
    struct cell* p;
    while (head != NULL) {
        p = head;
        head = p->next;
        free(p);
    }
}
int main(void) {
    struct cell* head, * half;
    head = build();
    half = mid(head);
    if (half != NULL)
        print(half);
    else
        printf("NULL");
    release(head);
}

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;
    scanf("%d", &n);
    if (n == 0)
        return NULL;
    head = (struct cell*)malloc(sizeof(struct cell));
    head->x = n;
    p = head;
    p->next = NULL;
    scanf("%d", &n);
    while (n != 0) {
        tmp= (struct cell*)malloc(sizeof(struct cell));
        tmp->x = n;
        p->next = tmp;
        p = tmp;
        p->next = NULL;
        scanf("%d", &n);
    }
    
    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的结点位于链表中间
        if (pm0 != NULL && pn0 != NULL) {
            tmp = pn->next;
            pm0->next = pn;
            pn->next = pm->next;
            pn0->next = pm;
            pm->next = tmp;
        }
        if (pm0 == NULL && pn0 != NULL) {   //即pm为head
            tmp = pm->next;
            pn0->next = pm;
            pm->next = pn->next;
            pn->next = tmp;
            head = pn;
        }
        if (pm0 != NULL && pn0 == NULL) {  //pn为head
            tmp = pn->next;
            pn->next = pm->next;
            pm0->next = pn;
            pm->next = tmp;
            head = pm;
        }
    }
    return head;
}
void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
    struct cell* p;
    printf("%d", head->x);
    p = head->next;
    while (p->x != 0) {
        printf(" %d", p->x);
        p = p->next;
    }
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
    struct cell* p;
    while (head != NULL) {
        p = head;
        head = p->next;
        free(p);
    }
}
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

这个就是教材上面的程序，完全按照上面的思路来的orz

#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;
    else
        return gcd(y, x % y);
}
/*构造法雷序列,并返回序列头指针*/
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 (j * r->denominator > i * r->numerator) {
                    r0 = r; r = r->next;
                }//j/i插入到r0，r之间
                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引导的法雷序列
    farleipointer p;
    p = fn;
    printf("%d/%d", p->numerator, p->denominator);
    p = p->next;
    while (p != NULL) {
        printf(" %d/%d", p->numerator, p->denominator);
        p = p->next;
    }
}

void release(farleipointer head) {//释放单链表空间,head是单链表首结点指针
    farleipointer p;
    while(head!=NULL){
        p = head;
        head = p->next;
        free(p);
    }
}

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;
    scanf("%d", &n);
    if (n == 0)
        return NULL;
    head = (struct cell*)malloc(sizeof(struct cell));
    head->x = n;
    tail = head;
    tail->next = NULL;
    scanf("%d", &n);
    while (n != 0) {
        tmp = (struct cell*)malloc(sizeof(struct cell));
        tmp->x = n;
        tail->next = tmp;
        tail = tmp;
        tail->next = NULL;
        scanf("%d", &n);
    }
    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;
    head = p;//head当头指针
    q0 = q; 
    while (q0 != NULL) {
        p = head;
        r = q0;  //r保存要插入的结点
        q = q->next;   //q的头指针指向下一个
        if (p->x < r->x) {
            p0 = p;
            p = p->next;
            while (p->x < r->x && p->next != NULL) {
                p0 = p;
                p = p->next;
            }
            if (p->next == NULL) {
                p->next = r;
                r->next = NULL;
            }
            else {
                r->next = p;
                p0->next = r;
            }
        }
        else {
            r->next = p;
            head = r;
        }
        q0 = q;
    }
    return head;
}
void print(struct cell* head) {//打印整个单链表,head是单链表首结点指针
    struct cell* p;
    printf("%d", head->x);
    p = head->next;
    while (p != NULL) {
        printf(" %d", p->x);
        p = p->next;
    }
}
void release(struct cell* head) {//释放单链表空间,head是单链表首结点指针
    struct cell* p;
    while (head != NULL) {
        p = head;
        head = p->next;
        free(p);
    }
}
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

（排序第一次自己写的太复杂了，借鉴了一下别人的思路orz）

#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;
    tail= head;
    tail->next = NULL;
    scanf("%d", &n);
    while (n != 0) {
        tmp = (struct cell*)malloc(sizeof(struct cell));
        tmp->x = n;
        tail->next = tmp;
        tail = tmp;
        tail->next = NULL;
        scanf("%d", &n);
    }
    return head;//返回单链表头
}
struct cell* sort(struct cell* head) {//递增排序链表，head是单链表首结点指针
    struct cell* p, * p0, * r, * r0, * q;
    p = p0 = r = r0 = q = NULL;
    p = head;
    p = p->next;
    p0 = head;
    while(p!=NULL){
        r = head;
        while (r->x < p->x && r != p) {
            r0 = r;
            r = r->next;
        }
        if (r != p) {     //r0比p小，r比p大
            q = p;       //此处把p所指的结点保存，根据r的位置分情况
            p0->next = p->next;
            p = p0;
            if (r == head) {
                q->next = r;
                head = q;
            }
            else {            //将q插入r0与r之间
                q->next = r;
                r0->next = q;
            }
        }
        p0 = p;
        p = p->next;
    }
    return head;
}   /*  sort */


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

Scarlett_19
关注
  • 5
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
吉林大学超星高级语言程序设计 实验09 动态数据组织
Felon233的博客
12-27 6077
填空题，不怎么难，比较懒直接给程序，自己对着填，给与参考，欢迎大家一起交流 ：-） 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高级语言程序设计 实验07(2021级）
qq_57791219的博客
11-29 2490
1.(程序题) 【计2016级期末试题】构造一个表示教师的结构体（包含3个字段：姓名、性别、年龄），编写函数，读入n个教师的信息，存入一个结构体数组中（如下图所示）。最后输出第n/2个教师的信息。 例如：一个教师的信息为zhangsan、false、50，另一个教师的信息为lisi、false、37。 输入：依次输入一个正整数n及n个教师的姓名、性别、年龄。（说明：n不大于10；姓名长度不超过20个英文字符；性别输入0/1表示女/男）。 输出：数组下标为n/2的教师信息。（说明：n/2直接截取.
吉林大学 超星慕课 高级语言程序设计 实验08 结构化程序设计（2022级）
m0_72113406的博客
12-10 1867
吉林大学 超星慕课 高级语言程序设计 实验08 结构化程序设计（2022级） 本人能力有限，发出只为帮助有需要的人。 建议同学们自己写完后再进行讨论。
C++上机实验1-1
Vircccccc的博客
03-10 406
一、问题及代码 /* * 文件名称：qwe.cpp * 作 者： 柳青雨 * 完成日期： 2016年 03 月 10 日 * 版 本 号：v1.0 * 对任务及求解方法的描述部分:求两数和差 * 输入描述： 两个整数 * 问题描述： 求两数和差 * 程序输出： 和差 * 问题分析： 略 * 算法设计： 略 */ #include using na
实验05 指针及其在程序设计中的应用（2020级）
qq_52878162的博客
12-04 2463
实验05 指针及其在程序设计中的应用（2020级） 1 题目编号：Exp05-Basic01，GJBook3-07-06 题目名称：字符串长度 题目描述：编写程序实现：使用自编函数int strlen(char *str)，求字符串str长度；并在主程序中调用。 输入：从键盘随机输入长度不超过256的字符串，字符串内可能包含若干空白字符。 输出：字符串的长度。 样例1： 输入：123 456 输出：8 样例2： 输入：A 输出：1 #include<stdio.h> int strlen(
程序设计基础Python语言-教学大纲2022版.docx
03-11
程序设计基础 Python 语言-教学大纲2022版.docx 本课程教学大纲是为非计算机专业学生设计的 Python 语言程序设计课程，旨在使学生系统...2. 中国大学慕课 Python 语言程序设计 - 在线学习中心超星平台 3. 线上考试系统
VB_ API 程序设计.超星.rar_超星
09-21
VB_ API 程序设计.超星学习必备资料
《单片机高级语言c51应用程序设计》书450页，徐爱钧等编。
07-28
《单片机高级语言c51应用程序设计》书450页，徐爱钧，彭秀华等编著。 超星文件格式，如果你无法阅读该格式的图书，到本站下载超星阅览器。 现在提供PDF格式，524页。
图书 CPLD_FPGA高级应用开发指南 （超星书 免费）-综合文档
05-25
图书 CPLD_FPGA高级应用开发指南 （超星书 免费）,CPLD_FPGA高级应用开发指南……
基于超星平台的JavaScript程序设计课程教学改革.pdf
最新发布
01-03
基于超星平台的JavaScript程序设计课程教学改革.pdf
吉林大学 C语言程序设计实验09 动态数据组织（2023级）
2301_80221401的博客
12-06 173
/ 连接部分 };struct cell* build(void) {//新建单链表，并将建好的单链表首结点地址返回 struct cell* head, * tmp, * p;//返回单链表头 } struct cell* del2one(struct cell* head) {//删除重复结点只保留一个，head是单链表首结点指针 /*请在以下位置补充完整，实现函数del2one的功能 ...... ...... ...... */ return head;
吉林大学超星高级语言程序设计 实验08 结构化程序设计（2020级）
qq_51741975的博客
12-17 9316
（以下答案均由本人自己编写，欢迎大家一起交流） 建议在完成本次实验前对DFS算法有一定了解。 1 题目编号：Exp08-Basic01，GJBook3-12-05 题目名称：正整数分解 题目描述：正整数n，按第一项递减的顺序依次输出其和等于n的所有不增的正整数和式。 输入：一个正整数n（0<n≤15）。 输出：每行输出如样例所示，和等于n的不增正整数和式，数字和运算符间无符号，最后一行结尾有一个回车换行符。 样例： 输入： 4 输出： 4=3+1 4=2+2 4=2+1+1 4=1+1+1+1` #i
机试指南练习-第六章
qq_41911859的博客
09-09 221
机试指南练习总结第六章机试指南练习总结第四章-枚举机试指南练习总结第四章-广度优先搜索(BFS)例6.2：胜利大逃亡 机试指南练习总结第四章-枚举 机试指南练习总结第四章-广度优先搜索(BFS)       常用的广度BFS， 一般使用队列实现，可以用来求最佳值 例6.2：胜利大逃亡 提交OJ 题目描述 Ignatius被魔王抓走了,有一天魔王出差去了,这可是Ignatius逃亡的好机会. 魔王住在一个城堡里,城堡是一个ABC的立方体,可以被表示成
单链表交换两结点
m0_60352483的博客
12-26 2121
题目描述：请填写缺失代码完成程序，实现如下功能：首先根据键盘随机输入，以0结束的若干非零整数建立单链表；然后根据输入的两个索引位置交换链表上的两个结点（链表首元素索引为1, #include <stdio.h> #include <malloc.h> struct cell {//单链表结点结构体定义 int x; struct cell* next; }; struct cell* build(void) {//新建单链表，并将建好的单链表首结点地址
c语言实现单链表的创建（完整版）
qq_44858403的博客
05-25 1万+
使用c语言实现单链表是考研的重点。但是如何实现却是一个难点。下面是我写的一个简单的创建单链表的代码。 #include<stdio.h> #include<stdlib.h> #include<malloc.h> typedef struct node{ int data; struct node *next; }LinkList; //结构体的定义 LinkList *create_Link(){ //创建单链表的主要代码（尾插法建立单链表） LinkLi
#Java学习#习题三
热门推荐
vircorns的博客
05-25 1万+
文章目录判断题单选题函数题写出派生类构造方法（Java）根据派生类写出基类（Java）人口统计编程题通过键盘输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数数组元素交换集体评分jmu-Java-03面向对象基础-01-构造函数与toString 判断题 单选题 函数题 写出派生类构造方法（Java） 裁判测试程序样例中展示的是一段定义基类People、派生类Student以及测试两个类的相关Java代码，其中缺失了部分代码，请补充完整，以保证测试程序正常运行 函数接口定义: 根提示： 观察类
多边形周长Exp03-Basic03
m0_46417197的博客
11-12 2209
标题多边形周长Exp03-Basic03 题目名称： 题目描述：编写程序，求由键盘按顺时针方向输入n（0<n<=10)个顶点坐标的多边形周长（测试数据已保证当n>2时，各点按输入方向依次连接可构成封闭的n边形）。 输入：第一行输入一个整数，作为n值；以后每行两个浮点数（double），为多边形各顶点的坐标。 输出：多边形的周长，精确到小数点后2位。 样例1： 输入： 4 0 0 0 1 1 1 1 0 输出：4.00 样例2： 输入： 1 2 3 输出： 0.00 样例3： 输入：
[单链表] 删除链表中重复的结点
Darling_sheeps的博客
09-18 1111
删除链表中重复的结点：在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 基本思想： 1.设置一个虚拟的新的链表的头结点，其后用来放不重复的结点 2.用cur遍历原链表，遇到前后值相等的两个结点，cur就向后走一步 3.对于不重复的结点，就尾插到新的链表后面 public class Solution { public ListNode deleteDuplication(ListNode pHead) { ListNode newh.
数据结构与算法——删除单链表中的重复结点
beilizhang的博客
07-26 8791
如何删除单链表中的重复结点 方法一：递归 对于一个结点head，首先把链表head->next作为头结点的链表中的重复项删除，然后遍历head->next为头结点的链表中的元素，判断遍历到的元素是否与head结点元素相等，如果相等，则删除。对于head->next为头结点的链表而言，可以使用同样的思路来删除以head->next->next为头结点的链表中的重复元素。因此可以使用递归的方法求解 struct ListNode { int val; ListNod
吉林大学超星mooc高级语言程序设计
03-16
您好，吉林大学超星mooc高级语言程序设计是一门高级编程语言课程，主要涵盖了C++语言的基础知识和高级应用。通过学习这门课程，学生可以掌握C++语言的基本语法、面向对象编程、数据结构与算法等知识，为以后的编程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Scarlett_19

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

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

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

打赏作者

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

抵扣说明：

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

余额充值