《C语言及程序设计》实践参考——改造链表

最新推荐文章于 2024-08-14 10:46:20 发布
最新推荐文章于 2024-08-14 10:46:20 发布
阅读量1.7k 收藏 2
点赞数
分类专栏： C程序 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sxhelijian/article/details/46761775
版权

返回：贺老师课程教学链接

【项目3 - 改造链表】
下面是一个建立动态链表的程序。阅读程序，然后按要求改造程序。

#include  <iostream>  
using namespace std;  
#include <stdio.h>
#include <malloc.h>
#define N 5
typedef struct NODE
{
    int data;            //结点的数据
    struct NODE *next;  //指向下一结点
} Node;
Node *head=NULL;    //将链表头定义为全局变量，以便于后面操作
void make_list();   //建立链表
void out_list();    //输出链表

int main( )
{
    make_list();
    out_list();
    return 0;
}
void make_list()
{
    int n;
    Node *p;
    printf("输入若干正数（以0或一个负数结束）建立链表：" );
    scanf("%d", &n);
    while(n>0)   //输入若干正数建立链表，输入非正数时，建立过程结束
    {
        p=(Node*)malloc(sizeof(Node));  //新建结点
        p->data=n;
        p->next=head;  //新建的结点指向原先的链表头
        head=p;    //链表头赋值为新建的节点，这样，新结点总是链表头
        scanf("%d", &n);      //输入下一个数，准备建立下一个结点
    }
    return;
}
void out_list()
{
    Node *p=head;
    printf("链表中的数据为：\n");
    while(p!=NULL)
    {
        printf("%d ", p->data);
        p=p->next;
    }
    printf("\n");
    return;
}

在上面的程序基础上定义下面的函数，实现相应的功能。
为简便起见，每编写一个函数，立刻在main函数中调用进行测试。
（1）编写make_list2()函数建立链表，使建立链表时，后输入的数据，将新输入的数字对应的结点放在链表末尾。若输入为3 5 2 9 4 7 0，建立的链表为：

[参考解答]

#include <stdio.h>
#include <malloc.h>
#define N 5
typedef struct NODE
{
    int data;            //结点的数据
    struct NODE *next;  //指向下一结点
} Node;
Node *head=NULL;
void make_list2();  //新结点始终在链表尾部
void out_list();    //输出链表

int main( )
{
    make_list2();
    out_list();
    return 0;
}
void make_list2()
{
    int n;
    Node *p,*q;  //p用于指向新建立的结点, q指向链表尾部
    printf("输入若干正数（以0或一个负数结束）建立链表：\n");
    scanf("%d", &n);
    while(n>0)
    {
        p=(Node*)malloc(sizeof(Node));
        p->data=n;
        p->next=NULL;
        if(head==NULL)
            head=p;
        else
            q->next=p;
        q=p;
        scanf("%d", &n);
    }
    return;
}
void out_list()
{
    Node *p=head;
    printf("链表中的数据为：\n");
    while(p!=NULL)
    {
        printf("%d ", p->data);
        p=p->next;
    }
    printf("\n");
    return;
}

（2）编写函数void search(int x)，输出链表中是否有值为x的结点。
[参考解答]

#include <stdio.h>
#include <malloc.h>
#define N 5
typedef struct NODE
{
    int data;            //结点的数据
    struct NODE *next;  //指向下一结点
} Node;
Node *head=NULL;
void make_list2();  //新结点始终在链表尾部
void out_list();    //输出链表
void search(int x);  //查找是否有值为x的结点

int main( )
{
    int x;
    make_list2();
    out_list();
    scanf("%d", &x);  //测试中输入一个链表中有的数字
    search(x);
    scanf("%d", &x);  //测试中输入一个链表中没有的数字
    search(x);
    return 0;
}

void make_list2()
{
    int n;
    Node *p,*q;  //p用于指向新建立的结点, q指向链表尾部
    printf("输入若干正数（以0或一个负数结束）建立链表：\n");
    scanf("%d", &n);
    while(n>0)
    {
        p=(Node*)malloc(sizeof(Node));
        p->data=n;
        p->next=NULL;
        if(head==NULL)
            head=p;
        else
            q->next=p;
        q=p;
        scanf("%d", &n);
    }
    return;
}

void out_list()
{
    Node *p=head;
    printf("链表中的数据为：\n");
    while(p!=NULL)
    {
        printf("%d ", p->data);
        p=p->next;
    }
    printf("\n");
    return;
}

void search(int x)
{
    //查找是否有值为x的结点
    Node *p=head;
    while(p!=NULL&&p->data!=x)
    {
        p=p->next;
    }
    if(p!=NULL)  //退出上一层循环一定是因为p->data==x
        printf("在链表中有值为%d的结点\n", x);
    else
        printf("在链表中没有值为%d的结点\n", x);
    return;
}

补充：

这个版本的search，只判断是否找到，有兴趣的同学，可以实现能输出有几个的版本
void search(int x)还可以重定义为bool search(int x)，让main函数根据返回值输出结果
对应能输出有几个的版本，重定义为int search(int x)，返回值是存在的个数，为0没有找到

（3）编写函数delete_first_node()，删除链表中的第一个结点。
[参考解答]

#include <stdio.h>
#include <malloc.h>
#define N 5
typedef struct NODE
{
    int data;            //结点的数据
    struct NODE *next;  //指向下一结点
} Node;
Node *head=NULL;
void make_list2();  //新结点始终在链表尾部
void out_list();    //输出链表
void delete_first_node();  //删除第一个结点

int main( )
{
    make_list2();
    out_list();
    delete_first_node();
    out_list();
    return 0;
}

void make_list2()
{
    int n;
    Node *p,*q;  //p用于指向新建立的结点, q指向链表尾部
    printf("输入若干正数（以0或一个负数结束）建立链表：\n");
    scanf("%d", &n);
    while(n>0)
    {
        p=(Node*)malloc(sizeof(Node));
        p->data=n;
        p->next=NULL;
        if(head==NULL)
            head=p;
        else
            q->next=p;
        q=p;
        scanf("%d", &n);
    }
    return;
}

void out_list()
{
    Node *p=head;
    printf("链表中的数据为：\n");
    while(p!=NULL)
    {
        printf("%d ", p->data);
        p=p->next;
    }
    printf("\n");
    return;
}

void delete_first_node()
{
    Node *p=head;
    if (p!=NULL)
    {
        head = p->next;
        free(p);
        printf("删除了首结点.\n");
    }
    else
    {
        printf("空链表，不能删除.\n");
    }
    return;
}

（4）编写函数delete_node(int x)，删除结点值为x的结点。
[参考解答]

#include <stdio.h>
#include <malloc.h>
#define N 5
typedef struct NODE
{
    int data;            //结点的数据
    struct NODE *next;  //指向下一结点
} Node;
Node *head=NULL;
void make_list2();  //新结点始终在链表尾部
void out_list();    //输出链表
void delete_node(int x);  //删除第一个结点

int main( )
{
    make_list2();
    out_list();
    delete_node(3);
    out_list();
    return 0;
}

void make_list2()
{
    int n;
    Node *p,*q;  //p用于指向新建立的结点, q指向链表尾部
    printf("输入若干正数（以0或一个负数结束）建立链表：\n");
    scanf("%d", &n);
    while(n>0)
    {
        p=(Node*)malloc(sizeof(Node));
        p->data=n;
        p->next=NULL;
        if(head==NULL)
            head=p;
        else
            q->next=p;
        q=p;
        scanf("%d", &n);
    }
    return;
}

void out_list()
{
    Node *p=head;
    printf("链表中的数据为：\n");
    while(p!=NULL)
    {
        printf("%d ", p->data);
        p=p->next;
    }
    printf("\n");
    return;
}

void delete_node(int x)
{
    Node *p,*q;
    if (head==NULL)
        printf("空链表，不能删除\n");
    else
    {
        //要删除的恰是首结点（不排除连续有若干个结点值为x），
        while(head!=NULL&&head->data==x)
        {
            p=head;
            head=head->next;
            free(p);
        }
        if(head!=NULL)
        {
            p=head;
            q=p->next;
            while(q!=NULL)
            {
                if(q->data==x)//q就是该删除的结点
                {
                    p->next=q->next;
                    free(q);
                }
                else     //q不该删除，继续考察下一个
                {
                    p=q;
                }
                q=p->next;  //总是p的下一个结点
            }
        }
    }
    return;
}

为充分测试，该程序运行了4次，所用的测试输入数据分别为：
5 2 9 9 7 11 3 0
3 5 2 9 9 7 11 0
3 5 2 9 3 9 7 11 0
3 3 3 3 3 3 3 0

（5）编写make_list3()函数建立链表，使建立链表时，使结点中的数据呈现升序。若输入为3 5 2 9 4 7 0，建立的链表为：

[参考解答]

#include <stdio.h>
#include <malloc.h>
#define N 5
typedef struct NODE
{
    int data;            //结点的数据
    struct NODE *next;  //指向下一结点
} Node;
Node *head=NULL;
void make_list3();  //建立有序链表，各结点由小到大
void out_list();    //输出链表

int main( )
{
    make_list3();
    out_list();
    return 0;
}

void make_list3()
{
    int n;
    Node *t,*p,*q;  //p用于指向新建立的结点, q指向链表尾部
    printf("输入若干正数（以0或一个负数结束）建立链表：\n");
    scanf("%d", &n);
    while(n>0)
    {
        t=(Node*)malloc(sizeof(Node));
        t->data=n;
        t->next=NULL;
        if(head==NULL)   //是空链表，p作为第一个结点即可
            head=t;
        else             //插入p结点后，各结点应该保持有序
        {
            if(n<=head->data)  //新加入的结点应该为首结点
            {
                t->next=head;
                head=t;
            }
            //应该找到合适的位置后，将结点插入
            //此时，链表中至少已经有一个结点，且插入结点不是首结点
            else
            {
                p=head;
                q=p->next;   //p与q相邻，p更靠近q，插入位置将在p和q之间
                while(q!=NULL&&n>q->data)  //链表没有完且p结点比n小，一直往后找
                {
                    p=q;
                    q=p->next;
                }
                if(q==NULL) //q为null，作为最后一个结点直接插入到p后即可
                {
                    p->next = t;
                }
                else   //t插入到p和q之间
                {
                    t->next=q;
                    p->next=t;
                }
            }
        }
        scanf("%d", &n);
    }
    return;
}

void out_list()
{
    Node *p=head;
    printf("链表中的数据为：\n");
    while(p!=NULL)
    {
        printf("%d ", p->data);
        p=p->next;
    }
    printf("\n");
    return;
}

（6）编写函数void insert(int x)，将值为x的结点插入到由make_list3建立起来的有序链表中。
[参考解答]

#include <stdio.h>
#include <malloc.h>
#define N 5
typedef struct NODE
{
    int data;            //结点的数据
    struct NODE *next;  //指向下一结点
} Node;
Node *head=NULL;
void make_list3();  //建立有序链表，各结点由小到大
void out_list();    //输出链表
void insert(int x); //将值为x的结点插入到有序链表中，使仍有序

int main( )
{
    make_list3();
    out_list();
    insert(5);
    out_list();
    return 0;
}

void make_list3()
{
    int n;
    Node *t,*p,*q;  //p用于指向新建立的结点, q指向链表尾部
    printf("输入若干正数（以0或一个负数结束）建立链表：\n");
    scanf("%d", &n);
    while(n>0)
    {
        t=(Node*)malloc(sizeof(Node));
        t->data=n;
        t->next=NULL;
        if(head==NULL)   //是空链表，p作为第一个结点即可
            head=t;
        else             //插入p结点后，各结点应该保持有序
        {
            if(n<=head->data)  //新加入的结点应该为首结点
            {
                t->next=head;
                head=t;
            }
            //应该找到合适的位置后，将结点插入
            //此时，链表中至少已经有一个结点，且插入结点不是首结点
            else
            {
                p=head;
                q=p->next;   //p与q相邻，p更靠近q，插入位置将在p和q之间
                while(q!=NULL&&n>q->data)  //链表没有完且p结点比n小，一直往后找
                {
                    p=q;
                    q=p->next;
                }
                if(q==NULL) //q为null，作为最后一个结点直接插入到p后即可
                {
                    p->next = t;
                }
                else   //t插入到p和q之间
                {
                    t->next=q;
                    p->next=t;
                }
            }
        }
        scanf("%d", &n);
    }
    return;
}

void insert(int x) //将值为x的结点插入到有序链表中，使仍有序
{
    Node *t,*p,*q;  //p用于指向新建立的结点, q指向链表尾部
    t=(Node*)malloc(sizeof(Node));;
    t->data=x;
    t->next=NULL;
    if(head==NULL)   //是空链表，p作为第一个结点即可
        head=t;
    else             //插入p结点后，各结点应该保持有序
    {
        if(x<=head->data)  //新加入的结点应该为首结点
        {
            t->next=head;
            head=t;
        }
        //应该找到合适的位置后，将结点插入
        //此时，链表中至少已经有一个结点，且插入结点不是首结点
        else
        {
            p=head;
            q=p->next;   //p与q相邻，p更靠近q，插入位置将在p和q之间
            while(q!=NULL&&x>q->data)  //链表没有完且p结点比n小，一直往后找
            {
                p=q;
                q=p->next;
            }
            if(q==NULL) //q为null，作为最后一个结点直接插入到p后即可
            {
                p->next = t;
            }
            else   //t插入到p和q之间
            {
                t->next=q;
                p->next=t;
            }
        }
    }
    return;
}

void out_list()
{
    Node *p=head;
    printf("链表中的数据为：\n");
    while(p!=NULL)
    {
        printf("%d ", p->data);
        p=p->next;
    }
    printf("\n");
    return;
}

（6）另解
实际上，从程序整体上看，makelist3()可以直接调用insert(int x)实现，这样写出的程序合乎工程上的原则。这启示我们，用函数组织程序结构，应该成为一种意识。

#include <stdio.h>
#include <malloc.h>
#define N 5
typedef struct NODE
{
    int data;            //结点的数据
    struct NODE *next;  //指向下一结点
} Node;
Node *head=NULL;
void make_list3();  //建立有序链表，各结点由小到大
void out_list();    //输出链表
void insert(int x); //将值为x的结点插入到有序链表中，使仍有序

int main( )
{
    make_list3();
    out_list();
    insert(5);
    out_list();
    return 0;
}

void make_list3()
{
    int n;
    printf("输入若干正数（以0或一个负数结束）建立链表：\n");
    scanf("%d", &n);
    while(n>0)
    {
        insert(n);
        scanf("%d", &n);
    }
    return;
}

void insert(int x) //将值为x的结点插入到有序链表中，使仍有序
{
    Node *t,*p,*q;  //p用于指向新建立的结点, q指向链表尾部
    t=(Node*)malloc(sizeof(Node));;
    t->data=x;
    t->next=NULL;
    if(head==NULL)   //是空链表，p作为第一个结点即可
        head=t;
    else             //插入p结点后，各结点应该保持有序
    {
        if(x<=head->data)  //新加入的结点应该为首结点
        {
            t->next=head;
            head=t;
        }
        //应该找到合适的位置后，将结点插入
        //此时，链表中至少已经有一个结点，且插入结点不是首结点
        else
        {
            p=head;
            q=p->next;   //p与q相邻，p更靠近q，插入位置将在p和q之间
            while(q!=NULL&&x>q->data)  //链表没有完且p结点比n小，一直往后找
            {
                p=q;
                q=p->next;
            }
            if(q==NULL) //q为null，作为最后一个结点直接插入到p后即可
            {
                p->next = t;
            }
            else   //t插入到p和q之间
            {
                t->next=q;
                p->next=t;
            }
        }
    }
    return;
}

void out_list()
{
    Node *p=head;
    printf("链表中的数据为：\n");
    while(p!=NULL)
    {
        printf("%d ", p->data);
        p=p->next;
    }
    printf("\n");
    return;
}
迂者-贺利坚
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言实现链表通讯录
01-03
C语言实现链表通讯录 主要就是链表的应用实例 入门用的 仔细阅读能有不少收获哦 加油~~
C语言程序设计——职工管理系统（链表）.zip
07-13
在本项目"C语言程序设计——职工管理系统（链表）"中，主要涉及的是使用C语言进行程序设计，尤其是利用链表数据结构实现一个职工管理系统的具体应用。链表是一种非常重要的数据结构，它与数组不同，不连续存储数据，...
链表的应用
weixin_33859504的博客
09-07 141
通讯录管理： //通讯录管理/*****************************//*主控菜单处理测试程序*//*****************************/#include<stdio.h>#include<string.h>#include<stdlib.h>typedefstruct{...
C语言实现单链表基础操作--增删查改
AlwenZwei的博客
06-12 992
typedef int DataType; typedef struct ListNode { DataType data; ListNode* next; }ListNode; 注： 1.以下函数都是针对无环单链表 2.若可能修改到原链表头结点，都要传二级指针 函数如下： ListNode* BuyNode(DataType x); //开辟新节点
《C语言及程序设计》实践参考——拆分链表
迂者-贺利坚的专栏
07-05 2789
返回：贺老师课程教学链接【项目2-拆分链表】 编写一个函数将一个头指针为a的单链表A分解成两个单链表A和B，其头指针分别为a和b，使得A链表中含有原链表A中序号为奇数的元素，而B链表中含有原链表A中序号为偶数的元素，且保持原来的相对顺序。例，建立长度为7，元素为1 2 3 4 5 6 7的链表后，经拆分，得到两个数组A和B，其元素分别是1 3 5 7 和2 4 6[参考解答]#include <s
《C语言及程序设计》实践参考——链表的合并
迂者-贺利坚的专栏
07-05 2120
返回：贺老师课程教学链接【项目1-链表的合并】 输入一个整数m，表示A链表的长度，再输入m个数作为A链表中的m个数据元素，建立链表A，其头指针为heada。输入一个整数n，表示B链表的长度，再输入n个数表示B链表中的n个数据元素，建立链表B，其头指针为headb。输入i、len、j，将要从单链表A中删除自第i个元素起的共len个元素，然后将单链表A插入到单链表B的第j个元素之前。最后输出操作后的链
《C语言及程序设计》实践参考——链表版通信录
迂者-贺利坚的专栏
07-05 3892
返回：贺老师课程教学链接【项目4-链表版通信录】 利用链表存储数据，写一个通信录程序，能够记录多个联系人的编号、姓名、性别、联系电话、地址，完成数据的录入、添加、删除、修改以及查询功能。[参考解答]本解答自网络：链接#include<stdio.h> #include<string.h> #include<stdlib.h> typedef struct //通讯录结点类型
《C语言及程序设计》实践项目——链表初步
迂者-贺利坚的专栏
07-05 2086
返回：贺老师课程教学链接【项目1-链表的合并】 输入一个整数m，表示A链表的长度，再输入m个数作为A链表中的m个数据元素，建立链表A，其头指针为heada。输入一个整数n，表示B链表的长度，再输入n个数表示B链表中的n个数据元素，建立链表B，其头指针为headb。输入i、len、j，将要从单链表A中删除自第i个元素起的共len个元素，然后将单链表A插入到单链表B的第j个元素之前。最后输出操作后的链
C语言数据结构——链表
wxk2227814847的博客
01-28 1894
在计算机科学中，数据结构是存储和组织数据的一种方式，它不仅影响数据的存储，也影响数据的检索和更新效率。C语言，作为一种经典的编程语言，提供了灵活的方式来处理数据结构，其中链表是最基本且重要的一种。
复旦大学C语言程序设计解答——链表部分4
06-23
//第7题：有序链表合并。输入：两个有序正整数链表 //(保证正整数从小到大输入，但可能有重复数字，输入为0表示终止）。 //输出：合并后的链表（将链表中的数字有序输出）。 //要求：一定要用链表实现，不能单单复制...
复旦大学C语言程序设计解答——链表部分2
06-23
输入：两个链表，每个链表均为若干个有序正整数(单个链表中无重复数字)， 以0表示一个链表终止，第一个链表为S1，第二个链表为S2。 输出：分三行，分别输出两个集合的并集、差集（S1-S2)和交集。因 为要连续输出三个...
C语言程序设计——学生成绩管理系统（链表）.zip
07-13
在本项目"C语言程序设计——学生成绩管理系统（链表）"中，我们将探讨如何使用C语言构建一个基于链表的数据结构来管理学生分数。这个系统的核心是利用链表高效地存储、检索和操作学生的成绩数据。以下是关于C语言、...
复旦大学C语言程序设计解答——链表部分3
06-23
//第8题：复制链表。输入：一个无序正整数链表（输入为0表示终止）。 //输出：三行，每行一个链表，分别满足题目中的三个链表的要求。 //这道题目必须要复制链表，所以说，不能直接将输入的链表作为第一小题的输出，...
《C语言及程序设计》实践参考——点结构体
迂者-贺利坚的专栏
07-04 3070
返回：贺老师课程教学链接【项目3-点结构体】下面定义了一个表示平面上一点的结构体类型：struct Point { float x; //横坐标 float y; //纵坐标 }; （1）请编写程序，输入一点的横纵坐标，输出该点到原点的距离 [参考解答]#include <stdio.h> #include <math.h> struct Point { fl
《C语言及程序设计》程序阅读——链表初步
迂者-贺利坚的专栏
07-05 1989
返回：贺老师课程教学链接（1）程序下面的阅读，写出其输出结果（建议画出内存中存储的数据，使链表直观地表示出来 ）#include <stdio.h> #include <stdlib.h> struct NODE { int num; struct NODE *next; }; int main() { struct NODE *p,*q,*r; p=(struct
归并排序(递归与非递归实现,C语言)
最新发布
SikJ_2020_0_24的博客
08-14 245
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有 序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。2. 时间复杂度：O(N*logN)3. 空间复杂度：O(N)
c语言-经典例题
m0_71813740的博客
08-12 669
- C y<=5 --是关系运算符的优先级大于&& -- 是逻辑运算符。-- B p本来是个指针（也就是地址），*p是解地址，所以 * p为空间。（2）-- const修饰*p，表示指针的值可以改变，但是地址所指向的空间的值不可以改变。（3）-- const修饰*p，表示指针的值可以改变，但是地址所指向的空间的值不可以改变。（1）-- const修饰p，表示指针的值不能改变，但是地址所指向的空间的值可以改变。
C语言程序设计：从入门到精通（第二版）
书中内容覆盖C语言的基础到高级主题，如指针、链表和算法，同时也涉及程序设计的基本原则。作者鼓励读者通过动手实践来增强理解，并提供QQ群和邮箱联系方式以解答疑问和接收反馈。第二版在第一版基础上进行了完善，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

迂者-贺利坚

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

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

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

打赏作者

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

抵扣说明：

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

余额充值