精华内容
下载资源
问答
  • 编写C语言程序7个步骤编程机制 C语言基础-第一个C程序 C语言基础-简单程序分析 VS2019编写简单C程序示例 简单示例,VS2019调试C语言程序 C语言基础-基本算法 C语言基础-数据类型 C语言中输入输出函数 C语言...

    C语言文章更新目录

    C/C++学习资源(百度云盘链接)
    计算机二级资料(过级专用)
    C语言学习路线(从入门到实战)
    编写C语言程序的7个步骤和编程机制
    C语言基础-第一个C程序
    C语言基础-简单程序分析
    VS2019编写简单的C程序示例
    简单示例,VS2019调试C语言程序
    C语言基础-基本算法
    C语言基础-数据类型
    C语言中的输入输出函数
    C语言流程控制语句
    C语言数组——一维数组
    C语言数组——二维数组
    C语言数组——字符数组
    C语言中常用的6个字符串处理函数
    精心收集了60个C语言项目源码,分享给大家
    C语言核心技术——函数
    C代码是怎样跑起来的?
    C语言实现字符串的加密和解密
    C语言——文件的基本操作

    今天来介绍一下C语言中常见的一种数据结构——链表

    如下是链表的结构示意图:

    image.png

    在链表中有一个头指针变量,图中head表示的就是头指针,这个指针变量保存一个地址。也就是说头指针指向一个变量,这个变量就是量表的元素。在链表中每一个元素包括数据部分和指针部分。数据部分用来存放元素所包含的数据,而指针部分用来指向下一个元素。最后一个元素的指针指向null,表示指向的地址为空。

    从示意图中我们可以看到,head头结点指向第一个元素,第一个元素的指针指向第二个元素,第二个元素的指针又指向第三个元素,第三个元素的指针指向null。这样我们就可以通过头指针寻找链表中的元素。

    下来我们通过一个具体的实例来深入地了解一下链表,编写一个学生信息的链表结构,并且将链表中的信息进行输出。

    #define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    #include<stdlib.h>
    
    struct Student
    {
        char name[20];//姓名
        int id;//学号
        struct Student* next;//指向下一个节点的指针
    };
    
    int count;//表示链表长度
    
    struct Student* create()
    {
        struct Student* head = NULL;//初始化链表的头指针
        struct Student* end, * new;
        count = 0;//初始化链表长度
    
        end = new = (struct Student*)malloc(sizeof(struct Student));//动态分配内存空间
        printf("请输入姓名,学号\n");
        scanf("%s", &new->name);
        scanf("%d", &new->id);
        while (new->id != 0)
        {
            count++;
            if (count == 1)
            {
                new->next = head;//使得指向为空
                end = new;//跟踪新加入的节点
                head = new;//头指针指向首节点
            }
            else
            {
                new->next = NULL;//新节点的指向为空
                end->next = new;//原来的为节点指向新节点
                end = new;//end指向新节点
            }
    
            new = (struct Student*)malloc(sizeof(struct Student));//再次动态分配节点的内存空间
            scanf("%s", &new->name);
            scanf("%d", &new->id);
    
        }
        free(new);//释放空间
        return head;
    };
    
    void show(struct Student* head) {
        struct Student *temp;
        int index = 1;
        printf("有%d位学生:\n",count);
        temp = head;
        while (temp != NULL)
        {
            printf("第 %d 位学生的姓名是:%s,学号是:%d \n", index, temp->name, temp->id);
            temp = temp->next;
            index++;
        }
    }
    
    int main() {
        struct Student* head;//定义头结点
        head = create();//创建节点
        show(head);//输出链表
        return 0;
    }
    

    运行结果

    image.png

    如果您觉得本篇文章对您有帮助,请转发给更多的人
    C语言中文社区】是一个C语言/C++视频教程、学习笔记、电子书、计算机二级资料等专注于C语言/C++编程学习者的干货知识分享平台,精选深度文章,分享优秀干货类、技能类的学习资源,帮助学习中的你。
    在这里插入图片描述

    展开全文
  • /*-------------------------------------------------------------------------...创建、插入、删除、打印输出学生信息包括姓名分数 本链表是带有头结点,头结点内容为空内容 -------------------------------
    <strong>初学数据结构,学的链表</strong>
    /*-----------------------------------------------------------------------------
    时间:2011年9月28日
    文件功能:实现了动态建立一个学生信息的链表包括链表的
    创建、插入、删除、和打印输出学生信息包括姓名和分数
    本链表是带有头结点的,头结点的内容为空内容
    -----------------------------------------------------------------------------*/
    /*-------------------------包含头文件------------------------------------*/
    #include<stdio.h>
    #include<stdafx.h>
    #include<stdlib.h>
    #include<malloc.h>
    #include<string.h>
    
    /*-------------------------结构体定义部分------------------------------*/
    struct Node
    {
     char name[10];
     int score;
     struct Node *next;
    };
    
    typedef struct Node ListNode;
    /*----------------------------函数声明部分------------------------------*/
    
    
    /*---------------------------函数实现部分-------------------------------*/
    /*-----------------------------创建链表---------------------------------*/
    /*在链表的末端插入新的节点,建立链表*/
    ListNode *CreateList(int n)
    {
     ListNode *head;//指向头结点指针
     ListNode *p,*pre;
     int i;
     head=(ListNode *)malloc(sizeof(ListNode));//为头节点分配内存空间
     head->next=NULL;//将头结点的指针域清空
     pre=head;//先将头结点首地址赋给中间变量pre
     for(i=1;i<=n;i++)//通过for循环不断加入新的结点
      {
       printf("input name of the %d student:",i);//打印出第几个人的名字
       p=(ListNode *)malloc(sizeof(ListNode));//为要插入的节点分配
       //内存空间p指向新插入结点的首地址
       scanf("%s",&p->name);//输入姓名
       printf("input score of the %d student:",i);
       scanf("%d",&p->score);//输入分数
       pre->next=p;//将p指向新结点插入链表也就是头结点指针域指向
       //下个结点
       //第一个结点就是p指向的,因为头结点内容为空
       pre=p;//这个起着指向下一个结点的作用
      }
     p->next=NULL;//最后将最后一个结点的指针域清空了
     return head;//返回这个链表的首地址
    }
    /*-------------------------输出链表-----------------------------------*/
    void PrintList(ListNode *h)
    {
     ListNode *p;
     p=h->next;
     while(p)
      {
       printf("%s,%d",p->name,p->score);
       p=p->next;
       printf("\n");
      }
    }
    /*----------------------插入链表结点--------------------------*/
    /*--------------------------------------------------------------------
    函数名称:InsertList(ListNode *h,int i,char name[],int e,int n)
    函数功能:插入链表结点
    入口参数: h: 头结点地址 i:插入到第几个结点 name:插入
    结点的姓名 e:插入结点的分数 n:
    链表中结点的个数
    除下头结点外的个数
    
    出口参数:
    --------------------------------------------------------------------*/
    void InsertList(ListNode *h,int i,char name[],int e,int n)
    {
     ListNode *q,*p;//先定义2个指向一个结点的指针
     int j;
     if(i<1 || i>n+1)
      printf("Error! Please input again.\n");
     else
      {
       j=0;
       p=h;//将指针p指向要链表的头结点
       while(j<i-1)
        {
         p=p->next;
         j++;
        }
       q=(ListNode *)malloc(sizeof(ListNode));/*为要插入的
       结点分配内存空间*/
        
       //----赋值操作--------- 
       strcpy(q->name,name); //将名字拷到要插入的节点内
       q->score=e; //将要插入的节点中分数赋值
    
       //调整指针域
       
       q->next = p->next; /*这个是将新插入的结点指针域指向
       上一个结点指针域指向的结点地址即为p->next*/
        
       p->next=q;/*将要插入结点位置前面的结点指针域
       指向现在插入的结点首地址*/
      }
    }
    
    /*--------------------------------------------------------------------
    函数名称:DeleteList(ListNode *h, int i, int n)
    函数功能:删除链表结点
    入口参数: h: 头结点地址 i:要删除的结点所在位置
    n:
    链表中结点的个数除下头结点外的个数
    
    出口参数:
    --------------------------------------------------------------------*/
    void DeleteList(ListNode *h, int i, int n)
    {
     ListNode *p,*q;//首先定义2个指向结点型结构体的指针
     int j;
     char name[10];
     int score;
     if(i<1 || i>n)//如果位置超出了1和n的范围的话则打印出错误信息
      printf("Error! Please input again.\n");
     else//没有超出除头结点外的1到n 的范围的话那么执行删除操作
      {
       j=0;
       p=h;//将指针指向链表的头结点首地址
       while(j<i-1)
        {
         p=p->next;
         j++;
        }
       q=p->next; /*q指向要删除的位置之前的那个结点指针域指向的
       地址q指向的结点就是要删除的结点*/
        
       p->next=q->next;/*这个就是将要删除的结点的前面那个结点
       的指针域指向要删除的结点指针域中存放的下个结点的
       首地址从而实现了删除第i个结点的作用*/
    
       strcpy(name,q->name);
       score=q->score;
       
       free(q);//释放q指向的结点
       printf("name=%s,score=%d\n",name,score);
      }
    }
    
    /*--------------------------主函数-------------------------------*/
    void main()
    {
     ListNode *h;//h指向结构体NODE
     int i = 1, n, score;
     char name [10];
    
     while ( i )
      {
       /*输入提示信息*/
       printf("1--建立新的链表\n");
       printf("2--添加元素\n");
       printf("3--删除元素\n");
       printf("4--输出当前表中的元素\n");
       printf("0--退出\n");
    
       scanf("%d",&i);
       switch(i)
        {
         case 1:
          printf("n=");   /*输入创建链表结点的个数*/
          scanf("%d",&n);
          h=CreateList(n);/*创建链表*/
          printf("list elements is : \n");
          PrintList(h);
          break;
    
         case 2:
          printf("input the position. of insert element:");
          scanf("%d",&i);
          printf("input name of the student:");
          scanf("%s",name);
          printf("input score of the student:");
          scanf("%d",&score);
          InsertList(h,i,name,score,n);
          printf("list elements is:\n");
          PrintList(h);
          break;
    
         case 3:
          printf("input the position of delete element:");
          scanf("%d",&i);
          DeleteList(h,i,n);
          printf("list elements in : \n");
          PrintList(h);
          break;
    
         case 4:
          printf("list element is : \n");
          PrintList(h);
          break;
         case 0:
          return;
          break;
         default:
          printf("ERROR!Try again!\n");
        }
      }
    }
    


    展开全文
  • 一:C++简单学生信息链表的创建和输出——要求所创建的链表的头结点存储链表的结点数,其它结点存储各学生信息 代码实现 运行结果 二:C++设计规定函数完成学生链表的升序、插入结点、按学号查找、按姓名模糊...

    文章目录:

    一:C++简单学生信息链表的创建和输出——要求所创建的链表的头结点存储链表的结点数,其它结点存储各学生信息

    方法一 

    代码实现

    运行结果

     方法二

    代码实现

    运行结果

    二:C++设计规定函数完成学生链表的升序、插入结点、按学号查找、按姓名模糊查找、按学号删除信息、链表的输出、链表的销毁

    代码实现

    运行结果

    三:C++创建两个存储整数的有序线性表例如LA=(1,3,5,8,10,13)和LB=(4,6,8,11,12,15,20,25),然后将LA和LB归并到新的有序线性表LC=(1,3,4,5,8,10,11,12,13,15,20,25)(相同元素只出现一次,要求使用单向链表)

    算法思想

    方法一:

    代码实现

    运行结果

    方法二:结构体控制台手动输入 

    代码实现

    运行结果

    方法三:结构体随机生成

    代码实现

    运行结果

    方法四:代码中手动添加

    代码实现

    运行结果

    四:C++编程实现两个一元n次多项式的和。要求使用单向链表存储多项式(按指数升序)

    算法思想

    代码实现

    运行结果


    一:C++简单学生信息链表的创建和输出——要求所创建的链表的头结点存储链表的结点数,其它结点存储各学生信息

    方法一 

    代码实现

    #include<iostream>
    using namespace std;
     
    //性别
    enum enumsex
    {
    	male,female
    };
    
    //创建结构体
    typedef struct student 
    { 
    	union
    	{
    	 int nodenum;//记录链接表节点数
    
    	 struct//学生数据信息结构体
    	 {
    		int  id;				// 学号
    		char name[20];			//姓名
    		float score;            // 成绩
    		enumsex sex;			//性别
    	 };	
    	};
    	 struct student *next;      // 指向下一个结构体变量的指针
    }student;
    
    
    //开始创建链表
    student *CreateList(int Head) 
    {  
     student *p,*q,*head;
     int inputsex;//输入性别辅助变量
    
     head = p = new(student);
     head->nodenum=0;//节点数为0
    
     for(int i = 0;i < Head;i++) 
     {
      q = new(student);
    	  cout << "请输入第" << i + 1 << "个学生的学号 : ";
    			cin >> q->id;
    	  cout << "请输入第" << i + 1 << "个学生的姓名 : ";
    			cin >> q->name;
    	  cout<<"请输入第" << i + 1 << "个学生的性别(1为女,2为男)!"<<endl;
    			cin>>inputsex;
    			if(inputsex==1)
    			{
    				q->sex=female;
    			}else
    			{
    				q->sex=male;
    			}
    
    	  cout << "请输入第" << i + 1 << "个学生的成绩 : ";
    			cin >> q->score;
    			cout<<endl;
    
    	  p->next = q;
    	  p = q;
    		 head->nodenum+=1;
    	  p->next = NULL;
     }
    
    
    	  return head;
    }
    
    
    //输出链表
    void PrintList(student *Head) 
    {
     student *p = Head->next;
     cout<<"你导入学生信息如下:"<<endl;
    	 for(; p != NULL; p = p->next)
    	 {
    		cout<<"学号为:"<<p->id<<'\t';
    
    		cout<<"姓名为:"<<p->name<<'\t';
    
    		if(p->sex==female)
    				cout<<"性别:"<<"女"<<"\t";
    		else
    				cout<<"性别:"<<"男"<<"\t";
    
    		cout<<"成绩为:"<<p->score<<'\n';
    	}
    }
    
    
    //释放内存
    void destroy(student *head)
    {
    	 student *p = head,*q;
    		 while(p) 
    		 {
    			  q = p;
    			  p = q->next;
    			  delete q;
    		 }
    }
    
    int main() 
    {    
    	int renshu;
    	cout<<"请输入你录入的人数:";
    	cin>>renshu;
    
    	cout<<"现在开始录入信息,请录入当前学生信息!"<<endl<<endl;
         student *head = CreateList(renshu);  // 创建
    
    	 cout<<endl<<"亲!~~~~恭喜你录入数据成功,该链表共有"<<head->nodenum<<"条记录!"<<endl<<endl;
         PrintList(head);        // 输出
         destroy(head);          // 释放
    
    	 system("pause");
    	return 0;
    }

    运行结果

     方法二

    代码实现

    #include <iostream>
    using namespace std;
    
    enum enumsex{
    	male,female
    };
    
    typedef struct student
    {
    	union{
    		int nodenum;//记录链接表节点数
    		struct{//学生数据信息结构体
    			unsigned ID;//学号
    			char name[16];//姓名
    			enumsex sex;//性别
    			float score;//成绩
    		};
    	};
    	struct student *next;
    }StuNode;
    
    //创建链表
    StuNode *CreateList(StuNode *Head){
    	StuNode *pnew,*paid;//链表创建辅助指针
    	int inputsex;//输入性别辅助变量
    	if(Head==NULL){
    		Head=new StuNode;
    		Head->nodenum=0;
    		Head->next=NULL;
    	}
    	paid=Head;
    	for(;;){
    		pnew=new StuNode;
    		cout<<"请输入学号:";
    		cin>>pnew->ID;
    		if(!pnew->ID){
    			return Head;
    		}
    		cout<<"请输入姓名:";
    		cin>>pnew->name;
    		cout<<"请输入性别(1为女,2为男):";
    		cin>>inputsex;
    		if(inputsex==1){
    			pnew->sex=female;
    		}else{
    			pnew->sex=male;
    		}
    		cout<<"请输入成绩:";
    		cin>>pnew->score;
    		cout<<endl;
    
    		pnew->next=NULL;
    		paid->next=pnew;
    		paid=pnew;
    
    		Head->nodenum+=1;
    		
    	}
    	return Head;
    }
    
    //输出链表
    void PrintList(StuNode *Head){
    	//如果链表为空
    	if(Head==NULL)
    		return;
    	//输出链表总结点数
    	cout<<"该链表存有"<<Head->nodenum<<"条记录"<<endl;
    	//遍历链表,输出所有学生信息
    	StuNode *pt;
    	pt=Head->next;
    	cout<<"学生信息为:"<<endl;
    	cout<<"学号"<<"\t"<<"姓名"<<"\t"<<"性别"<<"\t"<<"成绩"<<endl;
    	while(pt){
    		cout<<pt->ID<<"\t"<<pt->name<<"\t";
    		if(pt->sex==female)
    		cout<<"女"<<"\t";
    		else
    		cout<<"男"<<"\t";
    		cout<<pt->score<<endl;
    		pt=pt->next;
    	}
    }
    
    int main()
    {
    	cout<<"温馨提示,姓名按0建结束!"<<endl<<endl;
    	StuNode *Head=NULL;
    	Head=CreateList(Head);
    	PrintList(Head);
    
    	system("pause");
    	return 0;
    }
    

    运行结果

    二:C++设计规定函数完成学生链表的升序、插入结点、按学号查找、按姓名模糊查找、按学号删除信息、链表的输出、链表的销毁

    学生信息链表的功能扩展——设计程序,要求设计的函数:
    
        按学号升序创建链表的函数、
        插入新结点的函数、
        按学号查找学生的函数、
        按姓名查找学生的函数(注意:姓名的查找要做到模糊查找,例如查找”张”,则能输出所有名字中含有“张”的学生信息)、
        删除指定学号学生信息的函数、
        完整链表的输出函数、
        链表的销毁函数等

    代码实现

    #include <iostream>
    using namespace std;
    
    enum enumsex{
    	male,female
    };
    
    typedef struct student
    {
    	union{
    		int nodenum;//记录链接表节点数
    		struct{//学生数据信息结构体
    			unsigned ID;//学号
    			char name[16];//姓名
    			enumsex sex;//性别
    			float score;//成绩
    		};
    	};
    	struct student *next;
    }StuNode;
    
    
    //插入结点
    struct student *insert(student *head,student *s)
    {
    	struct student *p=head;
    	while(p->next!=NULL && s->score>p->next->score)//特别注意&&左右不能写反,若s最大,最后p->next=NULL,p->next->score运行出错
    	p=p->next;
    
    		if(p->next==NULL) //s->score最大的情况 //其实两种情况可以并在一块写
    		{
    			p->next=s; //连接结点
    			cout<<"抱歉,插入失败!"<<endl;
    			s->next=NULL; //p->next就等于NULL
    		}
    		else
    		{
    			p->next=s; //连接结点
    			s->next=p->next;
    			cout<<"恭喜你插入成功!"<<endl;
    		}
    	return head ;
    }
    
    
    //创建链表
    //按学号升序创建链表的函数
    StuNode *CreateList(StuNode *Head){
    	StuNode *pnew,*paid;//链表创建辅助指针
    	int inputsex;//输入性别辅助变量
    	if(Head==NULL){
    		Head=new StuNode;
    		Head->nodenum=0;
    		Head->next=NULL;
    	}
    	paid=Head;
    	for(;;){
    		pnew=new StuNode;
    		cout<<"请输入学号:";
    		cin>>pnew->ID;
    		if(!pnew->ID){
    			return Head;
    		}
    		cout<<"请输入姓名:";
    		cin>>pnew->name;
    		cout<<"请输入性别(1为女,2为男):";
    		cin>>inputsex;
    		if(inputsex==1){
    			pnew->sex=female;
    		}else{
    			pnew->sex=male;
    		}
    		cout<<"请输入成绩:";
    		cin>>pnew->score;
    		cout<<endl;
    		
    		pnew->next=NULL;
    		paid->next=pnew;
    		paid=pnew;
    
    		Head->nodenum+=1;
    		//Head=insert(Head,pnew);
    		/*	while(paid->next&&paid->ID)
    			{
    				pnew=paid;
    				paid=paid->next;
    			}
    			if(paid->ID)
    			{
    				paid->next=Head;
    				Head->next=0;
    			}
    			else
    			{
    				Head->next=paid;
    				pnew->next=Head;
    			}*/ 
    
    		//最小选择排序
    		//for(pnew = paid->next ; pnew->next != NULL ; pnew = pnew->next)
    		//{
    		//	for(paid = pnew->next ; paid != NULL ; paid = paid->next)
    		//	{
    		//		if(pnew->ID > paid->ID)
    		//		{
    		//			int temp;
    		//			temp = pnew->ID;
    		//			pnew->ID = paid->ID;
    		//			paid->ID = temp;
    		//		}
    		//	}
    		//}
    	}
    	return Head;
    }
    
    //输出链表
    void PrintList(StuNode *Head){
    	//如果链表为空
    	if(Head==NULL)
    		return;
    	//输出链表总结点数
    	cout<<"该链表存有"<<Head->nodenum<<"条记录"<<endl;
    	//遍历链表,输出所有学生信息
    	StuNode *pt;
    	pt=Head->next;
    	cout<<"学生信息为:"<<endl;
    	cout<<"学号"<<"\t"<<"姓名"<<"\t"<<"性别"<<"\t"<<"成绩"<<endl;
    	while(pt){
    		cout<<pt->ID<<"\t"<<pt->name<<"\t";
    		if(pt->sex==female)
    		cout<<"女"<<"\t";
    		else
    		cout<<"男"<<"\t";
    		cout<<pt->score<<endl;
    		pt=pt->next;
    	}
    }
    
    //按照学号查找
    struct student *searchID (student *Head)
    {
    	struct student *p=Head->next;
    	int num;
    	cout<<"请输入要查找的学号:";
    	cin>>num;
    	while(p!=NULL&&p->ID!=num)
    	{
    		p=p->next;
    	}
    	if(p==NULL) 
    	{
    		cout<<"找不到符合条件的结点!"<<endl;
    		return NULL; //查找不到返回空指针
    	}
    	if(p->ID==num)
    	{
    		cout<<"找到符合条件的结点!该结点为:"<<"学号:"<<p->ID<<"  "<<
    			"姓名:"<<p->name<<"  "
    			<<"性别:"<<p->sex<<"  "
    			<<"成绩:"<<p->score<<endl;
    		return p; //返回查找到的指针
    	}
    }
    
    //按照姓名查找
    struct student *searchname (student *Head)
    {
    	struct student *p1=Head->next;
    	char name[10];
    	cout<<"请输入要查找姓名:";
    	cin>>name;
    	while(p1!=NULL&&p1->name!=name)
    	{
    		p1=p1->next;
    	}
    	if(p1==NULL) 
    	{
    		cout<<"找不到符合条件的结点!"<<endl;
    		return NULL; //查找不到返回空指针
    	}
    	if(p1->name==name)
    	{
    		cout<<"找到符合条件的结点!该结点为:"<<"学号:"<<p1->ID<<"  "<<
    			"姓名:"<<p1->name<<"  "
    			<<"性别:"<<p1->sex<<"  "
    			<<"成绩:"<<p1->score<<endl;
    		return p1; //返回查找到的指针
    	}
    }
    
    
    //删除结点
    struct student *delete_ID(student *head,int num_x)
    {
    	struct student *p1=head->next,*p2=head;
    	while(p1!=NULL&&p1->ID!=num_x) //特别注意&&左右条件不能调换,若调换如果p1指向NULL时p1->num运行出错
    	{
    		p2=p1;
    		p1=p1->next;
    	}
    	if(p1==NULL) //特别注意两个if不能调换,若调换如果p1指向NULL时,p1->num运行出错
    			cout<<"找不到符合删除要求的结点!"<<endl;
    		if(p1->ID==num_x)
    			{
    			p2->next=p1->next;
    			free(p1);
    			cout<<"结点删除成功!"<<endl;
    		}
    	return head;
    }
    
    //销毁链表
    StuNode *DestroyList(StuNode *Head)
    {	StuNode *pt;
    	do
    	{	pt=Head;
    		Head=Head->next;
    		delete pt;
    	}while(Head);
    	cout<<"销毁链表成功!"<<endl<<endl;
    	return Head;
    }
    
    //排序
    void sort(student *head)
    {
    	StuNode *p,*s;//链表创建辅助指针
    	student *m=head;
    
    	if(head->next==NULL || head->next->next==NULL)
    	{
    		cout<<"链表排序完成!"<<endl<<endl;
    		return;
    	}
    
    	student *p=head->next;
    	student *s=p->next;
    	student *k=NULL;
    while(k != head->next->next)
    {
    	while(s!=k)
    	{
    		if(p->ID&&s->ID> 0)
    		{
    			p->next=s->next;     
    			s->next=p;
    			m->next=s;
    			m=s;
    			s=p->next;
    		}
    		else
    		{
    			m=p;
    			p=s;
    			s=s->next;
    		}
    	}
    
    	k=p;
    	m=head;
    	p=m->next;
    	s=p->next;
    	}
    cout<<"链表排序完成!"<<endl<<endl;
    }
    
    
    int main()
    {
    	int id;//学号
    	int num;//姓名
    	int Sex;//性别
    	float score;//成绩
    	struct student *p;
    
    	cout<<"温馨提示,姓名按0建结束!"<<endl<<endl;
    	StuNode *Head=NULL;
    	Head=CreateList(Head);
    	PrintList(Head);
    
    	//searchID(Head);
    	//searchname(Head);
    
    	/*cout<<"请输入你要删除的学号:"<<endl;
    	cin>>num;
    	delete_ID(Head,num)*/;
    
    	//给p赋值
    	//cout<<"请输入你要插入的学号:";
    	//cin>>id;
    	//cout<<"请输入你要插入的姓名:";
    	//cin>>num;
    	//cout<<"请输入你要插入的性别:";
    	//cin>>Sex;
    	//cout<<"请输入你要插入的成绩:";
    	//cin>>score;
    	//p=(struct student*)malloc( sizeof(struct student) );
    	//if(p==NULL)
    	//{
    	//	cout<<"申请该结点失败!"<<endl;
    	//	exit (0) ;
    	//}
    	///*p->ID=id;
    	//p->score=score; 
    	//p->name=num;
    	//p->sex=Sex;*/
    	//insert(Head,p);
    
    	cout<<"开始销毁链表:"<<endl;
    	DestroyList(Head);
    	system("pause");
    	return 0;
    }
    

    可参考

    #include <iostream>
    #include <cstring>
    
    using namespace std;
    
    typedef struct student {
        unsigned ID;
        char name[16];
        float score;
        struct student *next;
    } StuNode;
    
    StuNode *CreateList(StuNode *Head) {
        StuNode *pnew, *pend, *ps, *pe;
        cout << "开始创建学生链表,输入学号为0或负则停止:" << endl;
        for (;;) {
            //创建新结点
            pnew = new StuNode;
            pnew->next = NULL;
    
            //输入新结点学号
            cout << "请输入学生学号" << endl;
            cin >> pnew->ID;
    
            //如果学号==0则终止
            if (pnew->ID == 0) {
                break;
            }
    
            //输出新结点姓名和成绩
            cout << "请输入学生姓名" << endl;
            cin >> pnew->name;
    
            cout << "请输入学生成绩" << endl;
            cin >> pnew->score;
    
            //如果当前链表为空,新结点如何处理?
            if (Head == NULL) {
                Head = pnew;
                pend = pnew;
            } else {
                //如果新结点学号<头结点学号,如何处理?
                if (pnew->ID < Head->ID) {
                    pnew->next = Head;
                    Head = pnew;
                } else
                    //否则如果新结点学号>尾结点学号,如何处理?
    
                if (pnew->ID>pend->ID) {
                    pend->next = pnew;
                    pend = pnew;
                } else
                    //否则(新结点学号介于首尾结点之间)
                {
                    ps = Head;
                    pe = ps->next;
                    //操作见后面的示意图
                    while (true) {
                        if (ps->ID <= pnew->ID && pe->ID >= pnew->ID) {
                            ps->next = pnew;
                            pnew->next = pe;
    
                            break;
                        }
                        ps = pe;
                        pe = ps->next;
                    }
                }
            }
        }
        return Head;
    }
    
    void PrintList(StuNode *Head) {    //如果链表为空,如何处理?
        if (Head == NULL) {
            cout << "空链表" << endl;
            return;
        }
        StuNode *ptemp;
        ptemp = Head;
        cout << "学号\t姓名\t成绩" << endl;
        while (ptemp != NULL) {
            cout << ptemp->ID << "\t";
            cout << ptemp->name << "\t";
            cout << ptemp->score << "\t" << endl;
            ptemp = ptemp->next;
        }
    }
    
    StuNode *InsertList(StuNode *Head) {
        //如果现有链表为空链表,询问是否创建
        //是则调用CreateList( )函数,否则返回
        if (Head == NULL) {
            unsigned i = 0;
            cout << "当前链表为空,是否创建链表,输入1创建、0返回" << endl;
            cin >> i;
            if (i == 0) {
                return Head;
            }
            return CreateList(Head);
        }
        //如果当前链表非空,操作与CreateList( )函数类似
        StuNode *pnew, *pend, *ps, *pe;
        //创建新结点
        pnew = new StuNode;
        pnew->next = NULL;
    
        //输入新结点学号
        cout << "请输入学生学号" << endl;
        cin >> pnew->ID;
    
        //如果学号==0则退出增加
        if (pnew->ID == 0) {
            return Head;
        }
    
        //输出新结点姓名和成绩
        cout << "请输入学生姓名" << endl;
        cin >> pnew->name;
    
        cout << "请输入学生成绩" << endl;
        cin >> pnew->score;
    
        pnew->next = NULL;
    
        pend = Head;
        while (pend->next != NULL) {
            pend = pend->next;
        }
    
        //如果新结点学号<头结点学号,如何处理?
        if (pnew->ID < Head->ID) {
            pnew->next = Head;
            Head = pnew;
        } else if (pnew->ID > pend->ID) {
            //否则如果新结点学号>尾结点学号,如何处理?
            pend->next = pnew;
        } else {
            //否则(新结点学号介于首尾结点之间)
            ps = Head;
            pe = ps->next;
            //操作见后面的示意图
            while (true) {
                if (ps->ID <= pnew->ID && pe->ID >= pnew->ID) {
                    ps->next = pnew;
                    pnew->next = pe;
                    break;
                }
                ps = pe;
                pe = ps->next;
            }
        }
        return Head;
    }
    
    StuNode *DeleteID(StuNode *Head) {    //如果链表为空,如何处理?
        if (Head == NULL) {
            cout << "链表为空" << endl;
            return Head;
        }
        StuNode *p, *temp;
        int delID;
        //输入要删除的学号delID
        cout << "输入要删除学生的学号" << endl;
        cin >> delID;
        temp = Head;
        //当temp->ID!=delID与temp->next!=NULL时
        while (temp->ID != delID && temp->next != NULL) {
            p = temp;
            temp = temp->next;
        }
        if (temp->ID == delID) {
            if (temp == Head) {
                //(1)待删除结点是头结点,如何处理?temp==Head
                Head = temp->next;
            } else if (temp->next == NULL) 
    		{
                //(2)待删除结点是尾结点,如何处理?temp->next==NULL
                p->next = NULL;
            } else {
                //(3)等删除结点是中间结点,如何处理?
                p->next = temp->next;
            }
            delete temp;
        } else {
            //否则说明链表中不存在delID这个学号的结点,如何处理?
            cout << "学号 " << delID << " 的学生不存在于链表之中" << endl;
        }
        return Head;
    }
    
    void SearchNum(StuNode *Head) {
        if (Head == NULL) {
            cout << "链表为空" << endl;
            return;
        }
    
        unsigned num = 0;
        cout << "请输入需要查找学生的学号" << endl;
        cin >> num;
    
        StuNode *temp = Head;
        StuNode *Stu = NULL;
    
        while (temp != NULL) {
            if (temp->ID == num) {
                Stu = temp;
                break;
            }
            temp = temp->next;
        }
        if (Stu != NULL) {
            cout << "学号\t姓名\t成绩" << endl;
            cout << Stu->ID << "\t";
            cout << Stu->name << "\t";
            cout << Stu->score << "\t" << endl;
        } else {
            cout << "未找到学号为" << num << "的学生" << endl;
        }
    }
    
    void SearchName(StuNode *Head) {
        if (Head == NULL) {
            cout << "链表为空" << endl;
            return;
        }
    
        char name[16];
        cout << "请输入需要查找学生的姓名" << endl;
        cin >> name;
    
        StuNode *temp = Head;
    
        bool isHas = false;
    
    
        while (temp != NULL) {
            string s = temp->name;
            if (s.find(name, 0) != string::npos) {
                isHas = true;
                cout << "学号\t姓名\t成绩" << endl;
                cout << temp->ID << "\t";
                cout << temp->name << "\t";
                cout << temp->score << "\t" << endl;
            }
    
            temp = temp->next;
        }
        if (!isHas) {
            cout << "链表中未找到学生信息" << endl;
        }
    
    }
    
    StuNode *DestroyList(StuNode *Head) {
        StuNode *temp;
        while (Head != NULL) {
            temp = Head->next;
            Head = NULL;
            Head = temp;
        }
        return Head;
    }
    
    
    void StatisticsFractionCount(StuNode *Head) {
        if (Head == NULL) {
            cout << "链表为空" << endl;
            return;
        }
        unsigned int gradeA = 0;
        unsigned int gradeB = 0;
        unsigned int gradeC = 0;
        unsigned int gradeD = 0;
        unsigned int gradeE = 0;
        StuNode *temp = Head;
        while (temp != NULL) {
    
            if(temp->score >= 90){
                gradeA++;
            } else if(temp->score < 90 && temp->score >= 80){
                gradeB++;
            }else if(temp->score < 80 && temp->score >= 70){
                gradeC++;
            }else if(temp->score < 70 && temp->score >= 60){
                gradeD++;
            }else if(temp->score < 60){
                gradeE++;
            }
            temp = temp->next;
        }
    
        cout<<"成绩在100-90的学生人数为:"<<gradeA<<endl;
        cout<<"成绩在89-80的学生人数为:"<<gradeB<<endl;
        cout<<"成绩在79-70的学生人数为:"<<gradeC<<endl;
        cout<<"成绩在69-60的学生人数为:"<<gradeD<<endl;
        cout<<"成绩在60以下的学生人数为:"<<gradeE<<endl;
    
    }
    
    
    void PrintMaxAndMinScoreStudentInfo(StuNode *Head) {
        if (Head == NULL) {
            cout << "链表为空" << endl;
            return;
        }
        StuNode *max, *min, *temp;
        max = min = Head;
        temp = Head->next;
    
        while (temp != NULL) {
            if (max->score < temp->score) {
                max = temp;
            } else if (min->score > temp->score) {
                min = temp;
            }
            temp = temp->next;
        }
    
        cout << "最高成绩学生信息" << endl;
        cout << "学号\t姓名\t成绩" << endl;
        cout << max->ID << "\t";
        cout << max->name << "\t";
        cout << max->score << "\t" << endl;
        cout << "最低成绩学生信息" << endl;
        cout << "学号\t姓名\t成绩" << endl;
        cout << min->ID << "\t";
        cout << min->name << "\t";
        cout << min->score << "\t" << endl;
    }
    
    
    void PrintAvgScore(StuNode *Head) {
        if (Head == NULL) {
            cout << "链表为空" << endl;
            return;
        }
        double allScore = 0;
        unsigned int stuCount = 0;
        StuNode *temp = Head;
        while (temp != NULL) {
            stuCount++;
            allScore += temp->score;
            temp = temp->next;
        }
        double avg = allScore / (stuCount * 1.0);
        cout << "平均成绩为:" << avg << endl;
    
    }
    
    
    int main() {
    
        unsigned op = 0;
        StuNode *Head = NULL;
    
        bool flag = true;
    
        while (flag) {
            cout << "1.初始化创建链表\t2.增加学生" << endl;
            cout << "3.按学号查找\t4.按姓名查找" << endl;
            cout << "5.按学号删除学生\t6.打印链表信息" << endl;
            cout << "7.统计各分数段学生人数\t8.输出最低成绩信息和最高成绩信息" << endl;
            cout << "9.输出平均成绩信息\t10.销毁链表" << endl;
            cout << "11.退出" << endl;
            cout << "输入相应命令进行操作:";
            cin >> op;
    
            switch (op) {
                case 1:
                    Head = CreateList(Head);
                    break;
                case 2:
                    Head = InsertList(Head);
                    break;
                case 3:
                    SearchNum(Head);
                    break;
                case 4:
                    SearchName(Head);
                    break;
                case 5:
                    Head = DeleteID(Head);
                    break;
                case 6:
                    PrintList(Head);
                    break;
                case 7:
                    StatisticsFractionCount(Head);
                    break;
                case 8:
                    PrintMaxAndMinScoreStudentInfo(Head);
                    break;
                case 9:
                    PrintAvgScore(Head);
                    break;
                case 10:
                    Head = DestroyList(Head);
                    break;
                case 11:
                    flag = false;
                    break;
                default:
                    flag = false;
                    break;
            }
        }
    
    
        system("pause");
        return 0;
    }
    

    运行结果

    三:C++创建两个存储整数的有序线性表例如LA=(1,3,5,8,10,13)和LB=(4,6,8,11,12,15,20,25),然后将LA和LB归并到新的有序线性表LC=(1,3,4,5,8,10,11,12,13,15,20,25)(相同元素只出现一次,要求使用单向链表)

    算法思想

    因为都是两个有序的线性表,所以不需要排序
    
       1.两个有序线性表同时开始从头开始遍历,各出一个元素进行有序比较
    
       2.把小的元素放到新线性表LC中
    
       3.重复上面操作,直到其中一个表被取完
    
       4.因为是有序的,直接把剩下那个表中没有进行比较的,放在LC的后面

    方法一:

    代码实现

    #include<iostream>
    #include<cstring>
    using namespace std;
    
    typedef struct Data
    {
    	int v;				//数据域
    	struct Data *next; //指针域
    }IntNode;
    
    //创建一个链表存放n个整数
    IntNode *CreateList(IntNode *Head,int n)//存放几个整数
    {
    	IntNode *pnew = NULL, *pend = NULL;//首先将链表清空
    	for (int i = 1; i <= n; i++)
    	{	
    		pnew = new IntNode; //申请一个新的空间
    		pnew->next = NULL; //空间的下一个结点为空
    
    		cin >> pnew->v;//输入值
    			if (Head==NULL)//如果头结点为空
    			{
    				Head = pnew;//那么就申请一个
    			}	
    			else//如果头结点不为空
    			{
    				pend->next = pnew;//继续创建
    			} 
    			pend = pnew;//直到结束
    	}
    	return Head;
    }
    
    //输出链表
    void PrintList(IntNode *Head)
    {
    	if (Head == NULL)
    		return;
    
    	IntNode *pt = Head;
    		while (pt)
    		{
    			cout << pt->v << ',';//输出值
    			pt=pt->next;//依次输出
    		}
    		cout << endl;
    }
    
    //合并链表
    IntNode *MergeList(IntNode *HeadA,IntNode *HeadB,IntNode *HeadC)
    {
    	IntNode *pnew = NULL, *pend = NULL;
    	IntNode *pa = HeadA, *pb = HeadB;
    
    	while (pa&&pb)//当HeadA和HeadB都不为空时
    	{
    		pnew = new IntNode; pnew->next = NULL;//清空
    		if (pa->v<pb->v)		 //当A<B,那么就A先放
    		{
    			pnew->v = pa->v; 
    			pa = pa->next;
    		}
    		else if (pa->v == pb->v) //当A=B,那么就任选一个,比如A先放;已经存在一个了那就下一个B其次的放
    		{
    			pnew->v = pa->v; 
    			pa = pa->next; 
    			pb = pb->next;//这里很重要,就是为了避重
    		}
    		else//当A>B,那么就B先放
    		{
    			pnew->v = pb->v; 
    			pb = pb->next;
    		}
    
    		//依次的存放
    			if (HeadC==NULL)
    			{
    				HeadC = pnew;
    			}
    			else
    			{
    				pend->next = pnew;
    			}
    			pend = pnew;
    	}
    
    	//这里如果比较到某一个已经比完了
    	while (pa)//当HeadA不为空,当HeadB为空时
    	{
    		pnew = new IntNode; 
    		pnew->next = NULL;//先清空
    
    		pnew->v = pa->v; //把A中的值传入
    		pa = pa->next;
    
    		pend->next = pnew; //到头了
    		pend = pnew;
    	}
    	while (pb)//当HeadB不为空,当HeadA为空时
    	{
    		pnew = new IntNode; 
    		pnew->next = NULL;
    
    		pnew->v = pb->v; 
    		pb = pb->next;
    		pend->next = pnew; 
    		pend = pnew;
    	}
    	return HeadC;
    }
     
    
    int main()
    {
    
    	IntNode *HeadA = NULL, *HeadB = NULL, *HeadC = NULL;
    
    	cout << "请输入第一个链表:" << endl;
    	HeadA = CreateList(HeadA, 6);//6个整数
    	PrintList(HeadA);
    	cout << "请输入第二个链表:" << endl;
    	HeadB = CreateList(HeadB, 8);//5个整数
    	PrintList(HeadB);
    
    	cout << endl <<  "合并后的链表C为:" << endl;
    	HeadC = MergeList(HeadA, HeadB, HeadC);
    	PrintList(HeadC);
     
    	 system("pause");
    	 return 0;
    }

    运行结果

    方法二:结构体控制台手动输入 

    代码实现

    #include <iostream>
    using namespace std;
    #define MAX 20
     
    //定义结构体
    typedef struct data
    {
        unsigned  num[MAX];
        int next;
    }DataNode;
    //int La[]={1,3,5,8,10,13};                //定义线性表La; 
    //int Lb[]={4,6,8,11,12,15,20,25};		   //定义线性表Lb;
    
    //创建链表
    void CreatList(DataNode *L)
    {
        int i=0,c;
        while(1)
        {
    		cin >> c;
            if(c==-8080)
                break;
            L->num[i] = c;
    		i++;
            L->next++;
        }
    }
    
    //合并链表
    DataNode MergeList(DataNode HeadLA,DataNode HeadLB,DataNode HeadLC)
    {
        int i=0,j=0,k=0;
        while(i <= HeadLA.next && j <= HeadLB.next)
        {
            /*处理本列表里的重复*/
            if (k >= 1 && HeadLC.num[k-1] == HeadLA.num[i]) {
                i++;
                continue;
            }
            /*处理本列表里的重复*/
            if (k >= 1 && HeadLC.num[k-1] == HeadLB.num[j]) {
                j++;
                continue;
            }
     
            if(HeadLA.num[i] < HeadLB.num[j])
            {
                HeadLC.num[k] = HeadLA.num[i];
                i++;
                k++;
                HeadLC.next++;
            }
            else if(HeadLA.num[i]>HeadLB.num[j])
            {
                HeadLC.num[k]=HeadLB.num[j];
                j++;
                k++;
                HeadLC.next++;
            }
            else
            {
                HeadLC.num[k] = HeadLA.num[i];
                i++;
                j++;
                k++;
                HeadLC.next++;
            }
        }
        while(i <= HeadLA.next)    
        {
            HeadLC.num[k]=HeadLA.num[i];
            i++;k++;
            HeadLC.next++;
        }
        while(j <= HeadLB.next)   
        {
            HeadLC.num[k]=HeadLB.num[j];
            j++;k++;
            HeadLC.next++;
        }
        return HeadLC;
    }
    
    //打印链表
    void PrintList(DataNode L)
    {
        int i;
        for(i=0;i < L.next;i++)
    		cout<<L.num[i]<<"  ";
    	cout<<L.num[i]<<"  ";
    }
    
    
    int main()
    {
        DataNode HeadLA,HeadLB,HeadLC;
        HeadLA.next=-1;
        HeadLB.next=-1;
        HeadLC.next=-1;
    
    	cout<<"注意,程序结尾以-8080结束!"<<endl;
        //输入LA
    	cout<<"请输入线性表LA:"<<endl;
        CreatList(&HeadLA);
        getchar();
    	cout<<endl;
    
        //输入LB
    	cout<<"请输入线性表LB:"<<endl;
        CreatList(&HeadLB);
        HeadLC=MergeList(HeadLA,HeadLB,HeadLC);
    	cout<<endl;
    
    	cout<<"将线性表LA、LB合并后的线性表LC为:";
        PrintList(HeadLC);
    	cout<<endl;
    
    	cout<<endl;
    	system("pause");
        return 0;
    }
    

    运行结果

    方法三:结构体随机生成

    代码实现

    #include <iostream>
    #include <ctime>
    #include <iomanip>
    using namespace std;
     
    //定义结构体
    typedef struct data
    {
    	unsigned  num;
    	struct data *next;
    }DataNode;
    
    // 创建结点数为n的链表,返回链表头
    DataNode *CreateList(int n)
    {
    	DataNode *Head,*p,*q;
    	Head = p = new DataNode;
    	Head->num = 0;
    	for (short i = 0; i < n; i++)
    	{
    		q = new DataNode;
    		q->num = (unsigned)rand() % n + n/2;
    		p->next = q;
    		p = q;
    	}
    	p->next = Head;
    	return Head;
    }
    
    
    //上升排序
    void RiseSort(DataNode *Head)
    {
    	DataNode *p,*s,*pt;
    	p = Head;
    	s = p->next;
    	while(p->next != Head) 
    	{
    		while(s->next != Head)
    		{
    			if(p->next->num > s->next->num) 
    			{
    				pt = p->next;
    				p->next = s->next;
    				s->next = p->next->next;
    				p->next->next = pt;
    			}else
    			{
    				s = s->next;
    			}
    		}
    		p = p->next;
    		s = p->next;
    	}
    }
    
    // 去除相同的集合元素
    void Simplification(DataNode *Head)
    {
    	DataNode *p,*q,*s;
    	p = Head->next;
    	q = p->next;
    	while(q != Head)
    	{
    		if(p->num == q->num)
    		{
    			p->next = q->next;
    			s = q;
    			q = q->next;
    			delete s;
    		}else
    		{
    			p = p->next;
    			q = q->next;
    		}
    	}
    }
    
    //创建线性表
    DataNode *CreateDataNode(int n) 
    {
    	DataNode *Head;
    	Head = CreateList(n);
    	RiseSort(Head);
    	Simplification(Head);
    	return Head;
    }
    
    //插入结点
    void InsertNode(DataNode *Head,short num) 
    {
    	DataNode *t,*p = Head;
    	while(p->next != Head)
    	{
    		if(p->next->num == num)
    		{
    			return;
    		}
    		if (p->next->num < num)
    		{
    			p = p->next;
    		}else
    		{
    			t = new DataNode;
    			t->num = num;
    			t->next = p->next;
    			p->next = t;
    			return;
    		}
    	}
    	t = new DataNode;
    	t->num = num;
    	p->next = t;
    	t->next = Head;     // 插入在链表尾的处理
    }
    
    //求一共的A∪B
    DataNode *MergeList(DataNode *A,DataNode *B)
    {
    	DataNode *Head,*pa,*pb,*pc,*qc;
    	Head = pc = new DataNode;
    	pa = A->next;
    	while(pa != A)
    	{
    		qc = new DataNode;
    		qc->num = pa->num;
    		pc->next = qc;
    		pc = qc;
    		pa = pa->next;
    	}
    	pc->next = Head;
    	pb = B->next;
    	while(pb != B)
    	{
    		InsertNode(Head,pb->num);
    		pb = pb->next;
    	}
    	return Head;
    }
    
    //求两个都有的A∩B
    DataNode *MutualDataNode(DataNode *A,DataNode *B) 
    {
    	DataNode *C,*pa,*pb,*pc,*qc;
    	C = pc = new DataNode;
    	pc->num = 0;
    	pa = A->next;
    	pb = B;
    	while(pa != A)
    	{
    		pb = B->next;
    		while(pb != B)
    		{
    			if(pb->num == pa->num)
    			{
    				qc = new DataNode;
    				qc->num = pb->num;
    				pc->next = qc;
    				pc = qc;
    			}
    			pb = pb->next;
    		}
    		pa = pa->next;
    	}
    	pc->next = C;
    	return C;
    }
    
    //打印线性表
    void PrintList(DataNode *Head)
    {
    	DataNode *p = Head->next;
    	short counter = 0;
    	while(p != Head)
    	{
    		if(counter%10 == 0)
    		{
    			cout << "\t";
    		}
    		cout<<setw(5)<< p->num;
    		counter++;
    		p = p->next;
    	}
    	cout << endl;
    }
    
    //释放头结点
    void freeheap(DataNode *Head)
    {
    	DataNode *p,*q;
    	p = Head;
    	q = p->next;
    	while(q != Head)
    	{
    		p = q;
    		q = p->next;
    		delete p;
    	}
    	free(Head);
    }
    
    
    int main()
    {
    	DataNode *A,*B,*C,*D;
    	//DataNode *A,*B,*C,*D;
    	srand(time(NULL));
    
    
    	A = CreateDataNode(6);
    	//int A[]={1,3,5,8,10,13};			//定义线性表La; 
    	cout << "线性表LA中的元素有:"<<endl;	
    	PrintList(A);
    		cout<<endl;
    
    
    
    	B = CreateDataNode(8);
    	//int B[]={4,6,8,11,12,15,20,25};		//定义线性表Lb;
    	cout<< "线性表LB中的元素有:"<<endl;	
    	PrintList(B);
    		cout<<endl;
    
    	C = MutualDataNode(A,B);
    
    	cout  << "LA、LB公共有的元素有:"<<endl ;	
    	PrintList(C);
    		cout<<endl;
    
    	cout << "将LA、LB合并后的LC元素有: "<<endl;	
    	D = MergeList(A,B);
    	PrintList(D);
    		cout<<endl;
    	
    	freeheap(A);
    	freeheap(B);
    	freeheap(C);
    	freeheap(D);
    
    	system("pause");
    	return 0;
    }

    运行结果

    方法四:代码中手动添加

    代码实现

    #include<iostream>
    using namespace std;
    #define N 30
    
    int La[]={1,3,5,8,10,13};                //定义线性表La; 
    int Lb[]={4,6,8,11,12,15,20,25};		 //定义线性表Lb;
    
    int Lc[N];                               //定义线性表Lc,此时Lc是空表; 
    int La_Len=sizeof(La)/sizeof(La[0]);     //获得线性表La的表长; 
    int Lb_Len=sizeof(Lb)/sizeof(Lb[0]);     //获得线性表Lb的表长;
    int Lc_Len=0;                            //定义线性表Lc的表长为0; 
    
    int GetElem(int a[],int n)               //获得线性表中的元素;  
    {
    	return a[n-1];                       //返回对应的数组元素值; 
    }
    
    void ListInsert(int Lc[],int x1)         //实现元素的插入操作; 
    {
    	Lc[Lc_Len]=x1;
    	Lc_Len++;                            //每插入一次,表长加1,为下次插入留下空位; 
    }
    
    void MergeList(int La[],int Lb[],int Lc[])  //功能:合并两个有序的线性表; 
    {
    	int i,j;
    	i=j=1;                                 //线性表元素的位序,不是数组下标; 
    	while((i<=La_Len)&&(j<=La_Len))        //while循环执行的条件; 
    	{
    		if(GetElem(La,i)<=GetElem(Lb,j))   //比较ai和bj大小; 
    		{
    			ListInsert(Lc,GetElem(La,i));  //实现元素的插入; 
    			i++;                           //为遍历下一个元素作准备; 
    		}
    		else
    		{
    			ListInsert(Lc,GetElem(Lb,j));
    			j++;
    		}
    	}
    	while(i<=La_Len)             //表明线性表La中还有元素,把余下的元素都插到Lc中; 
    	{
    		ListInsert(Lc,GetElem(La,i));
    		i++;
    	}
    	while(j<=Lb_Len)          //表明线性表Lb中还有元素,把余下的元素都插到Lc中;
    	{
    		ListInsert(Lc,GetElem(Lb,j));
    		j++;
    	}
    }
    
    int main()
    {
    	//int i,j,m,n,k;
    	//int La[N],Lb[N];
    	//cout <<"请输入线性表A的元素:"<<endl;
    	//cout <<"----------------------"<<endl;
    	//for(i=0;i<n*m;i++)
    	//{
    	//	cout << "请输入线性表A的第"<<i+1<<"个元素"<<endl;
    	//	cin >>La[i];
     //
    	//}
    	//cout <<"----------------------"<<endl;
    	//
    	//cout <<"请输入线性表B的元素:"<<endl;
    	//cout <<"----------------------"<<endl;
    	//for(i=0;i<n*k;i++)
    	//{
    	//	cout << "请输入线性表B的第"<<i+1<<"个元素"<<endl;
    	//	cin >>Lb[i];
    	//}
    	//cout <<"----------------------"<<endl;
    
    
    	cout<<"La中的元素:";
    	for(int r=0;r<La_Len;r++)
    	{
    		cout<<La[r]<<" ";
    	}
    	cout<<endl;
    	cout<<"Lb中的元素:";
    	for(int r1=0;r1<Lb_Len;r1++)
    	{
    		cout<<Lb[r1]<<" ";
    	}
    	cout<<endl;
    	MergeList(La,Lb,Lc);
    	cout<<"Lc中的元素:";
    	for(int i=0;i<Lc_Len;i++)
    	{
    		if (Lc[i]==Lc[i+1])
    		{
    			continue;
    		}
    		cout<<Lc[i]<<" ";
    	}
    	cout<<endl;
    
    	system("pause");
    	return 0;
    } 
    
    

    运行结果

    四:C++编程实现两个一元n次多项式的和。要求使用单向链表存储多项式(按指数升序)

    算法思想

     一元多项式相加
    
    1.首相用链表创建两个一元n次多项式
              每个结点的数据包含两个:系数、指数
     
    2.按照指数升序,如果函数录入为乱序,这里需要一个排序函数
    
    3.多项式相加求和
    
              当指数相等时,系数相加,存入新的链表
    
              当指数不相等时,比较大小,存入新的链表
    
    4.输出函数
    
            4.1 p的后继结点不为空时,p等于它的后继结点,继续循环
    
                 两式相加为常数(指数为0)怎么处理——只输出系数
    
                 两式相加系数为1(系数为1.指数为1)怎么处理——不显示系数
    
                 系数不为0指数为1的情况——不显示指数x,2x,3x
    
                 系数为1指数不为0的情况——不显示系数x^2,x^3
    
                 两个多项式相加的和为0时——直接输出空
    
                 系数不为1指数不为0的情况——2x^3,3x^2
    
         4.2 这里还要判断最后一个多项式是上面的那种类型,因为最后一个可能存在,但是已经推出循环
    
                系数为0,指数不为0
    
                系数为1,指数为1
    
                系数为1,指数不为1
    
                系数为1,指数不为0
    
                系数为0
    
                系数不为1,指数不为0

    代码实现

    #include <iostream>
    using namespace std;
     
     //构造定义结构体变量
    typedef struct poly
    {
    	int coe;	//系数
    	int exp;		//指数
    	poly *next; 
    }poly;
    
    
    //创建单链表存储多项式的各项式[尾插法]
    poly *CreateList()
    {
    	poly *head,*p,*q;
    	
    	int n;				//确定每一个多项式的个数
    	int i = 0;			//输入的第几个多项式的系数或指数 
    
    	head = (poly*)malloc(sizeof(poly));			//给head分配内存空间
    	//poly *head=new poly;
    
    	head->next = NULL;	//head初始化为空表 	
    	q = head;			//让q等于head的头节点 
    	
    	cout<<"请输入你想要多少个多项式:"<<endl;
    	cin >>n;
    	
    	for(i = 0;i < n;i++)
    	{
    		//p = (poly*)malloc(sizeof(poly));		//给p分配内存空间 		
    		poly *p=new poly;
    
    		cout<<"请输入第:"<<i+1<<"项的系数"<<endl;
    		cin >>p->coe;
    	
    		cout<<"请输入第:"<<i+1<<"项的指数"<<endl;
    		cin >>p->exp;
    		
    		p->next = q->next;	
    		q->next = p;		
    		q = q->next; 
    
    		cout<<endl;
    	}
    	return head;
    }
    
    //输出函数,输出单链表
    void print(poly *head)
    {
    	poly *p;
    	
    	p = (poly*)malloc(sizeof(poly));	
    	//poly *p=new poly;
    	p = head->next;
    
    	while(p->next != NULL)								//如果p的后继节点不为空时执行下列语句
    	{								 
    		if(p->coe != 0 && p->exp == 0)		//系数不为0指数为0的情况(常数)
    		{	
    			cout<<"+"<<p->coe;						//所以只输入系数		
    		}
           
           else if(p->coe == 1 && p->exp == 1) //系数为1指数为1的情况 	
    	    {	
    			cout<<"x+";										//不显示系数
    	    }	
    		
    		else if(p->coe != 0 && p->exp == 1)//系数不为0指数为1的情况
    		{ 
    			cout<<p->coe<<"x+";						
    		}
    		
    		else if(p->coe == 1 && p->exp != 0) //系数为1指数不为0的情况
    		{
    			cout<<"x^"<<p->exp<<"+";
    		}
    		
    		else if(p->coe == 0)					 //两个多项式相加的和为0时的情况,不输出 
    		{					 	
    			cout<<"";		
    		}
    		
    		else if(p->coe != 1 && p->exp != 0) //系数不为1指数不为0的情况
    		{ 		
    			cout<<p->coe<<"x^"<<p->exp<<"+";		
    		}
    		
    		p = p->next;									//让p等于它的后继结点,继续循环
    	}
    
    	//判断最后一个多项式的类型 
    	//当p为最后一个结点时,p->next已经是空,就会跳出循环,最后一个结点的数据就会不运行出来
    	if(p->exp == 0 && p->coe != 0)         //系数为0,指数不为0
    		{	
    			cout<<p->coe;
    		}	
    
            else if(p->coe == 1 && p->exp == 1) //系数为1,指数为1
    		{
    			cout<<"x+";		
    		}
    		
    		else if(p->exp == 1 && p->coe != 0)  //系数为1,指数不为1
    		{
    			cout<<p->coe<<"x";	
    		}
    		
    		else if(p->coe == 1 && p->exp != 0)   //系数为1,指数不为0
    		{
    			cout<<"x^"<<p->exp;	
    		}
    		
    		else if(p->coe == 0)	                   //系数为0
    		{		
    			cout<<"0";
    		}
    		
    		else if(p->coe != 1 && p->exp != 0)   //系数不为1,指数不为0
    		{
    			cout<<p->coe<<"x^"<<p->exp;	
    		}
    }
    
    //排序
    void paixu(poly *head)//将多项式按升幂排序
    { 	
    	poly *p,*q;
    	
    	int temp,temp1;
    	
    	for(p=head->next;p!=NULL;p=p->next)		//运用了两个for循环
    	{		
    		for(q=p->next;q!=NULL;q=q->next)	//q为p的后继结点
    		{			
    			if(p->exp > q->exp)	//如果p的指数比q的指数大,也就是前一项的指数比后一个指数大,那么交换它们的指数和系数
    			{		
    				temp = p->exp;			
    				p->exp = q->exp;		
    				q->exp = temp;		
    				temp1 = p->coe;			
    				p->coe = q->coe;			
    				q->coe = temp1;		
    			}
    		} 
    	}
    } 
    
    //多项式相加
    poly *SumPoly(poly *&Heada,poly *Headb)			//一元多项式相加 (将一元多项式相加的结果存放在Heada中) 
    {	
    	poly *a,*b,*p;
    	
    	a = Heada->next;	
    	b = Headb->next;
    	p = Heada;
    	
    	while(a != NULL && b != NULL)
    	{		
    		if(a->exp == b->exp)
    		{	
    			a->coe = a->coe+b->coe;		
    			p->next = a;
    			p = p->next;			
    			a = a->next;		
    			b = b->next;		
    		}	
    		else if(a->exp < b->exp)
    		{			
    			p->next = a;		
    			p = p->next;		
    			a = a->next;		
    		}	
    		else
    		{			
    			p->next = b;			
    		    p = p->next;		    
    		    b = b->next;		
    		}		
    	}
    	
    	if(a != NULL)							//比较结束之后a或b如果有一个还未空就执行下述语句
    	{		
    			p->next = a;		
    	}	
    	else
    	{			
    		p->next = b;		
    	}
    	return Heada;	
    }
    
    	
     
    int main()
    {
    	 poly *Heada,*Headb,*Headc;
    
    	//创建多项式
    	Heada = CreateList();
    	Headb = CreateList();
    
    	//排序
    	paixu(Heada);
    	paixu(Headb);
    	
    	//输出多项式A、B
    	 cout<<endl<<"你输入的多项式A为:"<<endl;
    	 print(Heada);
    	 cout<<endl<<"你输入的多项式B为:"<<endl;
    	 print(Headb);
    
    	//求和输出
    	cout<<endl;
    	cout<<endl;
    	cout<<"合并后的多项式C为:";
    	Headc = SumPoly(Heada,Headb);//相加
    	print(Headc);//输出
    	cout<<endl;
    
    	system("pause");
    	return 0;
    }

    运行结果

     

    展开全文
  • 程序主要实现功能有:学生信息的录入(动态链表创建),输出所有学生信息(链表遍历),输出排名(单向链表排序),以及一系列基于链表操作查询,修改,添加学生成绩求平均分,统计分数区域人数等功能。 总体思路:...

    C语言 学生成绩管理系统(基于文件读写操作及单向动态链表的创建,遍历和排序)

    本程序为作者的大一下学期的c语言期末作业,用编译器VS2019写成,如有问题和不足,欢迎大家指出共同探讨。
    程序主要实现的功能有:学生信息的录入(动态链表创建),输出所有学生信息(链表遍历),输出排名(单向链表排序),以及一系列基于链表操作的查询,修改,添加学生成绩和求平均分,统计分数区域人数等功能。
    程序流程图
    总体思路:读取文件,创建单向动态链表储存文件中已有的学生成绩。通过对链表的操作,继续录入学生成绩,并且实现输出,修改等功能。在退出程序之前用"w+"模式新建文件重新写入链表中的学生成绩和信息来覆盖原文件。这种方法避免了对文件的直接操作,如在文件中查找删除或修改某个值,转为对链表节点的操作,相对而言更加简便。但这种方法不适用于大量数据的操作。

    //函数声明和结构体
    为方便修改,本程序中宏定义科目数N为4

    #include<stdio.h>
    #include<malloc.h>
    #include<string.h>
    #include<stdlib.h>
    #define N 4
    
    //函数声明
    void add_stu(int stu_num, struct student* head);//存储学生信息
    void menu(struct student* p);//菜单
    void list_initi(struct student* p);//链表初始化
    void present_all(struct student* p);//展示全部学生成绩
    void present_one(struct student* p);//输出某学生成绩
    void score_analy(struct student* p);//分析学生成绩
    void score_zone(struct student* p);//统计不同分数区域学生人数
    struct student* search(struct student* head);//通过姓名或学号查找某个学生信息,返回指向该学生指针
    void sort(struct student* head);//显示成绩排名
    void revise(struct student* p);//选择修改或添加学生信息
    void reinput(struct student* p);//修改信息
    void upfile(struct student* p);//更新文件
    void back_menu(struct student* p);//返回初始菜单
    struct student
    {
    	long ID;
    	char name[20];
    	char sex[20];
    	double score[N];
    	struct student* next;
    };
    
    

    //主函数部分
    创建头结点,调用list_initi()读取文件内容储存到链表中,调用menu()菜单供用户进行功能选择。当menu()函数执行完即用户选择退出后,选择是否更新文件,调用upfile()来新建文件覆盖原文件。

    int main(void)
    {
    	char ch;
    	struct student* head = (struct student*)malloc(sizeof(struct student));//头结点
    	head->next = NULL;
    	list_initi(head);
    	menu(head);
    	printf("是否更新文件?Y/N\n");
    	getchar();
    	scanf_s("%c", &ch, 1);
    	if (ch == 'y' || ch == 'Y')
    		upfile(head);
    	return 0;
    }
    

    //读取文件,链表初始化
    while (fgets(line, sizeof(line), fpRow))用于计算文件行数,防止读入空行产生无效节点。
    while (!feof(fp) && j < row)循环,一边创建链表节点,一边将读出的值赋给节点

    void list_initi(struct student* head)//链表初始化
    {
    
    	FILE* fpRow;
    	fopen_s(&fpRow, "1班学生成绩信息.txt", "r+");
    	char line[1024];
    	int row = 0;	//行数
    	while (fgets(line, sizeof(line), fpRow))
    	{
    		if (line[0] == '\n' || line[0] == '\r') // 判断空行
    		{
    			break; // 跳出
    		}
    		else
    		{
    			row++;
    		}
    	}
    	fclose(fpRow);
    
    	int j = 0;
    	int i;
    	FILE* fp;
    	fopen_s(&fp, "1班学生成绩信息.txt", "r+");
    	struct student* p = head;
    	if (fgetc(fp) != EOF)
    	{
    		rewind(fp);
    		while (!feof(fp) && j < row)
    		{
    			struct student* q = (struct student*)malloc(sizeof(struct student));//构建新节点存放下一个学生信息
    			fscanf_s(fp, "%s", &q->name, 20);
    			fscanf_s(fp, "%d", &q->ID);
    			fscanf_s(fp, "%s", &q->sex, 20);
    			for (i = 0; i < N; i++)
    			{
    				fscanf_s(fp, "%lf", &q->score[i]);
    			}
    			p->next = q;//原p指向新节点
    			q->next = NULL;
    			p = q;//q代替原p成为链表尾部
    			j++;
    		}
    
    	}
    	fclose(fp);
    }
    

    //调用主菜单
    用switch跳转到对应功能模块

    void menu(struct student* head)//主菜单
    {
    	struct student* temp = NULL;
    	system("cls");
    	int cho, stu_num = 0;
    
    	printf("-------------------------------------------------------------\n");
    	printf("\t\t1.录入学生信息\n\n");
    	printf("\t\t2.显示全部学生各科成绩\n\n");
    	printf("\t\t3.各科成绩统计分析\n\n");
    	printf("\t\t4.各科各分数段人数\n\n");
    	printf("\t\t5.通过学号或姓名查找学生成绩\n\n");
    	printf("\t\t6.按总分或单科成绩高低排序\n\n");
    	printf("\t\t7.更新学生信息\n\n");
    	printf("\t\t8.退出程序\n\n");
    	printf("-------------------------------------------------------------\n");
    	printf("请输入选项:\n");
    	scanf_s("%d", &cho);
    	system("cls");
    	switch (cho)
    	{
    	case 1:
    		printf("输入需要录入的学生数量\n");
    		scanf_s("%d", &stu_num);
    		add_stu(stu_num, head);
    		break;
    	case 2:
    		present_all(head);
    		break;
    	case 3:
    		score_analy(head);
    		break;
    	case 4:
    		score_zone(head);
    		break;
    	case 5:
    		temp = search(head);
    		present_one(temp);
    		break;
    	case 6:
    		sort(head);
    		break;
    	case 7:
    		revise(head);
    		break;
    	case 8:
    		return;
    	default:
    		printf("输入选项错误\n");
    		break;
    	}
    	back_menu(head);
    	return;
    }
    

    除排序和录入外,余下功能实现主要基于链表遍历操作。
    排序主要是通过冒泡排序和节点交换实现。录入函数是通过动态创建链表节点,与前面链表初始化的list_initi()函数操作一致。统计分数段人数中用到二维数组

    //存入学生信息

    void add_stu(int stu_num, struct student* head)//对链表操作,加长链表存储新学生信息
    {
    	int i, j;
    	struct student* p;
    	p = head;
    	while (p->next != NULL)
    	{
    		p = p->next;
    	}//p为尾部节点
    	char ch;
    	do {
    
    		for (i = 0; i < stu_num; i++)//每输入一个学生信息即构建一个节点存入
    		{
    			struct student* q = (struct student*)malloc(sizeof(struct student));//构建新节点存放下一个学生信息
    			printf("输入第%d个学生的姓名\n", i + 1);//输入信息
    			getchar();
    			scanf_s("%s", &q->name, 20);
    			printf("输入学号:\n");
    			scanf_s("%d", &q->ID);
    			printf("输入性别(男/女)\n");
    			scanf_s("%s", &q->sex, 20);
    			printf("请依次输入%d门成绩\n", N);
    			for (j = 0; j < N; j++)
    			{
    				scanf_s("%lf", &q->score[j]);
    			}
    			printf("\n");
    			p->next = q;//原p指向新节点
    			q->next = NULL;
    			p = q;//q代替原p成为链表尾部
    		}
    		printf("\n继续录入学生信息? 请输入:Y/N\n");
    		getchar();
    		scanf_s("%c", &ch, 1);
    	} while (ch == 'y' || ch == 'Y');
    
    }
    
    

    //输出所有学生信息(遍历链表)

    void present_all(struct student* head)//输出所有学生信息
    {
    	struct student* p = head->next;//头节点为空指针,输出从下一有效节点开始
    	int i;
    	printf("学生姓名\t第一科\t\t第二科\t\t第三科\t\t第四科\n");
    	while (p != NULL)//遍历链表
    	{
    		printf("%s\t\t", p->name);
    		for (i = 0; i < N; i++)
    		{
    			printf("%.2f\t\t", p->score[i]);
    		}
    		printf("\n");
    		p = p->next;
    	}
    	//方法二:输出文件中所有信息
    	/*
    	int ch;
    	FILE* fp;
    	fopen_s(&fp, "1班学生成绩信息.txt", "r");
    	while (!feof(fp))
    	{
    		if ((ch = fgetc(fp)) != EOF)
    			putchar(ch);
    	}
    	*/
    }
    

    //输出某个学生成绩

    
    
    void present_one(struct student* p)
    {
    	int i = 0;
    	printf("学生姓名:%s", &p->name);
    	for (i = 0; i < N; i++)
    		printf("第%d科成绩为:%.2f\n", i + 1, p->score[i]);
    }
    
    

    //计算平均分,及格率等

    void score_analy(struct student* p)//成绩分析
    {
    	p = p->next;
    	int i, j;
    	int cout = 0;//cout计算学生总数
    	int cout_pass[N] = { 0 };//存放各科及格人数
    	double sum[N] = { 0 };//存放各科总分
    	double Aver[N] = { 0 };//存放各科平均分
    	double rate_pass[N] = { 0 };//存放各科及格率
    	double max_each[N] = { 0 };//存放各科最高分
    	double min_each[N] = { 100,100,100 ,100 };//存放各科最低分
    	while (p != NULL)
    	{
    		for (i = 0; i < N; i++)
    		{
    			sum[i] += p->score[i];//计算各科总分
    			if (max_each[i] < p->score[i])//计算各科最高分
    				max_each[i] = p->score[i];
    			if (min_each[i] > p->score[i])//计算各科最低分
    				min_each[i] = p->score[i];
    			if (p->score[i] >= 60)//统计各科及格人数
    				cout_pass[i]++;
    		}
    		cout++;//计算学生总数
    		p = p->next;
    	}
    	printf("科目\t\t最高分\t\t最低分\t\t及格率\t\t平均分\n");
    	for (j = 0; j < N; j++)
    	{
    		Aver[j] = sum[j] / cout;
    		rate_pass[j] = cout_pass[j] / (cout * 1.0);
    		printf("第%d科\t\t%.2f\t\t %.2f\t\t%.3f\t\t%.2f\n", j + 1, max_each[j], min_each[j], rate_pass[j], Aver[j]);
    	}
    	printf("\n");
    }
    
    

    //统计不同分数区域人数

    void score_zone(struct student* p)//分析成绩区域人数
    {
    	p = p->next;
    	int i, j;
    	int score_cout[N][4] = { 0 };//N为科目数,4代表4个分数段
    	while (p != NULL)
    	{
    		for (i = 0; i < N; i++)//i代表科目
    		{
    			if (p->score[i] < 60)//j = 0 60分数以下
    				score_cout[i][0]++;
    			else if (p->score[i] >= 60 && p->score[i] < 80)//60-80分数段
    				score_cout[i][1]++;
    			else if (p->score[i] >= 80 && p->score[i] < 90)//80-90分数段
    				score_cout[i][2]++;
    			else//90分以上 
    				score_cout[i][3]++;
    
    		}
    		p = p->next;
    	}
    	printf("科目\t\t60分以下\t60-80分\t\t80-90分\t\t90分以上\n");
    	for (i = 0; i < N; i++)
    	{
    		printf("第%d科:", i + 1);
    		for (j = 0; j < 4; j++)
    			printf("\t\t%d", score_cout[i][j]);
    		printf("\n");
    	}
    }
    
    

    //通过学号或姓名查询学生信息

    struct student* search(struct student* head)//通过学号或姓名查询
    {
    	int num;
    	long ID_search;
    	char name_search[20];
    	struct student* p = head->next;
    	struct student* pre = p;
    	printf("请选择查询方式:\n1.学号  2.姓名\n");
    	scanf_s("%d", &num);
    	if (num == 1)//输入为学号
    	{
    		printf("请输入学号:\n");
    		scanf_s("%d", &ID_search);
    		while (p != NULL)
    		{
    			if (ID_search == p->ID)
    				return p;
    			pre = p;
    			p = p->next;
    		}
    	}
    	else if (num == 2)//输入为姓名
    	{
    		printf("请输入姓名:\n");
    		getchar();
    		scanf_s("%s", &name_search, 20);
    		while (p != NULL)
    		{
    			if (strcmp(name_search, p->name) == 0)
    				return p;
    			pre = p;
    			p = p->next;
    		}
    	}
    	else
    		printf("输入错误\n");
    	printf("没有找到对应学生信息!\n");
    	return NULL;//没有找到学生
    }
    

    //对链表排序,交换节点,输出各科成绩排名

    void sort(struct student* head)//对链表操作排序
    {
    	char ch;
    	int i, n, j, rank;
    	double sum1, sum2, total;
    	struct student* pre, * p, * tail, * headptr = head;
    	do {
    		tail = NULL;//参与比较的尾节点
    		printf("请选择:1.单科排名  2.总分排名\n");
    		scanf_s("%d", &n);
    		if (n == 1)
    		{
    			printf("输入第几门科目\n");
    			scanf_s("%d", &i);
    			while (headptr->next != tail)//当tail指向第一个有效节点(首节点headptr为空),即循环结束
    			{
    				pre = headptr;//首节点,内部为空
    				p = headptr->next;
    				while ((p->next) != tail)//冒泡排序。tail指向及其后面节点不参与比较
    				{
    					if (p->score[i - 1] < p->next->score[i - 1])
    					{//交换p和p的下一节点
    						pre->next = p->next;
    						p->next = p->next->next;
    						pre->next->next = p;
    						pre = pre->next;
    					}
    					else
    					{//p,pre向后移动一位
    						p = p->next;
    						pre = pre->next;
    					}
    				}//完成一次排序
    				tail = p;//循环节点向前移动一位(即下次比较排除该次循环后的最小值(p最后指向值))
    			}
    			p = headptr->next;//输出从第一个有效值节点开始
    			rank = 1;
    			system("cls");
    			printf("排名\t姓名\t成绩\n");
    			while (p != NULL)//输出排名
    			{
    				printf("%d\t%s\t%.2f\n", rank, p->name, p->score[i - 1]);
    				printf("\n");
    				p = p->next;
    				rank++;
    			}
    		}
    		else if (n == 2)
    		{
    			while (headptr->next != tail)//当tail指向第一个有效节点(首节点headptr为空),即循环结束
    			{
    				pre = headptr;//首节点,内部为空
    				p = headptr->next;
    				while ((p->next) != tail)//冒泡排序。tail指向及其后面节点不参与比较
    				{
    					sum1 = 0;
    					sum2 = 0;
    					for (j = 0; j < N; j++)
    					{
    						sum1 += p->score[j];
    						sum2 += p->next->score[j];
    					}
    					if (sum1 < sum2)
    					{//交换p和p的下一节点
    						pre->next = p->next;
    						p->next = p->next->next;
    						pre->next->next = p;
    						pre = pre->next;
    					}
    					else {//p,pre向后移动一位
    						p = p->next;
    						pre = pre->next;
    					}
    				}//完成一次排序
    				tail = p;//循环节点向前移动一位(即下次比较排除该次循环后的最小值(p最后指向值))
    			}
    			p = headptr->next;//输出从第一个有效值节点开始
    			rank = 1;
    			system("cls");
    			printf("排名\t姓名\t成绩\n");
    			while (p != NULL)
    			{
    				total = 0;
    				for (j = 0; j < N; j++)
    				{
    					total += p->score[j];
    				}
    				printf("%d\t%s\t%.2f\n", rank, p->name, total);
    				p = p->next;
    				rank++;
    			}
    		}
    		else
    			printf("输入错误\n");
    		printf("\n查看其他排名? 请输入:Y/N\n");
    		getchar();
    		scanf_s("%c", &ch, 1);
    	} while (ch == 'y' || ch == 'Y');
    }
    

    //修改或添加学生信息

    void revise(struct student* head)//选择修改或添加学生信息
    {
    	system("cls");
    	int cho, num;
    	printf("请输入选项:\n");
    	printf("1.修改学生信息  2.添加学生信息\n");
    	scanf_s("%d", &cho);
    	system("cls");
    	if (cho == 1)
    		reinput(head);
    	else if (cho == 2)
    	{
    		printf("输入需要添加的学生数量\n");
    		scanf_s("%d", &num);
    		add_stu(num, head);
    	}
    	else
    		printf("输入选项错误\n");
    }
    

    //修改信息,重新输入或删除

    void reinput(struct student* head)//重新输入信息
    {
    
    	struct student* p;
    	p = search(head);//查找对应学号或姓名学号
    	struct student* pre = head;
    	int j, cho, i;
    	char ch;
    	if (p == NULL)//没有找到对应学生信息,返回NULL
    		return;
    	printf("姓名\t\t性别\t\t学号\t\t%d科成绩\n", N);
    	printf("%s\t\t%s\t\t%d\t\t", p->name, p->sex, p->ID);
    	for (i = 0; i < N; i++)
    		printf("%.2f\t\t", p->score[i]);
    	printf("\n\n");
    	do
    	{
    		printf("请选择:\n1.修改姓名 2.修改学号 3.修改性别 4.修改成绩 5.全部修改 6.删除该学生信息\n");
    		scanf_s("%d", &cho);
    		switch (cho)
    		{
    		case 1:
    			printf("修改姓名为:\n");//输入信息
    			getchar();
    			scanf_s("%s", &p->name, 20);
    			break;
    		case 2:
    			printf("修改学号为:\n");
    			scanf_s("%d", &p->ID);
    			break;
    		case 3:
    			printf("修改性别为(男/女)\n");
    			scanf_s("%s", &p->sex, 20);
    			break;
    		case 4:
    			printf("请依次输入修改后%d门成绩\n", N);
    			for (j = 0; j < N; j++)
    			{
    				scanf_s("%lf", &p->score[j]);
    			}
    			printf("\n");
    			break;
    		case 5:
    			printf("修改姓名为\n");//输入信息
    			getchar();
    			scanf_s("%s", &p->name, 20);
    			printf("修改学号为:\n");
    			scanf_s("%d", &p->ID);
    			printf("修改性别为(男/女)\n");
    			scanf_s("%s", &p->sex, 20);
    			printf("请依次输入修改后%d门成绩:\n", N);
    			for (j = 0; j < N; j++)
    			{
    				scanf_s("%lf", &p->score[j]);
    			}
    			printf("\n");
    			break;
    		case 6:
    			while (pre != NULL)
    			{
    				if (pre->next == p)
    				{
    					pre->next = p->next;
    					free(p);
    					printf("删除成功!\n");
    					return;
    				}
    				pre = pre->next;
    			}
    
    		default:
    			printf("输入选项错误\n");
    			break;
    		}
    		printf("继续修改其他信息?Y/N\n");
    		getchar();
    		scanf_s("%c", &ch, 1);
    	} while (ch == 'Y' || ch == 'y');
    }
    

    //选择返回是否菜单

    void back_menu(struct student* head)//返回菜单menu
    {
    	char ch;
    	printf("是否返回主菜单?Y/N\n");
    	getchar();
    	scanf_s("%c", &ch, 1);
    	if (ch == 'Y' || ch == 'y')
    		menu(head);
    }
    

    以上函数仅改变了链表的信息和顺序,并未对文件内容产生影响,下面函数则将链表的信息储存进文件中

    void upfile(struct student* head)//把链表输入覆盖原文件
    {
    	int i;
    	struct student* p;
    	FILE* fp;
    	fopen_s(&fp, "1班学生成绩信息.txt", "w");
    	p = head->next;
    	while (p != NULL)//把链表中的值重新写入覆盖原文件
    	{
    		fprintf(fp, "%s\t\t%ld\t\t%s\t\t", p->name, p->ID, p->sex);
    		for (i = 0; i < N; i++)
    		{
    			fprintf(fp, "%.2f\t", p->score[i]);
    		}
    		fprintf(fp, "\n");
    		p = p->next;
    	}
    	fclose(fp);
    }
    

    以上为学生成绩管理系统的全部代码。
    学生成绩管理系统源码下载

    展开全文
  • /*-----------------------------------------------------------------------------时间:2011年9月28日文件功能:实现了动态建立一个学生信息的链表包括链表的创建、插入、删除、打印输出学生信息包括姓名分数本...
  • /*----------------------------------------------------------------------------...创建、插入、删除、打印输出学生信息包括姓名分数 本链表是带有头结点,头结点内容为空内容 --------------------------
  • 上机实验习题 上机实验要求及规范 C程序设计具有比较强理论性,同时也具有较强可应用性实践性。在上机实验是一个重要教学环节...),确定数据存储结构(是顺序结构还是链表结构?)。然后设计有关操作函...
  • /*-----------------------------------------------------------------------------文件功能:实现了动态建立一个学生信息的链表包括链表的创建、插入、删除、打印输出学生信息包括姓名分数本链表是带有头结点的...
  • 文件功能:实现了动态建立一个学生信息的链表包括链表的创建、插入、删除、打印输出学生信息包括姓名分数 本链表是带有头结点的,头结点的内容为空内容 -------------------------------------------
  • 通过静态链表建立一个由n个学生成绩顺序表,n大小由自己确定,每一个学生的成绩信息由自己确定,实现数据对表进行插入、删除、查找等操作。分别输出结果。 三.源代码 #include #include using ...
  • 巩固双链表的数据结构的存储方法相关操作,学会针对具体应用,使用线性表的相关知识来解决具体问题。 二. 实验内容  建立一个由n个学生成绩的顺序表,n的大小由自己确定,每一个学生的成绩信息由自己确定,...
  • (1)创建信息链表并以磁盘文件保存; (2)读取磁盘文件并显示输出所有学生的籍贯信息; (3)按学号或姓名查询其籍贯; (4)按籍贯查询并输出该籍贯所有学生; (5)能添加、删除修改学生的籍贯信息;
  • 创建学生成绩单链表

    千次阅读 2017-10-12 08:39:01
    建立一个由n个学生成绩顺序表,n大小由自己确定,每一个学生的成绩信息由自己确定,实现数据对表进行插入、删除、查找等操作。分别输出结果。 三、实验步骤 1、依据实验内容分别说明实验程序中用...
  • 创建学生成绩双链表

    2017-10-12 08:47:45
    建立一个由n个学生成绩顺序表,n大小由自己确定,每一个学生的成绩信息由自己确定,实现数据对表进行插入、删除、查找等操作。分别输出结果。 三、实验步骤 1、依据实验内容分别说明实验程序中用...
  • 建立一个由n个学生成绩顺序表,n大小由自己确定,每一个学生的成绩信息由自己确定,实现数据对表进行插入、删除、查找等操作。分别输出结果。 三、实验步骤 1、依据实验内容分别说明实验程序中用...
  • 之前写了一份但项链表的学生信息管理博客,今天又学到了双向链表,所以用双向链表写了一份代码(输入暂时只设置了name项,输出增加了时间),想要其他信息,可以修改结构体内容输入输出对应内容即可。...
  • 学生帐户 :对自己的信息的更新修改! 查看自己成绩信息! 管理员账号密码静态3次错误输出会推出系统 教师账号密码由管理员创建存在teacher.dat里面 学生账号密码也有管理员初始创建存在student.dat里面。 ...
  • 建立一个由n个学生成绩顺序表,n大小由自己确定,每一个学生的成绩信息由自己确定,实现数据对表进行插入、删除、查找等操作。分别输出结果。 代码如下: #include using namespace std; t
  • 建立一个由n个学生成绩顺序表,n大小由自己确定,每一个学生的成绩信息由自己确定,实现数据对表进行插入、删除、查找等操作。分别输出结果。 源代码如下: #include #include using namespace st
  • 、本程序为学生链表,实现创建链表输出链表,插入学生信息,删除学生信息。主函数中先创建一个学生链表,也包括学号姓名,把输入信息储存在head地址中,在输出函数,插入函数删除函数中,把head作为参数传递。...
  • 建立一个由n个学生成绩顺序表,n大小由自己确定,每一个学生的成绩信息由自己确定,实现数据对表进行插入、删除、查找等操作。分别输出结果。 三、代码 #include using namespace std;
  • 建立一个由n个学生成绩顺序表,n大小由自己确定,每一个学生的成绩信息由自己确定,实现数据对表进行插入、删除、查找等操作。分别输出结果。 三、代码 #include #include using namespac
  • 顺序表: 用顺序表实现下面功能: 1,顺序表的初始化,创建,结构体中饱含元素--学号,姓名,创建完毕后打印输出 1顺序表的定位,通过学号定位姓名,输出学号信息...3链表的插入删除(插入删除后输出剩余表中学生信息并打印输出

空空如也

空空如也

1 2 3 4 5 6
收藏数 120
精华内容 48
关键字:

学生信息链表的创建和输出