精华内容
下载资源
问答
  • 导言:本文使用C语言构建图书结构体,并实现其创建、输出、新旧书入库出库、最贵图书查找、图书修改、排序、逆序存储以及数组图书去重等函数的实现。 一、图书结构体定义 为了方便数组操作的实现,初始化图书数组...

    导言:本文使用C语言构建图书结构体,并实现其创建、输出、新旧书入库出库、最贵图书查找、图书修改、排序、逆序存储以及数组图书去重等函数的实现。

    一、图书结构体定义

    为了方便数组操作的实现,初始化图书数组1000个,根据用户需要的大小进行图书的初始化。

    #include<stdio.h>
    #include<stdlib.h>
    #define N 1000  //图书数组可能达到的最大长度 
    typedef struct tagbook
    {
    	char num[20];//图书ISBN
    	char name[50];//图书名字
    	double price;//图书价格
    }Book;

    二、图书结构体数组的创建和输出

    本函数的输入n+1行,第一行是需要输入图书的个数n,其中后n行是n本图书的信息(书号、书名、价格),每本图书信息占一行,书号、书名、价格用空格分隔,价格之后没有空格。其中书号和书名为字符串类型,价格为浮点数类型。

    /*创建、输出函数接口定义*/
    void input(Book book[],int n);
    void output(Book book[],int n);

    input函数使用scanf对图书结构的三个信息元素进行录入。在这里要注意的是,编译环境为Visual Studio 2017中,scanf是无法通过代码检测的,需要换成C++中的cin(标准输入输出流)进行录入,没有其他办法(亲测gets函数、fgets函数、scaf_s函数均无法实现空格读取字符串)。

    /*input函数定义*/
    void input(Book book[], int n)
    {
    	int i;
    	for (i = 0; i < n; i++)
    	{
    		scanf("%s %s %lf", book[i].num, book[i].name, &(book[i].price));
    	}
    }
    /*output函数定义*/
    void output(Book book[], int n)
    {
    	int i;
    	for (i = 0; i < n; i++)
    	{
    		printf("%s %s %.2lf", book[i].num, book[i].name, book[i].price);
    		if (i != n - 1)
    			printf("\n");
    	}
    }

    三、图书结构体数组的新书入库及旧书出库

    /*图书插入函数接口定义*/
    void insert(Book *L,int *m,int index,Book book);
    //其中 L , m, index , book都是用户传入的参数。 L 是指向要操作的图书数组的指针; m 是指向图书总数的指针;index是插入的位置;book是待插入的一本图书信息。
    void del(Book *L,int *m,int index);//在指定位置删除一个学生并显示所有学生信息
    //其中 L, m和index是用户传入的参数。 L 是待操作的图书信息,m 是指向学生的总人数的指针,index是旧书删除的位置。
    /*insert函数定义*/
    void insert(Book *L, int *m, int index, Book book)
    {
    	Book temp;
    	int size_bookarray;
    	int move_size;
    	int i, j;
    	size_bookarray = *m;
    	if (index > (*m) + 1 || index <= 0)
    	{
    		printf("Sorry,the position to be inserted is invalid!");
    	}
    	else
    	{
    		move_size = size_bookarray - index + 1;
    		for (i = size_bookarray - 1; i >= size_bookarray - move_size; i--)
    		{
    			L[i + 1] = L[i];
    		}
    		L[index - 1] = book;
    		*m = size_bookarray + 1; // 修改图书结构体数组图书总数
    	}
    }
    /*del函数定义*/
    void del(Book *L, int *m, int index)
    {
    	int i;
    	int size_bookarray;
    	int move_size;
    	size_bookarray = *m;
    	if (index > size_bookarray || index <= 0)
    	{
    		printf("Sorry,the position to be deleted is invalid!");
    	}
    	else
    	{
    		move_size = size_bookarray - index;
    		for (i = index - 1; i < index - 1 + move_size; i++)
    		{
    			L[i] = L[i + 1];
    		}
    		*m = size_bookarray - 1;
    	}
    }

    四、最贵图书查找

    /*函数接口定义*/
    void MaxPrice(Book *L,int n); 
    
    /*MaxPrice函数定义*/
    void MaxPrice(Book *L, int n)
    {
    	int i;
    	int count = 0;
    	double max_price = 0;
    	for (i = 0; i < n; i++)
    	{
    		if (max_price <= L[i].price)//找最高价格
    			max_price = L[i].price;
    	}
    	//在找到最高价格的基础上进行检索,找出下标
    	for (i = 0; i < n; i++)
    	{
    		if (L[i].price == max_price)
    			count++;
    	}
    	printf("%d\n", count);
    	for (i = 0; i < n; i++)
    	{
    		if (L[i].price == max_price)
    		{
    			printf("%s %s %.2lf\n", L[i].num, L[i].name, L[i].price);
    			count--;
    		}
    	}
    }
    
    

    五、图书按照价格降序排序

    该函数要求使用稳定排序方法,在这里考虑采用冒泡排序法:

    /*函数接口定义*/
    Book* Sort(Book *L,int n);
    
    /*Sort函数定义*/
    Book* Sort(Book *L, int n)
    {
    	int i, j;
    	int m = n - 1;
    	int flag = 1;
    	Book temp;
    	while ((m>0)&&(flag == 1))
    	{
    		flag = 0;
    		for (j = 0; j < m; j++)
    		{
    			if (L[j].price < L[j + 1].price)
    			{
    				flag = 1;
    				temp = L[j];
    				L[j] = L[j + 1];
    				L[j + 1] = temp;
    			}
    		}
    		--m;
    	}
            return L;
    }

    六、图书结构数组的去重操作

    出版社出版的任何一本图书的书号(ISBN)都是唯一的,即图书表中不允许包含书号重复的图书。定义一个包含图书信息(书号、书名、价格)的结构体数组,读入相应的图书数据来完成图书信息的创建(书号可能重复),然后进行图书的去重,即删除书号重复的图书(只保留第一本),最后输出去重后所有图书的信息。要求编写图书去重的函数。

    /*函数接口定义*/
    void del_same(Book *L,int *m);
    
    /*del_same函数定义*/
    //该函数的实现离不开使用del函数(对应位置删除函数)
    void del_same(Book *L, int *m) 
    {
    	int i, j;
    	int size_bookarray;
    	size_bookarray = *m;
    	for (i = 0; i < size_bookarray; i++)
    	{
    		for (j = i + 1; j < size_bookarray; j++)
    		{
    			if (strcmp(L[i].num, L[j].num) == 0)//如果相等 有重复
    			{
    				del(L, &size_bookarray, j + 1);
    				//同时修改了数组大小
    				j = j - 1; //这一步是为了防止j的跳跃,否则会出现比较遗漏的情况
    			}	
    		}
    	}
    	//*m = size_bookarray;
    }

     

    展开全文
  • C语言结构体作业

    2017-12-24 14:57:00
    题目1:6-3 结构体数组查找指定编号人员 1. 本题PTA提交列表 2. 设计思路 定义一个结构体指针*p for i=0 to i=7 如果std+i的编号与输入的编号一样 将std+i的地址传给p end for 返回p 3.代码截图 4.本题调试过程...

    一、PTA实验作业

    题目1:6-3 结构体数组中查找指定编号人员

    1. 本题PTA提交列表

    1232226-20171223214337975-1620892015.png

    2. 设计思路

    定义一个结构体指针*p
    for i=0 to i=7
         如果std+i的编号与输入的编号一样     将std+i的地址传给p
    end for
    返回p

    3.代码截图

    1232226-20171223214348396-1815468251.png

    4.本题调试过程碰到问题及PTA提交列表情况说明。

    • 无错误

    题目2:7-2 时间换算

    1. 本题PTA提交列表

    1232226-20171223214402506-956379143.png

    2. 设计思路

    定义结构体数组Time,其内容包括时,分,秒
    定义一个字符ch,增加的秒数n,结构体变量time
    输入time和n
    如果time中的秒数加上n大于等于60   time.s加上n后再减去60  time的分钟数加上1
    否则   time.s加上n
    如果time中的分钟数大于等于60    time.m减去60   time的小时数加上1
    如果time的小时数等于24    time.h减去24
    输出结果

    3.代码截图

    1232226-20171223214409865-863995072.png

    4.本题调试过程碰到问题及PTA提交列表情况说明。

    • 秒数加上n后大于等于60就再减去60,但是我第一次做的时候忘了加上n后没大于等于60的情况,这时候是要加上n但是不用减去60的

    题目3:7-6 通讯录的录入与显示

    1. 本题PTA提交列表

    1232226-20171223214417865-325660276.png

    2. 设计思路

    定义一个结构体变量person,内容为姓名 生日 性别 固话 手机
    定义整型变量n,k,num,输入n,定义结构体数组friends[n]
    for  i=0 to i=n-1  
              输入结构体数组的所有变量
    end  i
    输入k
    for  j=1  to  j=k
           输入num
           如果num小于n且大于等于0    输出friends[num]的姓名 固话 手机 性别 生日
           否则  输出Not Found
    end  j

    3.代码截图

    1232226-20171223214428865-1352227755.png

    4.本题调试过程碰到问题及PTA提交列表情况说明。

    • 我定义的性别是个字符,在输入性别后,要有一个getchar()来吸收空格,否则空格就会被性别吸收
    • 在最下面j的循环中,要在num大于等于0且小于n的情况下输出,但是我做的时候没注意,写的小于等于n,在devc上按pta的错误点调试也没错,我试了很多次后只好去看自己的代码,这才发现我的错误

    二、截图本周题目集的PTA最后排名。

    1232226-20171223214439068-1048241219.png

    三、阅读代码

    1:一帮一

    • 题目描述:输入第一行给出正偶数N(<=50),即全班学生的人数。此后N行,按照名次从高到低的顺序给出每个学生的性别(0代表女生,1代表男生)和姓名(不超过8个英文字母的非空字符串),其间以1个空格分隔。这里保证本班男女比例是1:1,并且没有并列名次。
      每行输出一组两个学生的姓名,其间以1个空格分隔。名次高的学生在前,名次低的学生在后。小组的输出顺序按照前面学生的名次从高到低排列。
    • 1232226-20171224141433350-1384729841.png
    • 此代码使用结构体来表示学生 ,下面的循环先输出前一半的学生,然后从后面开始寻找与之配对的学生,数组b的功能是来判断对应的学生是否已经退出
    • 首先,题目中学生信息包括姓名的性别,用结构体表示更加方便简洁;这个代码先输出前半的学生,然后巧妙地运用了数组b来避开已经输出过的学生

    2:斐波那契数列

    • 1232226-20171224145508225-365611611.png
    • 该函数功能是输出斐波那契数列
    • 通过递归函数,简单实现斐波那契数列的计算,使代码精简易懂,但是递归次数过多也容易造成栈溢出。

    四、本周学习总结

    1.总结本周学习内容。

    1、结构体、共用体、枚举这种构造数据类型特点。
    • 结构体和数组一样都是构造型数据类型,和数组不同的是,结构体可以处理不同类型的数据。结构体里还可以有结构体类型、共用体的类型的数据。
    • 共用体是一种多变量共享存储空间的构造类型,它允许几种不同的变量共用同一存储空间。共用体和结构体的区别:
      1.结构体每一位成员都用来表示一种具体事务的属性,共用体成员可以表示多种属性(同一存储空间可以存储不同类型的数据)。
      2.结构体总空间大小,等于各成员总长度,共用体空间等于最大成员占据的空间。
      3.共用体不能赋初值。
    • 枚举类型是指变量的值可以全部列出,定义一个枚举变量后,变量的值确定在定义之中。它和结构体、共用体的区别在于,枚举元素是常量,只能在定义阶段赋值。

      2、递归函数原理
    • 递归是把一个不能或不好解决的大问题转化为一个或几个小问题,再把这些小问题进一步分解成更小的问题,直至每个小问题都可以直接解决。
    • 递归算法的实质:是把问题转化为规模缩小了的同类问题的子问题。然后递归调用函数(或过程)来表示问题的解。
    • 递归算法解决问题的特点:
       (1) 递归就是在过程或函数里调用自身。
       (2) 在使用递归策略时,必须有一个明确的递归结束条件,称为递归出口。
       (3) 递归算法解题通常显得很简洁,但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
       (4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

      2.罗列本周一些错题。

    • 1、1232226-20171224135943678-1803046428.png
      这题其实很简单,但我做的时候没仔细看,把加看成乘,所以以为到0的时候返回0,乘以0就等于0;事实上,这是加法,答案应该是10
    • 2、1232226-20171224140143443-683819771.png
      这题我没注意思考,以为最后到7的时候输出完就没了,事实上,每一次计算都要输出一次

    转载于:https://www.cnblogs.com/wyb123/p/8094547.html

    展开全文
  • myarray.h#pragma once #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt;...typedef int datatype;...struct Res//创建一个新的结构体用来存储二级指针(用来存储返回查找到的重复元...

    myarray.h

    #pragma once
    #include<stdlib.h>
    #include<stdio.h>
    typedef int datatype;
    typedef struct myarray
    {
    	datatype *data;
    	int length;
    }array;
    
    struct Res//创建一个新的结构体用来存储二级指针(用来存储返回查找到的重复元素)
    {
    	datatype **ppstart;//创建指针数组
    	int n;
    
    };
    
    struct Res findall(array *pstart, datatype data);
    
    
    void init(array *pstart);
    void initwithdata(array *pstart, datatype data);
    void initwitharray(array *pstart, datatype *data, int datalength);
    void show(array *pstart);
    void addwithdata(array *pstart, datatype data);
    void addwitharray(array *pstart, datatype *data, int datalength);
    datatype *findfirst(array *pstart, datatype data);
    void deletedata(array *pstart, datatype data);
    void deletealldata(array *pstart, datatype data);
    void changedata(array *pstart, datatype data, datatype newdata);
    void changealldata(array *pstart, datatype data, datatype newdata);
    void insertdata(array *pstart, datatype data,datatype newdata);
    void insertarray(array *pstart, datatype data, datatype *newdata, int insertlength);
    
    

    myarray.c

    #include "myarray.h"
    
    
    struct Res findall(array *pstart, datatype data)
    {	
    	struct Res res;
    	res.n = 0;
    	for (int i = 0; i < pstart->length; i++)
    	{
    		if (pstart->data[i]==data)
    		{
    			res.n++;
    		}
    
    	}
    	res.ppstart = malloc(sizeof(datatype *)*res.n);
    	int j = 0;
    	for (int i = 0; i < pstart->length; i++)
    	{
    		if (pstart->data[i]==data)
    		{
    			res.ppstart[j++] = pstart->data + i;
    
    		}
    
    	}
    	return res;
    
    
    }
    void init(array *pstart)
    {
    	if (pstart!=NULL)
    	{
    		pstart->data = NULL;
    		pstart->length = 0;
    		
    
    	}
    	else
    	{
    		printf("init error");
    	}
    	
    
    }
    void initwithdata(array *pstart, datatype data)
    {
    	if (pstart!=NULL)
    	{
    		if (pstart->data==NULL||pstart->length==0&&data!=NULL)
    		{
    			pstart->data = malloc(sizeof(datatype));
    			*(pstart->data) = data;
    			pstart->length++;
    
    
    		}
    		else
    		{
    			printf("initwithdata error\n");
    		}
    
    	}
    	else
    	{
    		printf("initwithdata error\n");
    	}
    
    }
    void initwitharray(array *pstart, datatype *data, int datalength)
    {
    	if (pstart!=NULL)
    	{
    		if (pstart->data==NULL||pstart->length==0&&data!=NULL)
    		{
    			pstart->data = malloc(sizeof(datatype)*datalength);
    			for (int i = 0; i < datalength; i++)
    			{
    				pstart->data[i] = data[i];
    			}
    
    			pstart->length += datalength;
    
    		}
    		else
    		{
    			printf("initwitharray error\n");
    		}
    
    	}
    	else
    	{
    		printf("initwitharray error\n");
    	}
    
    }
    
    void show(array *pstart)
    {	
    	printf("数组内情况:");
    	if (pstart!=NULL)
    	{
    		for (int i = 0; i < pstart->length; i++)
    		{
    			printf("%4d", pstart->data[i]);
    		}
    		printf("\n");
    
    	}
    	else
    	{
    		printf("没有数据\n");
    	}
    
    }
    
    void addwithdata(array *pstart, datatype data)
    {
    	if (pstart!=NULL)
    	{
    		if (pstart->data!=NULL||pstart->length!=0)
    		{
    			pstart->data = realloc(pstart->data, (pstart->length + 1) * sizeof(datatype));
    			(pstart->data)[pstart->length] = data;
    			pstart->length++;
    
    		}
    		else
    		{
    			init(pstart);
    			initwithdata(pstart, data);
    		}
    
    	}
    	else
    	{
    		printf("addwithdata error");
    	}
    
    }
    void addwitharray(array *pstart, datatype *data, int datalength)
    {
    	if (pstart!=NULL)
    	{
    		if (pstart->data!=NULL||pstart->length!=0)
    		{
    			pstart->data = realloc(pstart->data, (pstart->length + datalength) * sizeof(datatype));
    			datatype *temp=(pstart->data) + (pstart->length);
    			for (size_t i = 0; i < datalength; i++)
    			{
    				*(temp + i) = data[i];
    
    			}
    			pstart->length += datalength;
    
    		}
    		else
    		{
    			init(pstart);
    			initwitharray(pstart, data, datalength);
    		}
    
    
    	}
    	else
    	{
    		printf("addwitharray error");
    	}
    
    }
    void changealldata(array *pstart, datatype data, datatype newdata)
    {
    	if (pstart!=NULL)
    	{
    		datatype *pfind = findfirst(pstart, data);
    		if (pfind==NULL)
    		{
    			printf("没有数据改什么该");
    
    		}
    		else
    		{
    			for (datatype *p=pfind; p!=NULL;p=findfirst(pstart,data))
    			{
    				changedata(pstart, data,newdata);
    			}
    		}
    
    	}
    	else
    	{
    		printf("changealldata error");
    	}
    
    
    
    }
    
    void changedata(array *pstart, datatype data,datatype newdata)
    {
    	if (pstart!=NULL)
    	{
    		datatype *pfind = findfirst(pstart, data);
    		if (pfind==NULL)
    		{
    			printf("没有找到要更改的数据");
    
    		}
    		else
    		{
    			int curr = pfind - pstart->data;
    			pstart->data[curr] = newdata;
    			
    		}
    
    	}
    	else
    	{
    		printf("changedata error");
    	}
    
    
    
    }
    
    void deletedata(array *pstart, datatype data)
    {
    	if (pstart!=NULL)
    	{
    		datatype *pfind = findfirst(pstart, data);
    		if (pfind==NULL)
    		{
    			printf("没找到,怎么删除");
    		}
    		else
    		{
    			int curr = pfind - (pstart->data); //地址(指针)相减等于下标
    
    
    			for (int i = curr; i < pstart->length - 1; i++)
    			{
    				pstart->data[i] = pstart->data[i + 1];
    			}
    			pstart->length-=1;
    			pstart->data = realloc(pstart->data, (pstart->length) * sizeof(datatype));
    
    
    		}
    		
    		
    		
    
    	}
    	else
    	{
    		printf("deletedata error");
    	}
    
    }
    
    void deletealldata(array *pstart, datatype data)
    {
    	if (pstart!=NULL)
    	{
    		datatype *pfind = findfirst(pstart, data);
    		if (pfind==NULL)
    		{
    			printf("没有数据删除个鬼");
    			
    
    		}
    		else
    		{
    			for (datatype *p=pfind; p!=NULL; p=findfirst(pstart,data))
    			{
    				deletedata(pstart, data);
    			}
    		}
    	}
    	else
    	{
    		printf("deletealldata errors");
    	}
    
    }
    
    datatype *findfirst(array *pstart, datatype data)
    {
    	if (pstart!=NULL)
    	{
    		if (pstart->data!=NULL||pstart->length!=0)
    		{
    			for (int i = 0; i < pstart->length; i++)
    			{
    				if (pstart->data[i]==data)
    				{
    					return pstart->data + i;
    
    				}
    
    			}
    			return NULL;
    
    		}
    		else
    		{
    			return NULL;
    		}
    
    	}
    	else
    	{
    		return NULL;
    	}
    
    
    }
    
    void insertarray(array *pstart, datatype data, datatype *newdata, int insertlength)
    {
    	if (pstart!=NULL)
    	{
    		datatype *pfind = findfirst(pstart, data);
    		if (pfind==NULL)
    		{
    			printf("找不到怎么插入");
    
    		}
    		else
    		{
    			int curr = pfind - pstart->data;
    			pstart->data = realloc(pstart->data, sizeof(datatype)*(pstart->length + insertlength));
    			for (int i = pstart->length; i >curr; i--)
    			{
    				pstart->data[i + insertlength - 1] = pstart->data[i - 1];
    
    			}
    			for (int i = 0; i < insertlength; i++)
    			{
    				pstart->data[i + curr] = newdata[i];
    			}
    			pstart->length += insertlength;
    		}
    
    	}
    	else
    	{
    		printf("insertarray error");
    	}
    
    
    }
    void insertdata(array *pstart, datatype data, datatype newdata)
    {
    	if (pstart!=NULL)
    	{
    		datatype *pfind = findfirst(pstart, data);
    		if (pfind==NULL)
    		{
    			printf("没找到怎么插入??");
    
    		}
    		else
    		{
    			int curr = pfind - pstart->data;
    			pstart->data = realloc(pstart->data, (pstart->length + 1) * sizeof(datatype)); //注意这里是给pstart->data重新分配内存而不是给整个结构体
    			for (int i = pstart->length; i >curr ; i--)
    			{
    				pstart->data[i] = pstart->data[i - 1];
    			}
    			pstart->data[curr] = newdata;
    			pstart->length++;
    		}
    
    	}
    	else
    	{
    		printf("insertdata error");
    	}
    
    }
    main.c
    #include"myarray.h"
    
    void main()
    {
    	int data = 5;
    	int date[3] = { 5,2,3 };
    	int a[4] = { 5,6,7,8 };
    	int c[4] = { 9,10,11,12 };
    	array Myarray;
    	init(&Myarray);	//必须先初始化
    
    	initwitharray(&Myarray, date, 3);
    	addwithdata(&Myarray, data);
    	addwitharray(&Myarray, a, 4);
    	//deletealldata(&Myarray, 5);  
    	//changealldata(&Myarray, 5, 4);
    	//insertdata(&Myarray, 6, 9);
    	//insertarray(&Myarray, 6, c, 4);
    	struct Res res=findall(&Myarray, 5);
    	for (int i = 0; i < res.n; i++)
    	{
    		printf("%p %d\n", res.ppstart[i], *res.ppstart[i]);
    
    	}
    	show(&Myarray);
    
    
    
    
    	system("pause");
    }

    展开全文
  • 结构体和数组,实现通讯录功能。目前完成六个基础功能:添加、查看、删除、查找、修改、排序。 若有好的建议或意见,欢迎留言! #include&lt;stdio.h&gt; #include&lt;string.h&gt; #include...

    概括:

    用结构体和数组,实现通讯录功能。目前完成六个基础功能:添加、查看、删除、查找、修改、排序。

    若有好的建议或意见,欢迎留言!

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
     
    #define N 15
    #define M 100
     
    void showscreen();
    void addlinkman();
    void showlinkman();
    void deletelinkman();
    void searchlinkman();
    void changelinkman();
    void sortlinkman();
     
    static int i_len = 0;
     
    struct Demo
    {
    	//int id;
    	char name[N];
    	char sex[N];
    	char address[N];
    	char phonenum[N];
    }linkman[M];
     
    int main()
    {	
    	
    	system("clear");
    	showscreen();
    	
    	return 0;
    }
     
    //选择菜单
    void showscreen()
    {
    	int num_select;
    	
    	printf("* * * * * * * * * * * *\n");
    	printf("* * *   功能列表  * * *\n");
    	printf("* * *   1.添加    * * *\n");		
    	printf("* * *   2.查看    * * *\n");
    	printf("* * *   3.删除    * * *\n");
    	printf("* * *   4.查找    * * *\n");
    	printf("* * *   5.修改    * * *\n");
    	printf("* * *   6.排序    * * *\n");
    	printf("* * *   7.退出    * * *\n");
    	printf("* * * * * * * * * * * *\n");
    	
    	printf("\n");
    	printf("序号选择功能: ");
    	scanf("%d", &num_select);
    	
    	switch (num_select)
    	{
    		case 1:
    		{
    			addlinkman();
    			break;
    		}
    		case 2:
    		{
    			showlinkman();
    			break;
    		}
    		case 3:
    		{
    			deletelinkman();
    			break;
    		}
    		case 4:
    		{
    			searchlinkman();
    			break;
    		}
    		case 5:
    		{
    			changelinkman();
    			break;
    		}
    		case 6:
    		{
    			sortlinkman();
    			break;
    		}
    		case 7:
    		{
    			printf("退出系统!\n");
    			exit(0);
    			break;
    		}
    		default:
    		{
    			printf("输入有误!请重新选择\n");
    			showscreen();	
    		}
    	}
    	
    }
     
    //添加功能
    void addlinkman()
    {
    	char new_linkman[N];
    	int i;
    	int continue_1=1;
    	char continue_choice;
     
    	printf("\n");                    
    	printf("输入姓名:");
    	scanf("%s", new_linkman);
    	
    	for (i = 0; i < i_len; i++)   //加个判断 是否重复
    	{
    		if((strcmp(new_linkman, linkman[i].name)) == 0)
    		{
    			printf("已有该联系人!\n");
    			printf("\n");
    			goto end_add;
    		}
    	}
    
    	strcpy(linkman[i_len].name, new_linkman);
    	strcpy(new_linkman,"");
    	
    	printf("输入性别:");
    	scanf("%s", new_linkman);
    	strcpy(linkman[i_len].sex, new_linkman);
    	strcpy(new_linkman,"");
    	
    	printf("输入地址:");
    	scanf("%s", new_linkman);
    	strcpy(linkman[i_len].address, new_linkman);
    	strcpy(new_linkman,"");
    	
    	printf("输入号码:");
    	scanf("%s", new_linkman);
    	strcpy(linkman[i_len].phonenum, new_linkman);
    	strcpy(new_linkman,"");
    	printf("\n");
    	
    	printf("添加成功!\n");
    	
    	i_len++;
    	while(continue_1)
    	{
    	printf("是否继续添加<y/n>:");
    	getchar();
    	scanf("%c", &continue_choice);
    	if(continue_choice == 'y')
    	{
    		continue_1 = continue_1 - 1;
    		addlinkman();
    	
    	}
    	else if(continue_choice == 'n')
    	{
    		continue_1 = continue_1 - 1;
    		printf("\n");
    		system("clear");
    		goto end_add;
    	}
    	else
    	{
    		printf("输入有误!重新输入\n");
    		continue;
    	}
    	}
    	end_add:showscreen();
     
    	/*for(i = 0; i < i_len; i++)       //给每个结构体赋予序号
    	{
    		linkman[i].id= i+1;
    	}*/	
    }
    	
    //查看功能	
    void showlinkman()
    {
    	int i;
    	system("clear");
    	if(i_len == 0)
    	{
    		printf("通讯录暂时为空,请添加!\n");
    		printf("\n");
    		goto end_show;
    	}
    	printf("联系人信息如下:\n");
    	for(i = 0; i < i_len; i++)
    	{
    		if(*linkman[i].name == 0 || *linkman[i].phonenum == 0)
    		{
    			continue;
    		}
    		printf("\n");
    		printf("  姓名: %s\n", linkman[i].name);
    		printf("  性别: %s\n", linkman[i].sex);
    		printf("  地址: %s\n", linkman[i].address);
    		printf("  号码: %s\n", linkman[i].phonenum);
    		printf("\n");
    	}
    	end_show:showscreen();
    }
    	
    //删除功能
    void deletelinkman()
    {
    	int i;
    	int continue_1=1;
    	char continue_choice;
    	
    	char *tmp_data;
    	tmp_data = malloc (sizeof(char) * N);
    	
    	system("clear");
    	
    	if(i_len == 0)
    	{
    	printf("通讯录为空,请先添加!\n");
    	printf("\n");
    	goto end_delete;
    	}
    	
    	return_start:printf("\n");
    	printf("输入要删除的姓名或者号码: ");  //判断是否存在 然后删除
    	getchar();
    	scanf("%s", tmp_data);
    	
    	for(i = 0; i < i_len; i++)
    	{
    		if(strcmp(linkman[i].name,tmp_data) != 0 || strcmp(linkman[i].phonenum,tmp_data) != 0 )
    		{
    			printf("联系人不存在,请重新输入:\n");
    			printf("\n");
    			goto return_start;
    		}
    	}
    	
    	printf("\n");
    	
    	printf("是否确认删除!!<y/n>");
    	getchar();
    	scanf("%c", &continue_choice);
    	if(continue_choice == 'y')
    	{
    	for(i = 0; i < i_len; i++)
    	{
    		if(!strcmp(linkman[i].name, tmp_data) || !strcmp(linkman[i].phonenum, tmp_data))
    		{
    			memset(linkman[i].name,0,sizeof(linkman[i].name)/sizeof(linkman[i].name[0]));
    			memset(linkman[i].sex,0,sizeof(linkman[i].sex)/sizeof(linkman[i].sex[0]));
    			memset(linkman[i].address,0,sizeof(linkman[i].address)/sizeof(linkman[i].address[0]));
    			memset(linkman[i].phonenum,0,sizeof(linkman[i].phonenum)/sizeof(linkman[i].phonenum[0]));
    			printf("删除成功!\n");
    			i_len--;
    			printf("\n");
    		}
    	}
    	}
    	else if(continue_choice == 'n')
    	{
    		system("clear");
    		goto end_delete; 
    	}
    	end_delete:showscreen();
    }
     
    //查找功能
    void searchlinkman()
    {
    	char *search_cnd;
    	search_cnd = malloc (sizeof(char) * N);
    	int i, count=0;
    	
    	system("clear");
    	
    	if(i_len == 0)
    	{
    	printf("通讯录为空,请先添加!\n");
    	printf("\n");
    	goto end_search;
    	}
    	
    	printf("输入查找的姓名或号码:");
    	getchar();
    	scanf("%s",search_cnd);
    	printf("\n");
    	printf("查找的信息:\n");
    	
    	for(i = 0; i < i_len; i++)
    	{
    		if(!strncmp(linkman[i].name, search_cnd,N) || !strncmp(linkman[i].phonenum, search_cnd,N))
    		{
    			printf(" 姓名: %s\n", linkman[i].name);
    			printf(" 性别: %s\n", linkman[i].sex);
    			printf(" 地址: %s\n", linkman[i].address);
    			printf(" 号码: %s\n", linkman[i].phonenum);
    			printf("\n");
    			count++;
    		}
    	}
    		if(count == 0)
    		{
    			printf("未找到相关信息!\n");
    			printf("\n");
    		}
    	end_search:showscreen();
    }
     
    //修改功能
    void changelinkman()
    {
    	char *changename;
    	char *changesex;
    	char *changeaddress;
    	char *changephonenum;
    	char *change_information;
    	
    	char continue_choice;
    	
    	changename = malloc(sizeof(char) * 15);
    	changesex = malloc(sizeof(char) * 15);
    	changeaddress = malloc(sizeof(char) * 15);
    	changephonenum = malloc(sizeof(char) * 15);
    	
    	system("clear");
    	
    	if(i_len == 0)
    	{
    	printf("通讯录为空,请先添加!\n");
    	printf("\n");
    	goto end_change;
    	}
    	
    	printf("输入要修改姓名或号码!:");
    	scanf("%s", change_information)	;
    	
    	int i;
    	for(i = 0; i < i_len; i++)
    	{
    		if(!strcmp(linkman[i].name,change_information)|| !strcmp(linkman[i].phonenum,change_information))
    		{
    			printf("原来的信息:\n");
    			printf("姓名:%s\n",linkman[i].name);
    			printf("性别:%s\n",linkman[i].sex);
    			printf("地址:%s\n",linkman[i].address);			
    			printf("手机号码:%s\n",linkman[i].phonenum);
    			printf("请确定是否修改(y/n): ");
    			getchar();
    			scanf("%c", &continue_choice);
    			
    			if(continue_choice == 'y')
    			{
    				printf("\n");
    				printf("请输入要修改的姓名:");
    				scanf("%s", changename);
    				strcpy(linkman[i].name,changename);
    				
    				printf("请输入要修改的性别:");
    				scanf("%s",changesex);
    				strcpy(linkman[i].sex,changesex);
    				
    				printf("请输入要修改的地址:");
    				scanf("%s",changeaddress);
    				strcpy(linkman[i].address,changeaddress);
    				
    				printf("请输入要修改的号码:");
    				scanf("%s",changephonenum);
    				strcpy(linkman[i].phonenum,changephonenum);
    			}
    			if(continue_choice == 'n')
    			{
    				goto end_change;
    			}	
    		}
    	}
    	system("clear");
    	end_change:showscreen();
    }
    
    //排序功能
    void sortlinkman()
    {
    	int i;
    	int j;
    	
    	char *tmp_name;
    	char *tmp_sex;
    	char *tmp_address;
    	char *tmp_phonenum;
    	
    	tmp_name = (char *) malloc (sizeof(char) * N);
    	tmp_sex = (char *) malloc (sizeof(char) * N);
    	tmp_address = (char *) malloc (sizeof(char) * N);
    	tmp_phonenum = (char *) malloc (sizeof(char) * N);
    	
    	system("clear");
    	
    	for(i = 0; i < i_len - 1; i++)
    	{
    		for(j = 0; j < i_len - i - 1; j++)
    		{
    			if(strcmp(linkman[j].name,linkman[j+1].name)>0)
    			{
    			
    				strcpy(tmp_name,linkman[j+1].name);
    				strcpy(linkman[j+1].name,linkman[j].name);
    				strcpy(linkman[j].name,tmp_name);
    				
    				strcpy(tmp_sex,linkman[j+1].sex);
    				strcpy(linkman[j+1].sex,linkman[j].sex);
    				strcpy(linkman[j].sex,tmp_sex);
    				
    				strcpy(tmp_address,linkman[j+1].address);
    				strcpy(linkman[j+1].address,linkman[j].address);
    				strcpy(linkman[j].address,tmp_address);
    				
    				strcpy(tmp_phonenum,linkman[j+1].phonenum);
    				strcpy(linkman[j+1].phonenum,linkman[j].phonenum);
    				strcpy(linkman[j].phonenum,tmp_phonenum);		
    			}
    		
    		}
    	}
    	printf("排序结束.\n");
    	
    	showscreen();
    }
    
    

     

    展开全文
  • C语言结构体运用实例

    2020-09-15 18:03:25
    C语言结构体运用实例 问题描述:编写程序,定义一个结构体(如下图)数组存放5个同学的学号,姓名和成绩,程序可按照用户输入的学号在该数组中进行查找,如找到则输出该同学的学号、姓名和成绩信息,如找不到则输出...
  • <p>a. 现有一个班级的学生成绩,要求自定义结构体存储学生信息,学生信息包括学生姓名与学生成绩。...插入代码段的时候不知道哪个是C语言,就选的C++ 谢谢泥萌!</p>
  • 结构体数组作为函数参数,并返回结构体 结构体中的结构体 结构体中的指针  动态内存分配结构体 链表的引入 单链表的定义 单链表的初始化与添加节点 单链表的查找、打印、释放 单链表的节点删除 链表算法题...
  • 题目1:6-3 结构体数组查找指定编号人员 1. 本题PTA提交列表(要提交列表,不是结果) 2. 设计思路(伪代码或流程图) 传入结构体数组str 和要查找的人员num struct student *pos; for pos=std to std+7 if...
  • 做了一个学生成绩的结构体数组,运行的时候发现成绩始终是0.0,好像输入的score数据没有传进去,其他的都正常。源码贴在下面,请大佬纠错! <code class="language-cpp">#include&...
  • 第一次发送很简单,第二次的起始地址需要跳转到结构体的中间,方法很多,比如第二次从结构体的某个元素开始,name可以取该元素的地址,或者将结构体内容拷贝到一个char数组内,然后使用数组索引定位第二次发送的起始...
  • C语言做的程序,编程环境visual C++ 6.0。此程序分成两个部分,一是对文件文本单词的查找,二是对文本内容的替换。 程序中需要创建子文件textfile,...//第二次优化时间 2021/02/10/ 结构体数组排序 //第三次优化时间
  • 看到同事一段接口代码,一脸懵逼,有这样一个结构体 typedef struct cache_rsp{ int ret; unsigned int len; ...这个结构体的设计是用来接收服务器报文回复数据的,接收...终于在一番百度之后,查找的到了这种结构...
  • C语言学习之结构体

    2020-06-24 14:21:43
    比如去描述一个班级学生的信息情况,这里就需要有姓名、学号、年龄,身高等信息,如果使用数组进行存储,那么就注定需要将学生的信息进行分类存储,这在查找某一名学生的信息时是非常不便的,因此就需要有结构体这一...
  • C语言分块查找算法索引顺序查找算法 例如采用分块查找法在有序表 111218283956698996122135146156256298 中查找...实现过程 (1)定义结构体 index用于存储块的结构并定义该 结构体数组?index_table (2)自定义函数 blo
  • status selectElem(SqList L,type elem,int &location){//查找元素 elem要查找的元素 location查找元素的位置 for(int i=0;i;i++) { if(L.elem[i]==elem) location=i+1; return SUCCESS; } printf("没有...
  • C语言中对结构体排序

    2020-11-07 17:33:22
    C语言中对结构体排序 用qsort()函数进行排序, qsort()里面要传入4个参数–qsort(数组名,数组长度,sizeof(),排序方法) 实验9-5 查找书籍 (20分) 给定n本书的名称和定价,本题要求编写程序,查找并输出其中定价...
  • 航班信息的读取,先定义结构体数组,从文件中读取航班的航班号、起始终点站等信息写入到结构体数组fly中,在用fscanf函数的格式读取方式将文档中相应的数据保存在相应的结构体数组里定义的变量中。 用户信息的读取,...
  • 例如,采用分块查找法在有序表 11、12、18、28、39、56、69、89、96、122... (1)定义结构体 index,用于存储块的结构,并定义该结构体数组index_table。 (2)自定义函数 block_search(),实现分块查找。 (3)main...
  • 结构体数组查找指定编号人员 1. 本题PTA提交列表 2. 设计思路 struct student{ char num[10]; int year,month,day ; };//该结构体表示人员的编号,出生年、月、日 定义i为循环变量,定义结构变量p for i=0 to...
  • 题目1:6-3 结构体数组查找指定编号人员 1. 本题PTA提交列表(要提交列表,不是结果) 2. 设计思路 struct student { char num[10]; int year,month,day ; };该结构体表示人员的编号,出生年月日。 定义一个环境...
  • 建立的结构体数组通过输入存放全班(最多45人)学生信息,输入班级人数,以及每个学生的姓名,性别,年龄,成绩(以回车分隔),输出考分最高的学生的姓名、年龄、性别和课程的成绩。 提示:请使用getchar()读出...
  • 电话通讯录C语言

    2013-05-29 23:10:54
    2、 查询记录模块:主要完成在结构体数组查找满足相关条件的记录,如可以按照联系人的姓名、联系人的电话号码等项目进行查询,查到了,将相关信息显示在屏幕上,否则显示没找到。 3、 更新记录模块:主要完成对...
  • 首先程序通过construct()函数,利用已经存在的结构体数组数据建立一个二叉树,建立树的过程中,要保证每个节点的值都大于它的左子树上节点的值而小于它右子树所有节点的值,该函数返回建立树的根指针;然后通过函数...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 214
精华内容 85
关键字:

c语言结构体数组查找

c语言 订阅