精华内容
下载资源
问答
  • 员工管理系统 C语言

    2013-01-11 23:45:57
    代码有300多行,是一个暑期小学期的程序设计。无bug,同学你懂得、
  • 员工管理系统C语言

    2014-04-11 22:44:48
    C语言写的员工管理系统。包括员工查找,工资查询,信息查询等等。可以运行,调试成功的。
  • 员工信息管理系统

    2018-10-26 10:59:52
    这个是我自己用C语言编写的员工信息管理系统,算是我这一点时间来对所学习C语言的一 个总结的作品.代码量还是蛮大的.功能比较丰富,包含了三个端,员工端,部门经理端,超 级管理员端. 员工端可以申请请假/加薪/转正...
  • word格式文档 word格式文档 专业整理 专业整理 一 课程设计目的 通过本...为后续各门计算机课程的学习打下坚实基础 为毕业设计和以后工作打下必要基础 二 课程设计内容 针对某企业的员工对其信息进行系统管理 三 需
  • 员工管理系统C语言

    2010-12-14 23:06:52
    这是一个我们数据结构课程设计做的员工管理系统,当时我们学的是c语言,很适合于大学生作为课程设计之用,当然也可以做为毕业设计的参考,真心希望对你的课程设计有所帮助!!!
  • 这是一个用C语言写的员工管理系统,实现了对员工的增、删、改、查的功能,当然程序本身并不是很完善,希望大家能给与建议
  • C语言员工信息管理系统,功能齐全,操作简单,代码详细易懂
  • 员工管理c 语言程序设 计员工信息管理系统 实验题目:员工信息管理系统 一 实验目的 1. 熟悉 c 语言的编译连接和运行过程 2. 掌握 c 语言的数据类型熟悉整型实型字符型变量的定义方式及如何给 它们赋值 3. 掌握 if ...
  • c语言课程设计报告 企业员工管理系统
  • 利用C语言实现公司管理员工工资的高效程序,也可以通过自己的改变增加新的功能,可以转化成任何信息规律程序,例如图书管理系统,学生信息管理系统
  • C 语言企业员工管理系统 代码部分 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct employee { int num; char duty[10]; char name[10]; char sex[3]; unsigned char age; char edu[10]...
  • c语言员工管理系统

    2019-01-23 14:55:14
    员工管理系统为用户提供员工信息录入、查看、查找、更新、删除、添加、请假记录 保存信息到文档等功能。 (1) 登录 登录系统时,对用户名和密码进行验证,两者均无误后方可进入系统。 (2) 输入员工信息 输入员工...
  • 4.往系统中添加一个员工; 5.从系统中删除一个员工; 6.程序退出时将系统中所有员工信息保存到文件中; 7.程序启动时将文件中所有员工信息读入程序中。 2、扩展要求 1.系统中所有成员按ID号排序; 2.系统中...
  • 员工工资管理系统c语言,源码,可执行,2000多行,有登录注册修改密码功能,登录之后可以进行员工工资的叔叔,查询,修改,插入,删除,排序,统计,显示,保存到文件。学习c语言的可以看下。
  • 员工管理数据结 构员工管理系统 壹设计题目 [问题描述] 每个员工的信息包括编号姓名性别出生年月学历职务 电话住址等系统能够完成员工信息的查询更新插 入删除排序等功能 [基本要求] 1 排序按不同关键字对所有员工的...
  • C语言员工信息管理系统源代码

    千次阅读 2020-12-23 16:05:39
    分享:C语言学生成绩管理系统设计《C语言程序设计》实训报告 扫描下方公众号,发送成绩系统4个字,获取下载实训源码。 ... ...回复系统大全,即可获得关于...今天分享:C语言员工信息管理系统源代码 /************...

    最近咨询这方面源码的朋友比较多,所以扒一扒以前的网盘,发现了好多之前攒的源码,分享给大家。

    扫描上方二维码,回复 999 直接获取作者之前收藏的学习资源,谢谢网友们的分享。

    更多管理系统更新中,请注意关注!

    今天分享: C语言员工信息管理系统源代码

    /*******************************************************************************
    *   文件名:UI.Cpp															   *
    *                                                                              *
    *   文件功能: 该文件主要是定义(实现)和用户操作有关的一些函数,之所以把和用户 *
    *   操作有关的函数单独放到ui.c中,是为了使程序结构更加清晰,源代码更           *
    *	容易管理,这也是遵循结构化程序设计的要求(模块化、层次化)				   *
    *																			   *
    *   作者:                                                                      *
    *                                                                              *
    *******************************************************************************/
    
    #include  <stdio.h>
    #include	<stdlib.h>
    #include  <string.h>
    #include "ui.h"
    
    
    //选择身份
    void UserOperateChoose(ListType  L)
    {
    	int  option = 0;
    	
    
    	
    	do
    	{
    		
    		//提示用户操作选择
    		PrintOptionChoose( );
    		scanf("%d", &option );
    		
    		//根据用户选择调用相关函数完成指定的操作
    		switch(option )
    		{
    			//添加一个员工
    	/*	case 1:   
    			 
    			UserOperateOne(L);
    			break;*/
    			
    			//删除员工
    	/*	case 2:
    			DelStu(L);
    			break;
    			
    			//修改员工
    	 	case 3:
    			ModifyStu(L);
    			break;         */
    			
    			//查询某个员工
    		case 1:
    			UserOperatemanager(L);
    
    			break;
    			
    			
    		
    			
    			//排序
    	/*	case 3:
    			UserOperateThree(L);
    			break;*/
    			//打印所有员工信息
    		case 2:
    			UserOperateVisitor(L);
    			
    			break;
    			
    		default: break;
    		}
    	}while(option );
    	
    	//程序退出时,显示BYEBYE
    	PrintHello( );
    }
    
    //该函数根据管理员的选择,完成指定的操作
    void UserOperateVisitor(ListType  L)
    {
    	int  option = 0;
    	
    	  //显示欢迎信息
    
    
    	
    	do
    	{
    		//提示用户操作选择
    		PrintOptionVisitor( );
    		scanf("%d", &option );
    		
    		//根据用户选择调用相关函数完成指定的操作
    		switch(option )
    		{
    			//添加一个员工
    	/*	case 1:   
    			 
    			UserOperateOne(L);
    			break;*/
    			
    			//删除员工
    	/*	case 2:
    			DelStu(L);
    			break;
    			
    			//修改员工
    	 	case 3:
    			ModifyStu(L);
    			break;         */
    			
    			//查询某个员工
    		case 1:
    			UserOperateTwo(L);
    
    			break;
    			
    			
    		
    			
    			//排序
    	/*	case 3:
    			UserOperateThree(L);
    			break;*/
    			//打印所有员工信息
    		case 2:
    			PrntAll(L);
    			
    			break;
    			
    		default: break;
    		}
    	}while(option );
    	
    	//程序退出时,显示BYEBYE
    	
    }
    
    
    //该函数根据管理员的选择,完成指定的操作
    void UserOperatemanager(ListType  L)
    {
    	int  option = 0;
    	
    	 
    		//用密码进入系统
    	 password();
    
    	
    	do
    	{
    		//提示用户操作选择
    		PrintOption( );
    		scanf("%d", &option );
    		
    		//根据用户选择调用相关函数完成指定的操作
    		switch(option )
    		{
    			//添加一个员工
    		case 1:   
    			 
    			UserOperateOne(L);
    			break;
    			
    			//删除员工
    	/*	case 2:
    			DelStu(L);
    			break;
    			
    			//修改员工
    	 	case 3:
    			ModifyStu(L);
    			break;         */
    			
    			//查询某个员工
    		case 2:
    			UserOperateTwo(L);
    
    			break;
    			
    			
    		
    			
    			//排序
    		case 3:
    			UserOperateThree(L);
    			break;
    			//打印所有员工信息
    		case 4:
    			PrntAll(L);
    			
    			break;
    		 
    			
    		default: break;
    		}
    	}while(option );
    	
    	//程序退出时,显示BYEBYE
    	 
    }
    
    
    //该函数为基本操作的二级菜单,完成指定的操作
    void UserOperateOne(ListType  L)
    {
    	int  option = 0;
    	
    	
    	do
    	{
    		//提示用户操作选择
    		PrintOptionOne( );
    		scanf("%d", &option );
    		
    		//根据用户选择调用相关函数完成指定的操作
    		switch(option )
    		{
    			//添加一个员工
    		case 1:   
    			AddStu(L);
    			break;
    			
    			//删除员工
    		case 2:
    			DelStu(L);
    			break;
    			
    			//修改员工
    		case 3:
    			ModifyStu(L);
    			break;
    			
    			//返回上级菜单
    		case 0:
    			return;
    			break;
    			
    	/*		//查询某个员工
    		case 5:
    			chkStuname(L);
    			break;
    			
    			
    			//打印所有员工信息
    		case 6:
    			PrntAll(L);
    			break;
    			
    			//按ID号排序
    		case 7:
    			sortbyID(L);
    			
    			break;
    		case 8:
    			//按姓名排序
    			sortbyname(L);
    			break;
    		case 9:
    			//按部门分类显示信息
    			sortbyoffice(L);
    			break;*/
    			
    		default: break;
    		}
    	}while(option );
    	
    	//程序退出时,显示BYEBYE
    	//PrintHello( );
    }
    
    
    //该函数为基本操作的第二个二级菜单,完成指定的操作
    void UserOperateTwo(ListType  L)
    {
    	int  option = 0;
    	
    	
    	do
    	{
    		//提示用户操作选择
    		PrintOptionTwo( );
    		scanf("%d", &option );
    		
    		//根据用户选择调用相关函数完成指定的操作
    		switch(option )
    		{
    			//查询某个员工
    		case 1:
    			chkStu(L);
    			break;
    			
    			//查询某个员工
    		case 2:
    			chkStuname(L);
    
    			break;
    			
    			//返回上级菜单
    		case 0:
    			return;
    			break;
    			
    	/*		//查询某个员工
    		case 5:
    			chkStuname(L);
    			break;
    			
    			
    			//打印所有员工信息
    		case 6:
    			PrntAll(L);
    			break;
    			
    			//按ID号排序
    		case 7:
    			sortbyID(L);
    			
    			break;
    		case 8:
    			//按姓名排序
    			sortbyname(L);
    			break;
    		case 9:
    			//按部门分类显示信息
    			sortbyoffice(L);
    			break;*/
    			
    		default: break;
    		}
    	}while(option );
    	
    	//程序退出时,显示BYEBYE
    	//PrintHello( );
    }
    
    //该函数为基本操作的第三个二级菜单,完成指定的操作
    void UserOperateThree(ListType  L)
    {
    	int  option = 0;
    	
    	
    	do
    	{
    		//提示用户操作选择
    		PrintOptionThree( );
    		scanf("%d", &option );
    		
    		//根据用户选择调用相关函数完成指定的操作
    		switch(option )
    		{
    				//按ID号排序
    		case 1:
    			sortbyID(L);
    			
    			break;
    		case 2:
    			//按姓名排序
    			sortbyname(L);
    			break;
    		case 3:
    			//按部门分类显示信息
    			sortbyoffice(L);
    			break;
    			
    			//按性别排序显示信息
    		case 4:
    
    			sortbysex(L);
    			break;
    			
    		//按年龄排序显示信息
    		case 5:
    			sortbyage(L);
    			break;
    
           //按电话排序显示信息 
    
    		case 6:
    			sortbyphone( L);
    			break;
            //按地址排序显示信息
    		case 7:
    			sortbyaddress( L);
    			break;
    
    
    		//按工资排序显示信息   
    		case 8:
    			sortbypay( L);
    			break;
    
    		//按电子邮件排序显示信息
    		case 9:
    
    			sortbyemil( L);
    			break;
    			
    			//返回上级菜单
    		case 0:
    			return;
    			break;
    			
    	/*		//查询某个员工
    		case 5:
    			chkStuname(L);
    			break;
    			
    			
    			//打印所有员工信息
    		case 6:
    			PrntAll(L);
    			break;
    			
    			//按ID号排序
    		case 7:
    			sortbyID(L);
    			
    			break;
    		case 8:
    			//按姓名排序
    			sortbyname(L);
    			break;
    		case 9:
    			//按部门分类显示信息
    			sortbyoffice(L);
    			break;*/
    			
    		default: break;
    		}
    	}while(option );
    	
    	//程序退出时,显示BYEBYE
    	//PrintHello( );
    }
    
    
    
    /* 用户操作界面启动时,在显示器上显示一些欢迎信息 */
    void PrintWelcome( )
    {
    	puts(" ");
    	puts("********************************************************************" );
    	puts("                       欢迎使用员工管理系统!" );
    	puts("********************************************************************" );
     	puts("	            若有有问题请在留言区交流");
     	puts("********************************************************************" );
    	
    }
    
    
    
    
    
    
    /* 在显示器上显示用户可以进行的操作,以及操作的方法 */
    void PrintOption( )
    {
    	puts(" ");
    	puts("请选择操作:" );
    	puts("0:返回 " );
    	puts("1:进入基本操作菜单");
    	puts("2:进入员工查询系统");
    	puts("3:进入信息排序系统");
    	puts("4:打印员工信息");
    	
    }
    
    
    //选择身份
    void PrintOptionChoose( )
    
    {
    	puts(" ");
    	puts("请选择身份:" );
    	puts("0:退出系统 " );
    	puts("1:以管理员身份进入 " );
    	puts("2:以游客身份进入 " );
    
    }
    
    //显示第一个二级的提示信息
    void PrintOptionOne( )
    {
    	puts(" ");
    	puts("请选择操作:" );
    	puts("0:返回 " );
    	puts("1:添加员工                2:删除员工               3:修改员工信息" );
    	
    }
    //显示第二个二级的提示信息
    void PrintOptionTwo( )
    {
    	puts(" ");
    	puts("请选择操作:" );
    	puts("0:返回 " );
    	puts("1:按员工ID号查询           2:按员工姓名查询" );
    	
    }
    
    //显示第三个二级的提示信息
    void PrintOptionThree( )
    {
    	puts(" ");
    	puts("请选择操作:" );
    	puts("0:返回 " );
    	puts("1:按ID号排序显示信息	 2:按姓名排序显示信息	    3:按部门分类显示信息");
    	puts("4:按性别排序显示信息    5:按年龄排序显示信息      6:按电话排序显示信息");
    	puts("7:按地址排序显示信息    8:按工资排序显示信息      9:按电子邮件排序显示信息");
    	
    }
    
    //显示游客查询系统
    void PrintOptionVisitor( )
    {
    	puts(" ");
    	puts("请选择操作:" );
    	puts("0:返回 " );
     
    	puts("1:进入员工查询系统");
     
    	puts("2:打印员工信息");
    }
    
    
    
    
    /* 程序退出时,在显示器上显示一些感谢语言,以给使用者一个好印象 */
    void PrintHello( )
    {
    	
    	puts("********************************************************************" );
    	puts("                   谢谢使用员工管理系统,再见!" );
    	puts("********************************************************************" );
    	puts(" ");
    	
    }
    
    
    
    //比较两个员工信息的学号是否相等
    //若相等则返回TRUE,否则返回FALSE
    //当调用线性表操作函数int LocateElem(ListType L, ElemType e, STATUS (*compare)(ElemType e1, ElemType e2) 
    //的时候,将该函数名作为第三个参数传递给compare
    STATUS IsEqual(ElemType e1, ElemType e2 )
    {
    	if( strcmp(e1.ID, e2.ID)==0 )
    		return TRUE;
    	
    	return FALSE;
    }
    STATUS IsEqual2(ElemType e1, ElemType e2 )
    {
    	if( strcmp(e1.name, e2.name)==0 )
    		return TRUE;
    	
    	return FALSE;
    }
    
    
    
    //往线性表中添加一个员工
    void AddStu(ListType  L)
    {
    	ElemType  stu;
    	
    	printf("请输入员工的ID号(不超过15位):" );
    	getchar();  //吃掉前面的回车键,否则后面的字符串输入时会出错
    	gets(stu.ID );
    	printf("请输入员工的姓名(不超过15位):" );
    	gets(stu.name );
    	printf("请输入员工的性别(输入M/W):" );
    	stu.sex=getchar();
    	printf("请输入员工的年龄:" );
    	scanf("%d",&stu.age);
    	printf("请输入员工的电话(不超过20位):" );
    	getchar();  //吃掉前面的回车键,否则后面的字符串输入时会出错
    	gets(stu.phone);
    	printf("请输入员工的地址(不超过100位):" );
    	gets(stu.address);
    	printf("请输入员工的电子邮件(不超过50位):" );
    	gets(stu.email);
    	printf("请输入员工的工资(不超过10位):" );
    	gets(stu.pay);
    	printf("请输入员工的工龄:" );
    	scanf("%d",&stu.workingyears);
    	getchar();  //吃掉前面的回车键,否则后面的字符串输入时会出错
    	printf("请输入员工的所在部门(不超过100位):" );
    	gets(stu.office);
    	
    	
    	//判断线性表中是否已经存在该ID号的员工,如果已经存在,则放弃插入操作
    	if( LocateElem(L, stu, IsEqual) )
    	{
    		puts("操作失败,该员工已经存在" );
    		return ;
    	}
    	
    	//将该学生放入线性表中
    	//为简单起见,我们把新添加的结点放到线性表的前面
    	if( ListInsert(L, 1, stu ) )
    		puts("操作成功" );
    	else
    		puts("操作失败" );
    }
    
    
    
    
    
    
    //从线性表中删除一个员工,根据员工的ID号决定删除哪个员工
    void DelStu(ListType  L)
    {
    	ElemType stu;
    	int pos;
    	
    	printf("请输入员工的ID号(不超过15位):" );
    	getchar();  //吃掉前面的回车键,否则后面的字符串输入时会出错
    	gets(stu.ID );
    	pos = LocateElem(L, stu, IsEqual );  //如果存在该ID号的V,则返回其在线性表中的位序,如果不存在返回0
    	if(pos )   
    	{
    		if(ListDelete(L, pos, stu) )
    		{
    			puts("操作成功");
    			return;
    		}
    	}
    	
    	puts("操作失败" );
    }
    
    
    
    //修改员工成绩,根据ID号决定修改哪个员工的成绩
    void ModifyStu(ListType  L)
    {
    	int pos;
    	ElemType stu;
    	
    	printf("请输入员工的ID号(不超过15位):" );
    	getchar();  //吃掉前面的回车键,否则后面的字符串输入时会出错
    	gets(stu.ID );
    	printf("请输入员工的姓名(不超过15位):" );
    	gets(stu.name );
    	printf("请输入员工的性别(输入M/W):" );
    	scanf("%c",&stu.sex);
    	printf("请输入员工的年龄:" );
    	scanf("%d",&stu.age);
    	printf("请输入员工的电话(不超过20位):" );
    	getchar();  //吃掉前面的回车键,否则后面的字符串输入时会出错
    	gets(stu.phone);
    	printf("请输入员工的地址(不超过100位):" );
    	gets(stu.address);
    	printf("请输入员工的电子邮件(不超过50位):" );
    	gets(stu.email);
    	printf("请输入员工的工资(不超过10位):" );
    	gets(stu.pay);
    	printf("请输入员工的工龄:" );
    	scanf("%d",&stu.workingyears);
    	getchar();  //吃掉前面的回车键,否则后面的字符串输入时会出错
    	printf("请输入员工的所在部门:" );
    	gets(stu.office);
    	
    	pos = LocateElem(L, stu, IsEqual );
    	if(pos > 0 )
    	{
    		ListModify(L, pos, stu );
    		puts("操作成功" );
    	}
    	else
    	{
    		puts("操作失败" );
    	}
    	
    	
    }
    
    
    
    
    
    
    //根据学号查询某个员工的成绩
    void chkStu(ListType  L)
    {
    	int pos;
    	ElemType stu;
    	
    	printf("请输入员工的ID号(不超过15位):" );
    	getchar();  //吃掉前面的回车键,否则后面的字符串输入时会出错
    	gets(stu.ID );
    	
    	if(pos = LocateElem(L, stu, IsEqual) )
    	{
    		GetElem(L, pos, stu );
    		PrntOneStu(stu );
    	}
    	else
    	{
    		puts("操作失败" );
    	}
    	
    }
    
    
    
    //根据姓氏查询某个员工的成绩
    void chkStuname(ListType  L)
    {
    	int pos;
    	ElemType stu;
    	
    	printf("请输入员工的姓氏(不超过15位):" );
    	getchar();  //吃掉前面的回车键,否则后面的字符串输入时会出错
    	gets(stu.name);
    	
    	if(pos = LocateElem(L, stu, IsEqual2) )
    	{
    		GetElem(L, pos, stu );
    		PrntOneStu(stu );
    	}
    	else
    	{
    		puts("操作失败" );
    	}
    	
    }
    
    
    //成绩统计,统计全体员工的平均成绩
    /*void StateScore(ListType  L)
    {
    float  total[2] = {0.0, 0.0};
    int num = 0;
    ElemType  e;
    
      while(GetElem(L, num+1, e ) )  //GetElem(...)返回值为FALSE时说明没有位序为num+1的数据
      {
    		num++;
    		total[0] += e.score[0];
    		total[1] += e.score[1];
    		}
    		
    		  if(num > 0 )
    		  {
    		  printf("平均成绩分别为:%.2f, %.2f\n", total[0]/num, total[1]/num );
    		  }
    		  else
    		  {
    		  puts("没有数据信息" );
    		  }
    		  
    			
    }*/
    
    
    
    //打印一个员工的信息
    //调用ListTraverse()函数的时候,将该函数的名字作为第二个参数传递给visit
    STATUS  PrntOneStu(ElemType  stu )
    {
    	printf("ID号:%s 姓名:%s 性别:%c 年龄:%d 电话:%s 地址:%s 电子邮件:%s 工资:%s 工龄:%d 所在部门:%s\n", stu.ID, stu.name, stu.sex,stu.age,stu.phone,stu.address,
    		stu.email,stu.pay, stu.workingyears ,stu.office);
    	
    	return OK;
    }
    
    
    
    
    
    //打印所有学生信息
    void PrntAll(ListType  L)
    {
    	
    	ListTraverse(L, PrntOneStu );
    	
    }
    
    //用于做新的链表 
    
    //按ID排序
    void sortbyID(struct lnode *head)
    {
    	struct lnode *p1,*p2,*l;
    	
    	l=(struct lnode *)malloc(sizeof(struct lnode));                  
    	l->next=NULL;
    	
    	for (p1=head;p1->next!=NULL;p1=p1->next)
    	{
    		for (p2=p1->next;p2!=NULL;p2=p2->next)
    		{
    			if (strcmp(p1->data.ID,p2->data.ID)==-1)
    			{
    				l->data=p1->data;
    				p1->data=p2->data;
    				
    				p2->data=l->data;
    				
    				
    			}
    		}
    	}
        printf("降序排序成功\n");
    	PrntAll(head);
    		  
    }
    
    
    //按姓名排序
    void sortbyname(struct lnode *head)
    {
    	struct lnode *p1,*p2,*l;
    	
    	l=(struct lnode *)malloc(sizeof(struct lnode));                  
    	l->next=NULL;
    	
    	for (p1=head;p1->next!=NULL;p1=p1->next)
    	{
    		for (p2=p1->next;p2!=NULL;p2=p2->next)
    		{
    			if (strcmp(p1->data.name,p2->data.name)==-1)
    			{
    				l->data=p1->data;
    				p1->data=p2->data;
    				
    				p2->data=l->data;
    				
    				
    			}
    		}
    	}
        printf("降序排序成功\n");
    	PrntAll(head);
    		  
    }
    
    //按性别分类显示信息
    void sortbysex(struct lnode *head)
    {
    	struct lnode *p1,*p2,*l;
    	
    	l=(struct lnode *)malloc(sizeof(struct lnode));                  
    	l->next=NULL;
    	
    	for (p1=head;p1->next!=NULL;p1=p1->next)
    	{
    		for (p2=p1->next;p2!=NULL;p2=p2->next)
    		{
    			if (p1->data.sex>p2->data.sex)
    			{
    				l->data=p1->data;
    				p1->data=p2->data;
    				
    				p2->data=l->data;
    				
    				
    			}
    		}
    	}
        PrntAll(head);
    		  
    }
    
    
    //按年龄分类显示信息
    void sortbyage(struct lnode *head)
    {
    	struct lnode *p1,*p2,*l;
    	
    	l=(struct lnode *)malloc(sizeof(struct lnode));                  
    	l->next=NULL;
    	
    	for (p1=head;p1->next!=NULL;p1=p1->next)
    	{
    		for (p2=p1->next;p2!=NULL;p2=p2->next)
    		{
    			if (p1->data.age>p2->data.age)
    			{
    				l->data=p1->data;
    				p1->data=p2->data;
    				
    				p2->data=l->data;
    				
    				
    			}
    		}
    	}
        PrntAll(head);
    		  
    }
    
    
    //按电话分类显示信息
    void sortbyphone(struct lnode *head)
    {
    	struct lnode *p1,*p2,*l;
    	
    	l=(struct lnode *)malloc(sizeof(struct lnode));                  
    	l->next=NULL;
    	
    	for (p1=head;p1->next!=NULL;p1=p1->next)
    	{
    		for (p2=p1->next;p2!=NULL;p2=p2->next)
    		{
    			if (strcmp(p1->data.phone,p2->data.phone)==-1)
    			{
    				l->data=p1->data;
    				p1->data=p2->data;
    				
    				p2->data=l->data;
    				
    				
    			}
    		}
    	}
        PrntAll(head);
    		  
    }
    
    
    //按地址分类显示信息
    void sortbyaddress(struct lnode *head)
    {
    	struct lnode *p1,*p2,*l;
    	
    	l=(struct lnode *)malloc(sizeof(struct lnode));                  
    	l->next=NULL;
    	
    	for (p1=head;p1->next!=NULL;p1=p1->next)
    	{
    		for (p2=p1->next;p2!=NULL;p2=p2->next)
    		{
    			if (strcmp(p1->data.address,p2->data.address)==-1)
    			{
    				l->data=p1->data;
    				p1->data=p2->data;
    				
    				p2->data=l->data;
    				
    				
    			}
    		}
    	}
        PrntAll(head);
    		  
    }
    
    
    //按工资分类显示信息
    void sortbypay(struct lnode *head)
    {
    	struct lnode *p1,*p2,*l;
    	
    	l=(struct lnode *)malloc(sizeof(struct lnode));                  
    	l->next=NULL;
    	
    	for (p1=head;p1->next!=NULL;p1=p1->next)
    	{
    		for (p2=p1->next;p2!=NULL;p2=p2->next)
    		{
    			if (strcmp(p1->data.pay,p2->data.pay)==-1)
    			{
    				l->data=p1->data;
    				p1->data=p2->data;
    				
    				p2->data=l->data;
    				
    				
    			}
    		}
    	}
        PrntAll(head);
    		  
    }
    //按邮件地址分类显示信息
    void sortbyemil(struct lnode *head)
    {
    	struct lnode *p1,*p2,*l;
    	
    	l=(struct lnode *)malloc(sizeof(struct lnode));                  
    	l->next=NULL;
    	
    	for (p1=head;p1->next!=NULL;p1=p1->next)
    	{
    		for (p2=p1->next;p2!=NULL;p2=p2->next)
    		{
    			if (strcmp(p1->data.email,p2->data.email)==-1)
    			{
    				l->data=p1->data;
    				p1->data=p2->data;
    				
    				p2->data=l->data;
    				
    				
    			}
    		}
    	}
        PrntAll(head);
    		  
    }
    
    //按部门分类显示信息
    void sortbyoffice(struct lnode *head)
    {
    	struct lnode *p1,*p2,*l;
    	
    	l=(struct lnode *)malloc(sizeof(struct lnode));                  
    	l->next=NULL;
    	
    	for (p1=head;p1->next!=NULL;p1=p1->next)
    	{
    		for (p2=p1->next;p2!=NULL;p2=p2->next)
    		{
    			if (strcmp(p1->data.office,p2->data.office)==-1)
    			{
    				l->data=p1->data;
    				p1->data=p2->data;
    				
    				p2->data=l->data;
    				
    				
    			}
    		}
    	}
        PrntAll(head);
    		  
    }
    
    //按密码进入系统
    void password()
    {
    	char password[7]="123456"; 
    
    	int choice; 
    	char s[7]; 
    	int flag=0; 
    	int n=3; 
    	do 
    	{ 
    		printf("请你输入密码:\n"); 
    		scanf("%s",s); 
    		if(strcmp(s,password)==0)//若密码正确 
    		{ 
    			printf("恭喜你成功登陆了\n\n\n"); 
    			flag=1; 
    			
    			break; 
    		} 
    		else 
    		{ 
    			printf("输入有错误请重新输入:\n"); 
    			n--; 
    		} 
    	}while(n>0); 
    	
    	if(!flag) 
    	{ 
    		printf("哈哈,O(∩_∩)O哈!,想暴力破解是行不通的\n"); 
    		puts("若有有问题留言区交流");
    		exit(0); 
    
    	}
    }

    做报告课程设计也是在网上找到了很多好的资源,感谢原作者的分享,现在也记不清名字啦,不过也学习网友们的无私奉献精神,把资料分享给大家,帮助更多的朋友吧

    相关文章推荐:

    1、 C语言学生成绩管理系统源代码 ★★★★★

    2、 C语言学籍管理系统源代码 ★★

    3、C语言学生成绩管理系统设计 《C语言程序设计》实训报告 ★★★

    4、C语言学生信息管理系统源代码 ★★★

    感谢阅读!

    展开全文
  • 员工信息管理系统是基于Linux 多线程并发服务器编程,由服务器端和客户端构成,客户端可以运行在多个不同的主机上连接服务器,服务器对员工信息的操作结果通过“员工信息文件”来保存,即:“员工信息”存放在后台的...
  • 工资管理系统c语言

    2018-07-31 10:46:39
    员工工资管理系统,数据结构:struct Salary_Info{ char Card_No[20]; //工资卡号 char name[20]; //姓名 int month; //月份 float Init_Salary; //应发工资 float Water_Rate; //水费 float Electric_Rate;...
  • 员工信息管理系统--C语言

    万次阅读 多人点赞 2017-07-22 16:57:14
    员工信息管理系统 1.管理员模块:密码验证成功后,进入管理员菜单选项,管理员可以进行:  1)采集信息

    员工信息管理系统

     一. 目的

    C语言的课设选择了员工管理系统, 处理的对象为员工的信息,分为3个端(管理员,普通员工,部门经理)登录。进入主函数首先读取文件内容,其次用户选择登录身份,验证登录密码,其次选择每个登录身份的各项功能。存在文件及文件之间的交互,*输入密码等。

    二. 功能模块图





    三.各功能简单描述

    1.管理员模块:

    密码验证成功后,进入管理员菜单选项,管理员可以进行:

          1采集信息(添加员工信息,添加部门经理信息):添加信息后选择是否保存,若保存将员工(部门经理)信息保存到存放员工(部门经理)信息的文件(staff.txt/manager.txt),其中添加员工信息时每种输入都有限制,如名字只能输入中文、工号只能输入小于等于8位的数字、电话只能输入11位的数字等,输入工号、电话的时候会有查重提示,输入部门和职位时只能输入公司机构文件存在的本公司现有的部门和职位,在公司机构文件里面查找,保证员工基本资金与职位对应。

          2管理员工信息(查找、修改、删除、排序):其中修改、删除后需要选择是否将改动信息保存到文件。

          3浏览员工信息,按照报表的格式输入公司所有员工的信息。

          4管理登录密码(管理员密码、员工密码、经理密码):若是管理管理员密码,因为管理员只有一个,所以直接将存放管理员密码文件的数据修改,若是管理员工和经理密码找到对应员工或经理修改其密码

          5管理公司机构:管理员为公司添加新的部门、职位、和职位对应的工资,添加时存在查重。

          6)查看公司现有机构:输出该公司现存在部门、职位。

     

    2.普通员工模块:

    密码验证成功后,进入菜单选项,管理员可以进行:

          1)查询员工信息:该公司是公开,所以员工可以查询公司每个员工的信息。

          2)修改自己的信息:员工只能修改自己的基础信息(姓名,工号,电话),不能修改请假、迟到、加班信息。

          3查看加班信息:可以查看自己的部门经理给其分配的加班天数

          4)发送请假请求:向经理发送请假请求,将发送请求的员工保存到另外一个文件,等待经理审核。


    3.部门经理模块:

          1)采集员工信息:经理有权利添加员工。

          2)浏览所有员工信息:经理可以查看该公司所有员工的信息

          3查看本部门员工信息:将经理所在部门的员工信息以报表的形式输出

          4)通知本部门员工加班信息:经理只能通知自己部门的员工加班,无权给其他部门员工给予加班信息,通知加班信息时加班时间不能(压榨员工)太长。

          5)审核请假信息:经理读取需要请假的员工文件,进行审核,若批准将员工信息的请假次数修改,若不批准则不改动。

    四.程序部分运行










    大一结束了,C语言也学完了,为了课设第一次写这么长的代码,下面是我的课设代码,在vc++6.0运行的,如果要复制查看的换运行程序后会出现多个.txt ( 其中manage.txt存放管理员密码,刚开始要手动打开.txt给里面添加密码,不然无法进行之后的程序 ), 刚开始程序有有点low....之后改了好多,输入也加了好多限制,不过应该有没发现的bug,希望大佬们别吐槽。奋斗

    #include <stdio.h>  
    #include <conio.h>  
    #include <string.h>  
    #include <stdlib.h>
    #include <windows.h>
    #include <malloc.h>
    //员工:姓名 工号 电话 部门 职位 密码 工资(实际工资,基本工资,扣款(迟到/请假) ,奖金(加班天数))
    struct wage  
    {  
    	  int real;//实际工资
          int base;//基本工资
    	  int cut;//扣款( 迟到-10,请假-5 )
    	  int bonus;//奖金( 加班60 )
    };
    typedef struct staff 
    {
    	char name[20];
    	char number[20];
    	char phone[20];
    	char depart[20];//部门	
    	char post[20];//职位
    	char password[20];
    	int late;//迟到次数
    	int leave;//请假次数
    	int over;//加班天数
        struct wage z;
    	struct staff *next;
    }sta;
    sta *head,*u,*p,*q,*wj,*t;//头指针
    //部门经理:  姓名 工号 所管部门 密码
    typedef struct manager
    {
    	char mname[20];
    	char mnumber[20];
    	char mdepart[20];//所管部门
    	char mpassword[20];
    	struct manager *next;
    }mana;
    mana *mhead,*mu,*mp,*mq,*mwj,*mt;
    //*************************************************************************************************************
    typedef struct begin//管理员输入的初始部门
    {
    	char bdepart[20];
    	char bpost[20];
    	int bbase;
    	struct begin *next;
    }beg;
    beg *bhead,*bu,*bp,*bq,*bwj,*bt;
    typedef struct gobye
    {
    	char gnumber[20];
    	int gleave;//请假次数
    	struct gobye *next;
    }gob;
    //员工个数
    int n;
    char nei;
    //员工登录工号 员工查找自己信息	
    char sdl[100];
    char ddepart[100];//登录经理所管的部门
    char look[100];//查找重复的时候使用
    //*********************************************函数声明*****************************************
    sta* new_node(sta* uu);
    mana* mnew_node(mana* uu);
    void add();void s_add();void m_add();
    void modify();  void modi_all();void modi_num();void modi_name();  void modi_phone();	
    void del();	void del_name(); void del_num(); void del_phone();
    void sort();void sort_name();void sort_num();void sort_real();void sort_late();void sort_leave();void sort_over();
    void find();void find_sta();void find_depart();void find_name();void find_num();void find_phone();void find_namenum();
    void lookover();void callover();void overday();int overname();//关于加班
    void askleave();void giveleave();//关于请假
    void display();void adminxx();
    void save();void read();void msave();void mread();gob* learead();void leasave();
    void exi();void admin();void staff();void manager();void mjinru();
    void mmgl();void stam();void manam();void adminm();
    void welcome();void gotoxy(int x, int y);//光标移动
    void begin();void begread();void begsave();void beg_show();void beg_add();//公司机构
    //**********************************************************************************************
    //构造员工结点函数   没有头结点
    sta* new_node(sta* uu)  
    {  
        uu = (sta*)malloc(sizeof(sta));  
        uu->next = NULL;  
        return uu;  
    }
    //构造部门经理结点函数   没有头结点
     mana* mnew_node(mana* uu)  
    {  
        uu = (mana*)malloc(sizeof(mana));  
        uu->next = NULL;  
        return uu;  
    } 
    //构造公司机构结点函数   没有头结点
    beg* bnew_node(beg* uu)  
    {  
        uu = (beg*)malloc(sizeof(beg));  
        uu->next = NULL;  
        return uu;  
    }
    //构造请假结点函数   没有头结点
    gob* gnew_node(gob* uu)  
    {  
        uu = (gob*)malloc(sizeof(gob));  
        uu->next = NULL;  
        return uu;  
    }
    
    void askleave()
    {
    	char c[20];
    	FILE *fp;
        for(u = head; u != NULL;u = u->next) 
        {  
            if(strcmp(u->number,sdl) == 0)  
            {  
    			printf("\t\t\t☆ 你可以向你所在部门的经理申请一次请假\n");
    			printf("\t\t\t☆ 友情提示: 请假太多一定不会被批准的\n");
    			printf("\t\t\t☆ 你在这个月已经请了%d次假(被批准的)\n",u->leave);
    			printf("\t\t\t☆ 你是否还要请假(y/n):"); 
    			while(1)
    			{
    				scanf("%s",c);
    				if( (strcmp(c,"n")!=0) && (strcmp(c,"y")!=0))
    				{
    					printf("\t\t\t☆请输入合法字符!\n");
    					printf("\t\t\t☆请重新输入: ");
    					fflush(stdin); //清除缓冲区 
    				}
    				if( (strcmp(c,"n")==0) || (strcmp(c,"y")==0))
    				{
    					break;
    				}
    			}
    			if((strcmp(c,"n")==0))
    			{
    				printf("\t\t\t☆你这次选择了不请假,此次操作不会告诉上级 ^.^\n");
    				return ;
    			}
    			if((strcmp(c,"y")==0))
    			{
    				printf("\t\t\t☆你这次选择了请假,此次操作将反馈给上级,请等待批准\n");
    				//fp=fopen("leave.txt","a+");          //进入程序时打开/建立该文件
    				//fclose(fp);	
    				fp=fopen("leave.txt","a+");
    				printf("\t\t\t☆你此次的请假信息将被记录\n");
    				fprintf(fp,"%s ",u->number);  
    				fprintf(fp,"%d\n",u->leave); 
    				fclose(fp);  
    			}
            }  
        } 
    }
    //读取请假文件
    gob * learead()  
    {  
        FILE *fp;
    	gob *ghead,*gu,*gr;
        ghead  = gr= (gob*)malloc(sizeof(gob));
    	ghead ->next=NULL;
    	//fp=fopen("leave.txt","a");          //进入程序时打开/建立该文件
    	//fclose(fp);
        if((fp=fopen("leave.txt","r"))==NULL)  
        {  
            return NULL;  
        }
        nei=fgetc(fp);
        if(nei==EOF)//文件内没东西时
    	{ 
    		return NULL;
    	}	
    	else
    	{
    		rewind(fp);
    	}
    	while(!feof(fp))  
    	{   
    		gu= (gob*)malloc(sizeof(gob));
    		fscanf(fp,"%s ",gu->gnumber);  
    		fscanf(fp,"%d\n",&gu->gleave);
    		gr->next=gu;
    		gu->next=NULL;
    		gr=gu;
    	}
    	fclose(fp);
    	return ghead;
    }
    void giveleave()
    { 
    	FILE *fp;
    	char c[20];
    	int m=0;
    	gob *ghead,*gu;
    	ghead=learead();//读入
        if(nei==EOF)//文件内没东西时
    	{ 
    		printf("\n\n\t\t\t☆ 暂时还没有员工需要请假\n");
    		return;
    	}	
        for(gu = ghead->next; gu!= NULL;gu = gu->next)  
        {  
            m++;  
            printf("\t\t\t☆ 第%d个代批准员工的请假记录\n",m);
    		printf("\t\t\t☆ 工号\t请假次数\n");
    		printf("\t\t\t☆ %s\t%d\n",gu->gnumber,gu->gleave);
    		printf("\t\t\t☆ 你是否批准?(y/n)");
    		while(1)
    		{
    			scanf("%s",c);
    			if( (strcmp(c,"n")!=0) && (strcmp(c,"y")!=0))
    			{
    				printf("\t\t\t☆请输入合法字符!\n");
    				printf("\t\t\t☆请重新输入: ");
    				fflush(stdin); //清除缓冲区 
    			}
    			if( (strcmp(c,"n")==0)|| (strcmp(c,"y")==0))
    			{
    				break;
    			}
    		}
    		if((strcmp(c,"n")==0))
    		{
    			printf("\t\t\t☆ 你狠心的拒绝了该员工此次的请假申请\n");
    			continue;
    		}
    		if((strcmp(c,"y")==0))
    		{
    			printf("\t\t\t☆ 你通过了该员工的请假申请\n");//请假次数加1
    			for(u = head; u != NULL;u = u->next) 
    			{  
    				if(strcmp(u->number,gu->gnumber) == 0)  
    				{  
    					printf("\t\t\t☆ 你将给员工记录这请假\n");
    					u->leave=gu->gleave+1;
    					u->z.cut=u->late*10+u->leave*5;   //扣款:迟到-10 请假-5 
    					u->z.real=u->z.base + u->z.bonus - u->z.cut;
    					save();
    					break;   
    				}  
    			} 
    		}
        }   
    	fp=fopen("leave.txt","w");          //进入程序时打开直接关闭相当于清空文件
        fclose(fp);
    	return;
    }
    
    
    void lookover()//员工查看加班时间   员工登录工号全局变量char sdl[20];
    {
        for(u = head; u != NULL;u = u->next) 
        {  
            if(strcmp(u->number,sdl) == 0)  
            {  
    			printf("\t\t\t☆ 你所在部门给你分配下来的本月加班%d天☆\n",u->over);
    			printf("\t\t\t☆ 小提示: 若时间不充足,你也可以返回上一步申请请假,等待批准\n");
                break;   
            }  
        } 
    }
    void overday()
    {
    	int j;
    	printf("\t\t\t☆ 输入你准备给分配本月的加班天数:");//匹配时输入加班时间
    	while(1)
    	{
    		j=scanf("%d",&u->over);
    		if(j!=1)
    		{
    			printf("\t\t\t☆ 加班天数是数字哦 ^.^ 请重新输入:");
    			fflush(stdin); //清除缓冲区 
    			u->over=1; //防止跳出循环 
    		}
    		else
    		{
    			if(u->over>32)
    			{
    				printf("\t\t\t☆ 哇,加班天数有点都多哦,经理也不能这么压榨劳苦人民吧\n");
    				printf("\t\t\tSo...^.^ 请你重新输入:");
    			}
    			if(j==1 && u->over<32)
    			{
    				u->z.bonus=u->over*60;      //奖金:加班60 
    				u->z.real=u->z.base + u->z.bonus - u->z.cut;
    				printf("\n\t\t\t--->修改成功!\n");
    				save();
    				break;
    			}
    		}
    	}
    }
    int overname()//经理通知加班时间*********************************
    { 
    	int k,m,j,l;//控制
    	char overname[20];
    	k=m=l=0;
    	printf("\t\t\t☆ 经理特权: 你可以让自己部门的员工进行加班哦\n ");
    	printf("\t\t\t☆ 小提示: 你可以先退回上一步查看自己部门的员工哦\n");
    	printf("\t\t\t☆ 输入你准备给分配加班员工的姓名:");
    	while(1)
    	{
    		scanf("%s",overname);
    		for(j=0;(size_t)j<strlen(overname);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    		{
    			if(overname[j]>=0 && overname[j]<=255)
    			{
    				printf("\t\t\t☆ 不是中文 ^.^ 请重新输入:");
    				break;
    			}
    			if(strlen(overname)>15)
    			{
    				printf("\t\t\t☆ 姓名过长了 ^.^ 请重新输入:");
    				break;
    			}
    			else k=1;
    		}
            if(k==1)
    		{
    			for(u = head->next; u != NULL;u = u->next)  
    			{  										 
    				if( strcmp(u->depart,ddepart)==0 && strcmp(u->name,overname)==0)//不是该部门的员工则跳过;
    				{
    						l=1;
    						return 1;	
    				}
    			}
    			if(l==0)
    			{
    				printf("\t\t\t☆ 哇,你不能让其他部门的员工加班 ");
    				return 0;
    			}
    			if(u==NULL && l==0)  
    			{  
    				printf("\t\t\t☆ 哇,你的部门还木有员工,怎么让别人加班呢(T▽T)!\n");
    				printf("\t\t\t☆ 小提示: 你可以退回上一步雇佣员工给你的部门增加人气哦");
    				return 0;  
    			}
    		}
    	}
    	return 0;
    }
    void callover()
    {
    	if(overname())
    	{
    		overday();
    	}
    	else
    		return;
    }
    //打印该公司机构
    void beg_show()  
    {  
        if(bhead->next == NULL)  
        {  
            printf("\t\t\t--->该公司的公司机构还没有录入!\n");  
            return;  
        }
    	printf("☆友情提示:该公司现有部门和职位\n");
        puts("部门            职位            \n");  
        for(bu = bhead->next; bu!= NULL;bu = bu->next)  
        {    
    		printf("%-15s %-15s ",bu->bdepart,bu->bpost);
    		printf("\n");
        }   
    }  
    //添加公司机构********************************************************8888
    void beg_add()  
    { 
    	int j,m;//控制
    	char c[20];
    	bu = bnew_node(bu);  //新建一个节点
        printf("\t\t\t****************采集公司机构信息***************\n");
    	while(1)
    	{
            printf("\t\t\t*部门:__\b\b");//查重*********************************************************
    	    scanf("%s",bu->bdepart);
    		for(j=0;(size_t)j<strlen(bu->bdepart);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    		{
    			if(bu->bdepart[j]>=0 && bu->bdepart[j]<=255)
    			{
    				printf("\t\t\t不是中文呢 ^.^\t请重新输入\n");
    				break;
    			}
    			if(strlen(bu->bdepart)>15)
    			{
    				printf("\t\t\t部门输入过长 ^.^\t请重新输入\n");
    				break;
    			}
    		}
    		strcpy(look,bu->bdepart);//查重
    		for(bt = bwj->next; bt != NULL;bt = bt->next)  
    		{  
    			if(strcmp(bt->bdepart,look) == 0)  
    			{
    				m=0;
    				printf("\t\t\t该公司已经存在该部门了呦 ^.^\n ");
    				printf("\t\t\t您是否要新建部门? (y/n)");
    				while(1)
    				{
    					scanf("%s",c);
    					if( (strcmp(c,"n")!=0) && (strcmp(c,"y")!=0))
    					{
    						printf("\t\t\t请输入合法字符!\n");
    						printf("\t\t\t请重新输入: ");
    						fflush(stdin); //清除缓冲区 
    					}
    					if( (strcmp(c,"n")==0) || (strcmp(c,"y")==0))
    					{
    						break;
    					}
    				}
    				if((strcmp(c,"n")==0))
    				{
    					printf("\t\t\t不新建部门 ^.^\n");
    					m=1 ;
    					break;
    				}
    				printf("\t\t\t新建部门请重新命名 ^.^\n");
    				break;
    			} 
    			if(strcmp(bt->bdepart,look) != 0)  
    			{ 
    				continue;
    			}
    		}
    		if(bt==NULL)//新的工号时
    		{
    				m=1;
    		}
    		if(strlen(bu->bdepart)<=15 && (size_t)j==strlen(bu->bdepart)&&m==1)
    		{
    			break;
    		}
    	}
    	while(1)
    	{
    		printf("\t\t\t*职位:__\b\b");//查重***********************************************************
    		scanf("%s",bu->bpost);
    		for(j=0;(size_t)j<strlen(bu->bpost);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    		{
    			if(bu->bpost[j]>=0 && bu->bpost[j]<=255)
    			{
    				printf("\t\t\t不是中文呢 ^.^ 请重新输入\n");
    				break;
    			}
    			if(strlen(bu->bpost)>15)
    			{
    				printf("\t\t\t职位输入过长 ^.^ 请重新输入\n");
    			}
    		}
    		strcpy(look,bu->bpost);//查重
    		for(bt = bwj->next; bt != NULL;bt = bt->next)  
    		{  
    			if(strcmp(bt->bpost,look) == 0)  
    			{
    				m=0;
    				printf("\t\t\t该公司已经存在该职位了呦 ^.^ 新建职位请重新命名\n ");
    				break;
    			} 
    			if(strcmp(bt->bpost,look) != 0)  
    			{ 
    				continue;
    			}
    		}
    		if(bt==NULL)//新的工号时
    		{
    				m=1;
    		}
    		if(strlen(bu->bpost)<=15 && (size_t)j==strlen(bu->bpost) && m==1)
    		{
    			break;
    		}
    	}
    	while(1)
    	{
    		printf("\t\t\t*基本工资:");
    		j=scanf("%d",&bu->bbase);
    		if(j!=1)
    		{
    			printf("\t\t\t工资是数字哦 ^.^\t请重新输入\n");
    			fflush(stdin); //清除缓冲区 
    			bu->bbase=1; //防止跳出循环 
    		}
    		if(j==1)
    		{
    			if(bu->bbase>20000)
    			{
    				printf("\t\t\t亲,这个工资有点高哦,请检查是不是手误啦\n");
    				printf("\t\t\t ^.^请重新输入\n");
    			}
    			if(j==1 && bu->bbase<=20000)
    			{
    				break;
    			}
    		}
    	}
        bu->next = bhead->next;  //采用头插法将新节点的尾指针指向第二个节点
        bhead->next = bu;  //将新节点放在头节点后面
        printf("\n\t\t\t--->采集成功!\n"); 
    	begsave();
    	printf("\n\t\t\t");
    	system("pause");
    	system("cls");
    }
    
    //读取公司机构文件
    void begread()  
    {  
    	char a[100];//存放读取的汉字
        FILE *fp;
    	char ch;
    	fp=fopen("begin.txt","a+");          //进入程序时打开/建立该文件
    	fclose(fp);
        if((fp=fopen("begin.txt","r"))==NULL)  
        {  
            printf("\n\t\t\t--->没有找到文件!\n");  
            return ;  
        }
        ch=fgetc(fp);
        if(ch==EOF)
    		{
    			return;
    		}
    	else
    		rewind(fp);
    	fgets(a,20,fp);//读取第一行汉字信息
    	while(!feof(fp))  
    	{   
    		bu = bnew_node(bu);
    		fscanf(fp,"%s %s ",bu->bdepart,bu->bpost);  
    		fscanf(fp," %d\n",&bu->bbase);
    		bu->next = bhead->next; //头插法建立链表 
    		bhead->next = bu;  
    	}
    	fclose(fp);	
    }
    //保存公司机构信息
    void begsave()
    {
    	char c[20];
    	FILE *fp;
        printf("\n\t\t\t确认保存?(y/n): ");  
    	while(1)
    	{
    	    scanf("%s",c);
    		if( (strcmp(c,"n")!=0) && (strcmp(c,"y")!=0))
    		{
    			printf("\t\t\t请输入合法字符!\n");
    			printf("\t\t\t请重新输入: ");
    			fflush(stdin); //清除缓冲区 
    		}
    		if( (strcmp(c,"n")==0) || (strcmp(c,"y")==0))
    		{
    			break;
    		}
    	}
        if((strcmp(c,"n")==0))
    	{
    		printf("\t\t\t不保存哦 ^.^\n");
            return ;
    	}
        if((fp=fopen("begin.txt","w+"))==NULL)  
        {  
            printf("\n\t\t\t--->begin.txt文件打开失败!\n");
            return ;  
        }
    	fputs("部门 职位 基本工资\n",fp);
    //从头节点开始依次写入文件;
        for(bu = bhead->next; bu != NULL;bu = bu->next)  
        { 
            fprintf(fp,"%s %s ",bu->bdepart,bu->bpost);  
            fprintf(fp,"%d\n",bu->bbase);
        }  
        fclose(fp);  
        printf("\n\t\t\t--->信息成功存入\n"); 
    }
    //添加员工信息
    void s_add()  
    { 
    
    	int j;
    	int m,k,l=0;//控制
    	u = new_node(u);  //新建一个节点
        printf("\t\t\t┏━━━━━━━━━━━━━━采集员工信息━━━━━━━━━━━━━━━┓\n");
    	printf("\t\t\t┃                                                                      ┃\n");
    	printf("\t\t\t┃姓名:                                                                 ┃\n");
    	printf("\t\t\t┃                                                                      ┃\n");
    	printf("\t\t\t┃工号:                                                                 ┃\n");
    	printf("\t\t\t┃                                                                      ┃\n");
    	printf("\t\t\t┃电话:                                                                 ┃\n");
    	printf("\t\t\t┃                                                                      ┃\n");
    	printf("\t\t\t┃部门:                                                                 ┃\n");
    	printf("\t\t\t┃                                                                      ┃\n");
    	printf("\t\t\t┃职位:                                                                 ┃\n");
    	printf("\t\t\t┃                                                                      ┃\n");
    	printf("\t\t\t┃密码:                                                                 ┃\n");
    	printf("\t\t\t┃                                                                      ┃\n");
    	printf("\t\t\t┃迟到次数:                                                             ┃\n");
    	printf("\t\t\t┃                                                                      ┃\n");
        printf("\t\t\t┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
    	while(1)
    	{
    		gotoxy(32,2);
    		scanf("%s",u->name);
    		for(j=0;(size_t)j<strlen(u->name);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    		{
    			if(u->name[j]>=0 && u->name[j]<=255)
    			{
    				gotoxy(32,2);
    				printf("不是中文 ^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,2);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    			if(strlen(u->name)>15)
    			{
    				gotoxy(32,2);
    				printf("姓名过长了 ^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,2);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    		}
    		if(strlen(u->name)<=15&&(size_t)j==strlen(u->name))
    		{
    			break;
    		}
    	}
    	while(1)
    	{
    		gotoxy(32,4);
    	    scanf("%s",u->number);
    		for(j=0;(size_t)j<strlen(u->number);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    		{
    			if(u->number[j]<'0' || u->number[j]>'9')   
    			{
    				gotoxy(32,4);
    				printf("工号是数字哦 ^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,4);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    			if(strlen(u->number)>8)
    			{
    				gotoxy(32,4);
    				printf("工号控制在8位以内哦 ^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,4);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    		}
    		strcpy(look,u->number);//查重
    		for(t = wj->next; t != NULL;t = t->next)  
    		{  
    			if(strcmp(t->number,look) == 0)  
    			{
    				m=0;
    				gotoxy(32,4);
    				printf("该工号已经存在了哦 ^.^ 请重新给予一个工号 ");
    				Sleep(400);
    				gotoxy(32,4);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			} 
    			if(strcmp(t->number,look) != 0)  
    			{ 
    				continue;
    			}
    		}
    		if(t==NULL)//新的工号时
    		{
    				m=1;
    		}
    		if(strlen(u->number)<=8&& (size_t)j==strlen(u->number) && m==1)
    		{
    			break;
    		}
    	}
    	while(1)
    	{
    		gotoxy(32,6);
    	    scanf("%s",u->phone);
    		for(j=0;(size_t)j<strlen(u->phone);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    		{
    			if(u->phone[j]<'0' || u->phone[j]>'9')
    			{
    				gotoxy(32,6);
    				printf("电话是数字 ^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,6);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    			if(strlen(u->phone)!=11)
    			{
    				gotoxy(32,6);
    				printf("电话是11位 ^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,6);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    		}
    		strcpy(look,u->phone);//查重
    		for(t = wj->next; t != NULL;t = t->next)  
    		{  
    			if(strcmp(t->phone,look) == 0) 
    			{
    				m=0;
    				gotoxy(32,6);
    				printf("已经存在员工为电话了哦,不可能重复呀  ^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,6);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			} 
    			if(strcmp(t->phone,look) != 0)  
    			{ 
    				continue;
    			}
    		}
    		if(t==NULL)//新的电话时
    		{
    				m=1;
    		}
    		if(strlen(u->phone)==11&& (size_t)j==strlen(u->phone) && m==1)
    		{
    				break;
    		}
    	}
    	while(1)//应该输入公司之前存在的部门
    	{
    		gotoxy(32,8);
    	    scanf("%s",u->depart);
    		for(j=0;(size_t)j<strlen(u->depart);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    		{
    			if(u->depart[j]>=0 && u->depart[j]<=255)
    			{
    				gotoxy(32,8);
    				printf("不是中文 ^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,8);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    			if(strlen(u->depart)>15)
    			{
    				gotoxy(32,8);
    				printf("部门输入过长 ^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,8);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    			l=1;//输入符合 接下来判断是否存在
    		}
    		if(l==1)
    		{
    			strcpy(look,u->depart);//检查输入的部门是否为公司机构文件之前存在的
    			for(bt = bwj->next; bt != NULL;bt = bt->next)  
    			{  
    				if(strcmp(bt->bdepart,look) == 0)  //存在时满足
    				{
    					m=1;
    					break;
    				} 
    				if(strcmp(bt->bdepart,look) != 0)  
    				{ 
    					m=0;
    					continue;
    				}
    			}
    			if(m==0)// 请重新输入或者回到机构管理添加
    			{
    				gotoxy(32,8);
    				printf("该公司还没有此部门,^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,8);
    				for(k=0;k<55;k++)
    					printf(" ");
    			}
    			if(strlen(u->depart)<=15 && (size_t)j==strlen(u->depart)&& m==1)
    			{
    				break;
    			}
    		}
    	}
    	while(1)
    	{
    		gotoxy(32,10);
    		scanf("%s",u->post);
    		for(j=0;(size_t)j<strlen(u->post);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    		{
    			if(u->post[j]>=0 && u->post[j]<=255)
    			{
    				gotoxy(32,10);
    				printf("不是中文呢 ^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,10);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    			if(strlen(u->post)>15)
    			{
    				gotoxy(32,10);
    				printf("职位输入过长 ^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,10);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    			l=1;
    		}
    		if(l==1)
    		{
    			strcpy(look,u->post);//检查输入的职位是否为公司机构文件之前存在的
    			for(bt = bwj->next; bt != NULL;bt = bt->next)  
    			{  
    				if(strcmp(bt->bpost,look) == 0)  //存在时满足
    				{
    					m=1;
    					break;
    				} 
    				if(strcmp(bt->bpost,look) != 0)  
    				{ 
    					m=0;
    					continue;
    				}
    			}
    			if(m==0)// 请重新输入或者回到机构管理添加
    			{
    				gotoxy(32,10);
    				printf("该公司还没有此职位,^.^ 请重新输入");
    				Sleep(400);
    				gotoxy(32,10);
    				for(k=0;k<55;k++)
    					printf(" ");
    			}
    		}
    		if(strlen(u->post)<=15 && (size_t)j==strlen(u->post) && m==1)
    		{
    			break;
    		}
    	}
    	while(1)
    	{
    		gotoxy(32,12);
    		scanf("%s",u->password);
    		if(strlen(u->password)>15)
    		{
    			gotoxy(32,12);
    			printf("密码输入过长 ^.^ 请重新输入");
    			Sleep(400);
    			gotoxy(32,12);
    			for(k=0;k<55;k++)
    				printf(" ");
    		}
    		if(strlen(u->password)<=15)
    		{
    			break;
    		}
    	}
    	while(1)//迟到次数是输入的
    	{
    		gotoxy(35,14);
    		j=scanf("%d",&u->late);
    		if(j!=1)
    		{
    			gotoxy(35,14);
    			printf("迟到次数是数字哦 ^.^ 请重新输入");
    			Sleep(400);
    			gotoxy(35,14);
    			for(k=0;k<55;k++)
    				printf(" ");
    			fflush(stdin); //清除缓冲区 
    			u->late=1; //防止跳出循环 
    		}
    		else
    		{
    			if(u->late>100)
    			{
    				gotoxy(35,14);
    				printf("亲,迟到次数有点多哦,手误了吧 ^.^请重新输入");
    				Sleep(300);
    				gotoxy(35,14);
    				for(k=0;k<55;k++)
    					printf(" ");
    			}
    			if(j==1 && u->late<=100)
    			{
    				break;
    			}
    		}
    	}
    	u->leave=u->over=0;
        u->z.base=bt->bbase;
    	u->z.bonus=u->z.real=u->z.cut=0;
    	u->z.bonus=u->over*60;      //奖金:加班60
    	u->z.cut=u->late*10+u->leave*5;   //扣款:迟到-10 请假-5 
    	u->z.real=u->z.base + u->z.bonus - u->z.cut;
        u->next = head->next;  //采用头插法将新节点的尾指针指向第二个节点
        head->next = u;  //将新节点放在头节点后面
        printf("\n\t\t\t--->采集成功!\n"); 
    	save();
    	printf("\n\t\t\t");
    	system("pause");
    	system("cls");
    }
     //添加部门经理信息
    void m_add()  
    {
    	int j;
    	int m,k,l=0;//控制
    	mu = mnew_node(mu);  //新建一个节点
        printf("\t\t\t┏━━━━━━━━━━━━━━采集经理信息━━━━━━━━━━━━━━━┓\n");
    	printf("\t\t\t┃                                                                      ┃\n");
    	printf("\t\t\t┃姓名:                                                                 ┃\n");
    	printf("\t\t\t┃                                                                      ┃\n");
    	printf("\t\t\t┃工号:                                                                 ┃\n");
    	printf("\t\t\t┃                                                                      ┃\n");
    	printf("\t\t\t┃所管部门:                                                             ┃\n");
    	printf("\t\t\t┃                                                                      ┃\n");
    	printf("\t\t\t┃密码:                                                                 ┃\n");
    	printf("\t\t\t┃                                                                      ┃\n");
        printf("\t\t\t┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
    	while(1)
    	{
    		gotoxy(32,2);
    		scanf("%s",mu->mname);
    		for(j=0;(size_t)j<strlen(mu->mname);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    		{
    			if(mu->mname[j]>=0 && mu->mname[j]<=255)
    			{
    				gotoxy(32,2);
    				printf("不是中文 ^.^ 请重新输入");
    				Sleep(300);
    				gotoxy(32,2);
    				for(k=0;k<55;k++)
    				printf(" ");
    				break;
    			}
    			if(strlen(mu->mname)>15)
    			{
    				gotoxy(32,2);
    				printf("姓名过长了 ^.^ 请重新输入");
    				Sleep(300);
    				gotoxy(32,2);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    		}
    		if(strlen(mu->mname)<=15 && (size_t)j==strlen(mu->mname))
    		{
    			break;
    		}
    	}
    	while(1)
    	{
    		gotoxy(32,4);
    	    scanf("%s",mu->mnumber);
    		for(j=0;(size_t)j<strlen(mu->mnumber);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    		{
    			if(mu->mnumber[j]<'0' || mu->mnumber[j]>'9')
    			{
    				gotoxy(32,4);
    				printf("工号是数字哦 ^.^ 请重新输入");
    				Sleep(300);
    				gotoxy(32,4);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    			if(strlen(mu->mnumber)>8)
    			{
    				gotoxy(32,4);
    				printf("工号控制在8位以内哦 ^.^ 请重新输入");
    				Sleep(300);
    				gotoxy(32,4);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    		}
    		strcpy(look,mu->mnumber);//查重
    		for(mt = mwj->next; mt != NULL;mt = mt->next)  
    		{  
    			if(strcmp(mt->mnumber,look) == 0)  
    			{
    				m=0;
    				gotoxy(32,4);
    				printf("该工号已经存在了哦 ^.^ 请重新给予一个工号 ");
    				Sleep(300);
    				gotoxy(32,4);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			} 
    			if(strcmp(mt->mnumber,look) != 0)  
    			{ 
    				continue;
    			}
    		}
    		if(mt==NULL)//新的工号时
    		{
    				m=1;
    		}
    		if(strlen(mu->mnumber)<=8 && (size_t)j==strlen(mu->mnumber) && m==1)
    		{
    			break;
    		}
    	}
    	while(1)
    	{
    		gotoxy(35,6);
    	    scanf("%s",mu->mdepart);
    		for(j=0;(size_t)j<strlen(mu->mdepart);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    		{
    			if(mu->mdepart[j]>=0 && mu->mdepart[j]<=255)
    			{
    				gotoxy(35,6);
    				printf("不是中文 ^.^ 请重新输入");
    				Sleep(300);
    				gotoxy(35,6);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    			if(strlen(mu->mdepart)>20)
    			{
    				gotoxy(35,6);
    				printf("部门输入过长 ^.^ 请重新输入");
    				Sleep(300);
    				gotoxy(35,6);
    				for(k=0;k<55;k++)
    					printf(" ");
    				break;
    			}
    			l=1;
    		}
    		if(l==1)
    		{
    			strcpy(look,mu->mdepart);//检查输入的部门是否为公司机构文件之前存在的
    			for(bt = bwj->next; bt != NULL;bt = bt->next)  
    			{  
    				if(strcmp(bt->bdepart,look) == 0)  //存在时满足
    				{
    					m=1;
    					break;
    				} 
    				if(strcmp(bt->bdepart,look) != 0)  
    				{ 
    					m=0;
    					continue;
    				}
    			}
    			if(m==0)// 请重新输入或者回到机构管理添加
    			{
    				gotoxy(35,6);
    				printf("该公司还没有此部门,^.^ 请重新输入");
    				Sleep(300);
    				gotoxy(35,6);
    				for(k=0;k<55;k++)
    					printf(" ");
    			}
    			if(strlen(mu->mdepart)<=20 && (size_t)j==strlen(mu->mdepart) && m==1)
    			{
    				break;
    			}
    		}
    	}
    	while(1)
    	{
      		gotoxy(32,8);
    		scanf("%s",mu->mpassword);
    		if(strlen(mu->mpassword)>15)
    		{
    			gotoxy(32,8);
    			printf("密码输入过长 ^.^ 请重新输入");
    			Sleep(300);
    			gotoxy(32,8);
    			for(k=0;k<55;k++)
    				printf(" ");
    		}
    		if(strlen(mu->mpassword)<=20)
    		{
    			break;
    		}
    	}
        mu->next = mhead->next;  //采用头插法将新节点的尾指针指向第二个节点(掰开)
        mhead->next = mu;  //将新节点放在头节点后面
        printf("\n\t\t\t--->添加成功!\n"); 
    	msave();
    }
    void add()
    {
    	int chioce;
    	do
    	{
    		printf("\n");
        	printf("\t\t\t***********************************\n");
         	printf("\t\t\t*        1.采集员工信息           *\n");			
         	printf("\t\t\t*        2.采集部门经理信息       *\n");
        	printf("\t\t\t*        3.返回上一步             *\n");
        	printf("\t\t\t*        0.退出                   *\n");
        	printf("\t\t\t***********************************\n");
        	printf("\t\t\t请选择:");
        	if(scanf("%d",&chioce))
    		{
    			system("cls");
    			switch(chioce)
        		{  
            		case 1:s_add();break;
             		case 2:m_add();break;
            		case 3:return;
    				case 0:exi(); break;
            		default:printf("\n\t\t\t--->没有该选项!\n"); 
        		}
    		}
    		else
    		{
    			printf("\n\t\t\t不能输入非整型,请重新输入:");
    			fflush(stdin); //清除缓冲区 
    			chioce=1; //防止跳出循环 
    		}
    	}while(chioce!=0);
    	return;
    }
    //修改函数  也可再里面弄一个整体修改小函数
    void modify()
    {
    	int chioce;
        if(head->next == NULL)  
        {  
            printf("\t\t\t--->没有员工信息!");  
            return ;  
        }
    	do
    	{
    		printf("\n");
    	    printf("\t\t\t********************************\n");
         	printf("\t\t\t*        1.按姓名修改          *\n");
         	printf("\t\t\t*        2.按工号修改          *\n");
         	printf("\t\t\t*        3.按电话修改          *\n");
    		printf("\t\t\t*        4.返回上一步          *\n");
        	printf("\t\t\t*        0.退出                *\n");
        	printf("\t\t\t********************************\n");
          	printf("\t\t\t请选择:");
         	if(scanf("%d",&chioce))
    		{
    			system("cls");
        	    switch(chioce)
    			{  
    			case 1:modi_name();break;
         		case 2:modi_num();break;
         		case 3:modi_phone();break;
        		case 4:return;
        		default:printf("\n--->无效的指令!\n");
    			}
    		}
    		else
    		{
    			printf("\n\t\t\t不能输入非整型,请重新输入:");
    			fflush(stdin); //清除缓冲区 
    			chioce=1; //防止跳出循环 
    		}
    	}while(chioce!=0);
    	return;
    }
    
    void modi_all()
    {						
    	int chioce;	
    	int j;
    	do
    	{
    		printf("\n");
    	    printf("\t\t\t*********************修改信息*********************\n");
         	printf("\t\t\t*        1.修改姓名         2.修改工号           *\n");
         	printf("\t\t\t*        3.修改电话         4.调动部门           *\n");
         	printf("\t\t\t*        5.调动职位         6.修改基本工资       *\n");
         	printf("\t\t\t*        7.修改加班天数     8.修改迟到次数       *\n");
         	printf("\t\t\t*        9.修改请假次数     10.返回上一步        *\n");
    		printf("\t\t\t*        0.退出                                  *\n");
        	printf("\t\t\t**************************************************\n");
          	printf("\t\t\t请选择:");
         	if(scanf("%d",&chioce))
    		{
    			system("cls");
        	    switch(chioce)
    			{  
    			case 1:
    				{	
    					while(1)
    					{
    						printf("\t\t\t*请输入新的姓名: ");  
    						scanf("%s",u->name);
    						for(j=0;(size_t)j<strlen(u->name);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    						{
    							if(u->name[j]>=0 && u->name[j]<=255)
    							{
    								printf("\t\t\t不是中文呢 ^.^\t请重新输入\n");
    								break;
    							}
    							if(strlen(u->name)>15)
    							{
    								printf("\t\t\t姓名过长 ^.^\t请重新输入\n");
    								break;
    							}
    						}
    						if(strlen(u->name)<=15&&(size_t)j==strlen(u->name))
    						{
    							break;
    						}
    					}
    					printf("\n\t\t\t--->修改成功!\n");
    					save();
    					break;
    				}
         		case 2:
    				{
    					while(1)
    					{
    						printf("\t\t\t*请输入新的工号(8位以内):__\b\b");
    						scanf("%s",u->number);
    						for(j=0;(size_t)j<strlen(u->number);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    						{
    							if(u->number[j]<'1' || u->number[j]>'9')
    							{
    								printf("\t\t\t工号是数字 ^.^\t请重新输入\n");
    								break;
    							}
    							if(strlen(u->number)>=8)
    							{
    								printf("\t\t\t工号控制在8位以内 ^.^\t请重新输入\n");
    								break;
    							}
    						}
    						if(strlen(u->number)<8 && (size_t)j==strlen(u->number))
    						{
    							break;
    						}
    					}
    					printf("\n\t\t\t--->修改成功!\n");
    					save();
    					break;
    				}
    			case 3:
    				{
    					while(1)
    					{
    						printf("\t\t\t*请输入新的电话(11位):__\b\b");
    						scanf("%s",u->phone);
    						for(j=0;(size_t)j<strlen(u->phone);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    						{
    							if(u->phone[j]<'1' || u->phone[j]>'9')
    							{
    								printf("\t\t\t电话是数字 ^.^\t请重新输入\n");
    								break;
    							}
    							if(strlen(u->phone)!=11)
    							{
    								printf("\t\t\t电话是11位 ^.^\t请重新输入\n");
    								break;
    							}
    						}
    						if(strlen(u->phone)==11&& (size_t)j==strlen(u->phone))
    						{
    							break;
    						}
    					}
    					printf("\n\t\t\t--->修改成功!\n");
    					save();
    					break;
    				}
    			case 4:
    				{
    					while(1)
    					{
    						printf("\t\t\t*请输入新的部门:__\b\b");
    						scanf("%s",u->depart);
    						for(j=0;(size_t)j<strlen(u->depart);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    						{
    							if(u->depart[j]>=0 && u->depart[j]<=255)
    							{
    								printf("\t\t\t不是中文呢 ^.^\t请重新输入\n");
    								break;
    							}
    							if(strlen(u->depart)>20)
    							{
    								printf("\t\t\t部门输入过长 ^.^\t请重新输入\n");
    								break;
    							}
    						}
    						if(strlen(u->depart)<=20 && (size_t)j==strlen(u->depart))
    						{
    							break;
    						}
    					}
    
    					printf("\n\t\t\t--->修改成功!\n");
    					save();
    					break;
    				}
    			case 5:
    				{
    					while(1)
    					{
    						printf("\t\t\t*请输入新的职位:__\b\b");
    						scanf("%s",u->post);
    						for(j=0;(size_t)j<strlen(u->post);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    						{
    							if(u->post[j]>=0 && u->post[j]<=255)
    							{
    								printf("\t\t\t不是中文呢 ^.^\t请重新输入\n");
    								break;
    							}
    							if(strlen(u->post)>20)
    							{
    								printf("\t\t\t职位输入过长 ^.^\t请重新输入\n");
    							}
    						}
    						if(strlen(u->post)<=20 && (size_t)j==strlen(u->post))
    						{
    							break;
    						}
    					}
    
    					printf("\n\t\t\t--->修改成功!\n");
    					save();
    					break;
    				}
    			case 6:
    				{
    					while(1)
    					{
    						printf("\t\t\t*请输入新的基本工资:");
    						j=scanf("%d",&u->z.base);
    						if(j!=1)
    						{
    							printf("\t\t\t工资是数字哦 ^.^\t请重新输入\n");
    							fflush(stdin); //清除缓冲区 
    							u->z.base=1; //防止跳出循环 
    						}
    						if(j==1)
    						{
    							if(u->z.base>20000)
    							{
    								printf("\t\t\t亲,这个工资有点高哦,请检查是不是手误啦\n");
    								printf("\t\t\t ^.^请重新输入\n");
    							}
    							if(j==1 && u->z.base<=20000)
    							{
    								break;
    							}
    						}
    					}
    					u->z.bonus=u->over*60;      //奖金:加班60 补贴20%
    					u->z.real=u->z.base + u->z.bonus - u->z.cut;
    					printf("\n\t\t\t--->修改成功!\n");
    					save();
    					break;
    				}
    			case 7:
    				{
    					while(1)
    					{
    						printf("\t\t\t*请输入新的加班天数:");
    						j=scanf("%d",&u->over);
    						if(j!=1)
    						{
    							printf("\t\t\t加班天数是数字哦 ^.^\t请重新输入\n");
    							fflush(stdin); //清除缓冲区 
    							u->over=1; //防止跳出循环 
    						}
    						else
    						{
    							if(u->over>32)
    							{
    								printf("\t\t\t亲,加班天数比每月天数都多哦,请检查是不是手误啦\n");
    								printf("\t\t\t^.^请重新输入\n");
    							}
    							if(j==1 && u->over<32)
    							{
    								break;
    							}
    						}
    					}
    					u->z.bonus=u->over*60;      //奖金:加班60 
    					u->z.real=u->z.base + u->z.bonus - u->z.cut;
    					printf("\n\t\t\t--->修改成功!\n");
    					save();
    					break;
    				}
    			case 8:
    				{
    					while(1)
    					{
    						printf("\t\t\t*请输入新的迟到次数: ");
    						j=scanf("%d",&u->late);
    						if(j!=1)
    						{
    							printf("\t\t\t迟到次数是数字哦 ^.^\t请重新输入\n");
    							fflush(stdin); //清除缓冲区 
    							u->late=1; //防止跳出循环 
    						}
    						else
    						{
    							if(u->late>100)
    							{
    								printf("\t\t\t亲,这个迟到次数有点多哦,请检查是不是手误啦\n");
    								printf("\t\t\t^.^请重新输入\n");
    							}
    							if(j==1 && u->late<=100)
    							{
    								break;
    							}
    						}
    					}
    					u->z.cut=u->late*10+u->leave*5;   //扣款:迟到-10 请假-5 
    					u->z.real=u->z.base + u->z.bonus - u->z.cut;
    					printf("\n\t\t\t--->修改成功!\n");
    					save();
    					break;
    				}
    			case 9:
    				{
    					while(1)
    					{
    						printf("\t\t\t*请输入新的请假次数::");
    						j=scanf("%d",&u->leave);
    						if(j!=1)
    						{
    							printf("\t\t\t请假次数是数字哦 ^.^\t请重新输入\n");
    							fflush(stdin); //清除缓冲区 
    							u->leave=1; //防止跳出循环 
    						}
    						else
    						{
    							if(u->leave>100)
    							{
    								printf("\t\t\t亲,这个请假次数有点多哦,请检查是不是手误啦\n");
    								printf("\t\t\t^.^请重新输入\n");
    							}
    							if(j==1 && u->leave<=100)
    							{
    								break;
    							}
    						}
    					}
    					u->z.cut=u->late*10+u->leave*5;   //扣款:迟到-10 请假-5 
    					u->z.real=u->z.base + u->z.bonus - u->z.cut;
    					save();
    					printf("\n\t\t\t--->修改成功!\n");
    					break;
    				}
        		case 10:return;
        		default:printf("\n\t\t\t--->无效的指令!\n");
    			}
    		}
    		else
    		{
    			printf("\n\t\t\t不能输入非整型,请重新输入:");
    			fflush(stdin); //清除缓冲区 
    			chioce=1; //防止跳出循环 
    		}
    	}while(chioce!=0);
    	return;
    }
    //根据员工姓名修改信息
    void modi_name()  
    {  
    	char xname[100];
        n = 0;
        printf("\n\t\t\t请输入您要修改的员工姓名: ");  
        scanf("%s",xname);  
        for(u = head; u != NULL;u = u->next)  
        {  
            if(strcmp(u->name,xname) == 0)  
            {  
                n = 1;
    			printf("\t\t\t\t*员工初始信息*\n");
    			puts("      姓名          工号     电话        部门              职位      实际工资 基本工资 迟到 请假 加班 罚款 奖金\n");    
    			printf("%-15s %-8s %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    			printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
    			modi_all();
                break;  
            }  
        }  
        if(!n)  
            printf("\n\t\t\t--->没有这个学生的信息!\n");  
    }
    //根据员工工号修改信息
    void modi_num()
    {  
    	char xnum[20];
    	n = 0;
        printf("\n\t\t\t请输入您要修改员工的工号: ");  
        scanf("%s",xnum);  
        for(u = head; u != NULL;u = u->next)  
        {  
            if(strcmp(u->number,xnum) == 0)  
            {  
                n = 1;
    			printf("\t\t\t\t*员工初始信息*\n");
    			puts("      姓名          工号     电话        部门              职位      实际工资 基本工资 迟到 请假 加班 罚款 奖金\n");    
    			printf("%-15s %-8s %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    			printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
    			modi_all();
    			save();
                break;   
            }  
        }  
        if(!n)  
            printf("\n\t\t\t--->没有这个学生的信息!\n");  
    } 
    //根据员工电话修改信息
    void modi_phone()  
    {  
    	char xphone[20];
    	n = 0;
        printf("\n\t\t\t请输入您要修改员工的电话: ");  
        scanf("%s",xphone);  
        for(u = head; u != NULL;u = u->next)  
        {  
            if(strcmp(u->number,xphone) == 0)  
            {  
                n = 1;
    			printf("\t\t\t\t*员工初始信息*\n");
    			puts("      姓名          工号     电话        部门              职位      实际工资 基本工资 迟到 请假 加班 罚款 奖金\n");    
    			printf("%-15s %-8s %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    			printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
    			modi_all();
    			save();
                break;    
            }  
        }  
        if(!n)  
            printf("\n\t\t\t--->没有这个学生的信息!\n");  
    } 
    void del()			
    {
        int chioce;
        if(head->next == NULL)  
        {  
            printf("--->\t\t\t没有员工信息!");  
            return ;  
        }
    	do
    	{
    		printf("\n");
    	    printf("\t\t\t********************************\n");
         	printf("\t\t\t*        1.按姓名删除          *\n");
         	printf("\t\t\t*        2.按工号删除          *\n");
         	printf("\t\t\t*        3.按电话删除          *\n");
    		printf("\t\t\t*        4.返回上一步          *\n");
        	printf("\t\t\t*        0.退出                *\n");
        	printf("\t\t\t********************************\n");
          	printf("\t\t\t请选择:");
         	if(scanf("%d",&chioce))
    		{
        		switch(chioce)
    			{  
    			case 1:del_name();break;
         		case 2:del_num();break;
        		case 3:del_phone();break;
        		case 4:return;
        		default:printf("\n\t\t\t--->无效的指令!\n");
    			}
    		}
    		else
    		{
    			printf("\n\t\t\t不能输入非整型,请重新输入:");
    			fflush(stdin); //清除缓冲区 
    			chioce=1; //防止跳出循环 
    		}
    	}while(chioce!=0);
    	return;
    } 
    //根据姓名删除信息
    void del_name()  
    {  
    	char dname[100];
        n = 0;
        printf("\n\t\t\t请输入您要删除员工的姓名: ");  
        scanf("%s",dname);  
        for(u = head; u != NULL;u = u->next)  
        {  
            if(strcmp(u->name,dname) == 0)  
            {  
                n = 1;
    			printf("\t\t\t\t*员工信息*\n");
    			puts("      姓名          工号     电话        部门              职位      实际工资 基本工资 迟到 请假 加班 罚款 奖金\n");    
    			printf("%-15s %-8s %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    			printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
                p->next = u->next;  
                free(u);  
                printf("\n\t\t\t--->删除成功!\n");
    			save();
                break;  
            }  
            p = u;  
        }  
        if(!n)  
            printf("\n\t\t\t--->没有这个员工的信息!\n");  
    } 
    //根据工号删除信息
    void del_num()  
    {  
    	char dnum[20];
    	n = 0;
        printf("\n\t\t\t请输入您要删除员工的工号: ");  
        scanf("%s",dnum);  
        for(u = head; u != NULL;u = u->next)  
        {  
            if(strcmp(u->number,dnum) == 0)  
            {  
                n = 1; 
    			printf("\t\t\t\t*员工信息*\n");
    			puts("      姓名          工号     电话        部门              职位      实际工资 基本工资 迟到 请假 加班 罚款 奖金\n");    
    			printf("%-15s %-8s %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    			printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
                p->next = u->next;  
                free(u);  
                printf("\t\t\t\n--->删除成功!\n");
    			save();
                break; 
            }  
            p = u;  
        }  
        if(!n)  
            printf("\n\t\t\t--->没有这个员工的信息!\n");  
    }
    //根据电话删除信息
    void del_phone()  
    {  
    	char dphone[20];
    	n = 0;
        printf("\n\t\t\t请输入您要删除员工的电话: ");  
        scanf("%s",dphone);  
        for(u = head; u != NULL;u = u->next)  
        {  
            if(strcmp(u->number,dphone) == 0)  
            {  
                n = 1; 
    			printf("\t\t\t\t*员工信息*\n");
    			puts("      姓名          工号     电话        部门              职位      实际工资 基本工资 迟到 请假 加班 罚款 奖金\n");    
    			printf("%-15s %-8s %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    			printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
                p->next = u->next;  
                free(u);  
                printf("\n\t\t\t--->删除成功!\n");
    			save();
                break; 
            }  
            p = u;  
        }  
        if(!n)  
            printf("\n\t\t\t--->没有这个员工的信息!\n");  
    }
    void sort()	
    {
        int chioce;
    	if(head->next == NULL)  
        {  
            printf("\t\t\t--->没有员工信息!");  
            return ;  
        }
    	do
    	{
    		printf("\n");
    	    printf("\t\t\t************************************\n");
         	printf("\t\t\t*        1.按工号排序              *\n");
         	printf("\t\t\t*        2.按实际工资排序          *\n");
         	printf("\t\t\t*        3.按迟到次数排序          *\n");
         	printf("\t\t\t*        4.按请假次数排序          *\n");
         	printf("\t\t\t*        5.按加班天数排序          *\n");
    		printf("\t\t\t*        6.返回上一步              *\n");
        	printf("\t\t\t*        0.退出                    *\n");
        	printf("\t\t\t************************************\n");
          	printf("\t\t\t请选择:");
         	if(scanf("%d",&chioce))
    		{
    			system("cls");
        		switch(chioce)
    			{  		
         		case 1:sort_num();break;			
        		case 2:sort_real();break;
    			case 3:sort_late();break;
         		case 4:sort_leave();break;
        		case 5:sort_over();break;
        		case 6:return;
        		default:printf("\n\t\t\t--->无效的指令!\n");
    			}
    		}
    		else
    		{
    			printf("\n\t\t\t不能输入非整型,请重新输入:");
    			fflush(stdin); //清除缓冲区 
    			chioce=1; //防止跳出循环 
    		}
    	}while(chioce!=0);
    	return;
    }
    //按工号排序
    void sort_num()  
    {  
        int i,j;  
        n = 0;  //记录员工总数;
        for(u = head->next; u != NULL;u = u->next)  
            n++;  
    //采用冒泡法对各个节点按工号升序
        for(i=1;i<=n;i++)  
        {  
            u = head;  
            for(j=0;j<n-i;j++)  
            {  
                p = u->next;  
                q = p->next;  
                if(strcmp(p->number,q->number) > 0 || strcmp(p->number,q->number) == 0)  
                {  
                    u->next = q;  
                    p->next = q->next;  
                    q->next = p;  
                }  
                u = u->next;
            }  
        } 
    	printf("\t\t\t\t工号排序后员工信息\n");
    	display();
    	return;
    }
    //按实际工资排序
    void sort_real()  
    {  
        int i,j;  
        n = 0;  
        for(u = head->next; u != NULL;u = u->next)  
            n++;  
    //采用冒泡法对各个节点按工资升序
        for(i=1;i<=n;i++)  
        {  
            u = head;  
            for(j=0;j<n-i;j++)  
            {  
                p = u->next;  
                q = p->next;  
                if(p->z.real >= q->z.real)  
                {  
                    u->next = q;  
                    p->next = q->next;  
                    q->next = p;  
                }  
                u = u->next;  
            }  
        } 
    	printf("\t\t\t\t实际工资升序后员工信息\n");
    	display();
    	return;
    }  
    //按请假次数排序
    void sort_leave()  
    {  
        int i,j;  
    //记录学生总数;
        n = 0;  
        for(u = head->next; u != NULL;u = u->next)  
            n++;  
    //采用冒泡法对各个节点按请假次数降序排列
        for(i=1;i<=n;i++)  
        {  
            u = head;  
            for(j=0;j<n-i;j++)  
            {  
                p = u->next;  
                q = p->next;  
                if(p->leave < q->leave)  
                {  
                    u->next = q;  
                    p->next = q->next;  
                    q->next = p;  
                }  
                u = u->next;  
            }  
        } 
    	printf("\t\t\t\t请假次数降序后员工信息\n");
    	display();
    	return;
    }  
    //按迟到次数排序
    void sort_late()  
    {  
        int i,j;  
    //记录学生总数;
        n = 0;  
        for(u = head->next; u != NULL;u = u->next)  
            n++;  
    //采用冒泡法对各个节点按迟到次数降序排列
        for(i=1;i<=n;i++)  
        {  
            u = head;  
            for(j=0;j<n-i;j++)  
            {  
                p = u->next;  
                q = p->next;  
                if(p->late< q->late)  
                {  
                    u->next = q;  
                    p->next = q->next;  
                    q->next = p;  
                }  
                u = u->next;  
            }  
        } 
    	printf("\t\t\t\t迟到次数降序后员工信息\n");
    	display();
    	return;
    }  
     //按加班天数排序
    void sort_over()  
    {  
        int i,j;  
    //记录学生总数;
        n = 0;  
        for(u = head->next; u != NULL;u = u->next)  
            n++;  
    //采用冒泡法对各个节点按加班天数降序排列
        for(i=1;i<=n;i++)  
        {  
            u = head;  
            for(j=0;j<n-i;j++)  
            {  
                p = u->next;  
                q = p->next;  
                if(p->over < q->over)  
                {  
                    u->next = q;  
                    p->next = q->next;  
                    q->next = p;  
                }  
                u = u->next;  
            }  
        } 
    	printf("\t\t\t\t加班天数降序后员工信息\n");
    	display();
    	return;
    }  
    void find()
    {
    	int chioce;
    	do
    	{
    	    printf("\t\t\t********************************\n");
         	printf("\t\t\t*        1.按姓名查找          *\n");
         	printf("\t\t\t*        2.按工号查找          *\n");
         	printf("\t\t\t*        3.按电话查找          *\n");
         	printf("\t\t\t*        4.按姓名和工号查找    *\n");
    		printf("\t\t\t*        5.返回上一步          *\n");
        	printf("\t\t\t*        0.退出                *\n");
        	printf("\t\t\t********************************\n");
          	printf("\t\t\t请选择:");
         	if(scanf("%d",&chioce))
    		{
    			system("cls");
        		switch(chioce)			
    			{  
    			case 1:find_name();break;
         		case 2:find_num();break;
        		case 3:find_phone();break;
      		    case 4:find_namenum();break;
        		case 5:return;
        		default:printf("\n\t\t\t--->无效的指令!\n");
    			}
    		}
    		else
    		{
    			printf("\n\t\t\t不能输入非整型,请重新输入:");
    			fflush(stdin); //清除缓冲区 
    			chioce=1; //防止跳出循环 
    		}
    	}while(chioce!=0);
    	return;
    }
    //按姓名查找某一员工
    void find_name()  
    {  
    	char cname[20];//标志变量,记录是否查找成功;
    	n = 0;
    	printf("\t\t\t\t\t根据姓名查询信息\n");
        printf("\t\t\t请输入您要查询员工的姓名: ");  
        scanf("%s",cname);  
        for(u = head->next; u != NULL;u = u->next)  
        {  
            if(strcmp(u->name,cname) == 0)  
            {  
                n = 1;  
            puts("☆\t  姓名        工号      电话        部门             职位          实际工资  基本工资 迟到 请假 加班 罚款 奖金\n");  
        	printf("┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈\n");  
    		printf("\t  ┊%-10s %-8s  %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    		printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d┊\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
    		printf("┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈\n"); 
                break;  
            }  
        }  
        if(!n)  
            printf("\t\t\t--->该员工不存在哦(⊙o⊙)!\n");  
    }  
    //按工号查找某一学生成绩
    void find_num()  
    {  
    //标志变量,记录是否查找成功;
    	char cnum[20];
    	n = 0;
    	printf("\t\t\t\t\t根据工号查询信息\n");
        printf("\t\t\t请输入您要查询员工的工号: ");  
        scanf("%s",cnum);  
        for(u = head->next; u != NULL;u = u->next)  
        {  
            if(strcmp(u->number,cnum) == 0)  
            {  
                n = 1;  
            puts("☆\t  姓名        工号      电话        部门             职位          实际工资  基本工资 迟到 请假 加班 罚款 奖金\n");  
        	printf("┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈\n");  
    		printf("\t  ┊%-10s %-8s  %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    		printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d┊\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
    		printf("┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈\n"); 
                break;  
            }  
        }  
        if(!n)  
            printf("\t\t\t--->该员工不存在哦(⊙o⊙)!\n");  
    }
     
     //按电话查找某一员工
    void find_phone()  
    {  
    //标志变量,记录是否查找成功;
    	char cphone[20];
    	n = 0;
    	printf("\t\t\t\t\t根据电话查询信息\n");
        printf("\t\t\t请输入您要查询员工的电话: "); 
        scanf("%s",cphone);  
        for(u = head->next; u != NULL;u = u->next)  
        {  
            if(strcmp(u->phone,cphone) == 0)  
            {  
                n = 1;  
                printf("\n");  
            puts("☆\t  姓名        工号      电话        部门             职位          实际工资  基本工资 迟到 请假 加班 罚款 奖金\n");  
        	printf("┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈\n");  
    		printf("\t  ┊%-10s %-8s  %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    		printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d┊\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
    		printf("┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈\n"); 
                break;  
            }  
        }  
        if(!n)  
            printf("\t\t\t--->该员工不存在哦(⊙o⊙)!\n");  
    }  
    //按姓名和工号查找某一员工
    void find_namenum()  
    {
    //标志变量,记录是否查找成功;
    	char ch[20];
    	n = 0;
    	printf("\t\t\t\t\t根据姓名和工号查询信息\n");
        printf("\t\t\t请输入您要查询员工的姓名: "); 
        scanf("%s",ch);  
        for(u = head->next; u != NULL;u = u->next)  
        {  
            if(strcmp(u->name,ch) == 0)  
            { 
    			printf("\t\t\t请输入工号:");
    			while(1)
    			{
    				scanf("%s",ch);
    				if(strcmp(u->number,ch) == 0)
    				{
    					n = 1;  
    					printf("\n");  
            puts("☆\t  姓名        工号      电话        部门             职位          实际工资  基本工资 迟到 请假 加班 罚款 奖金\n");  
        	printf("┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈\n");  
    		printf("\t  ┊%-10s %-8s  %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    		printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d┊\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
    		printf("┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈\n"); 
    					break;
    				}
    				else
    				{
    					printf("\t\t\t工号与姓名不匹配!请重新输入工号:");
    					fflush(stdin);
    
    				}
    			}
            }  
        }  
        if(!n)  
            printf("\t\t\t--->该员工不存在哦(⊙o⊙)!\n");  
    }   
    //打印该公司所以员工的信息
    void display()  
    {   
        n=0;  
        if(head->next == NULL)  
        {  
            printf("--->没有员工信息!\n");  
            return ;  
        }  
        puts("☆\t  姓名        工号      电话        部门             职位          实际工资  基本工资 迟到 请假 加班 罚款 奖金\n");  
        	printf("┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈\n");
    	for(u = head->next; u!= NULL;u = u->next)  
        {  
            n++;  
    		printf("\t  ┊%-10s %-8s  %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    		printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d┊\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
    		printf("┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈\n");
        }  
        printf("\n该公司共有 %d个员工.\n\n",n);  
    }  
    //保存员工文件;
    void save()  
    {  
    	char c[20];
    	FILE *fp;
        printf("\n\t\t\t确认保存?(y/n): ");  
    	while(1)
    	{
    	    scanf("%s",c);
    		if( (strcmp(c,"n")!=0) && (strcmp(c,"y")!=0))
    		{
    			printf("\t\t\t请输入合法字符!\n");
    			printf("\t\t\t请重新输入: ");
    			fflush(stdin); //清除缓冲区 
    		}
    		if( (strcmp(c,"n")==0) || (strcmp(c,"y")==0))
    		{
    			break;
    		}
    	}
        if((strcmp(c,"n")==0))
    	{
    		printf("\t\t\t不保存哦 ^.^\n");
            return ;
    	}
        if((fp=fopen("staff.txt","w+"))==NULL)  
        {  
            printf("\n\t\t\t--->staff.txt文件打开失败!\n");
            return ;  
        }
    	fputs("姓名 工号 电话 部门 职位 密码 实际工资 基本工资 迟到  请假 加班 扣款 奖金\n",fp);
    //从头节点开始依次写入文件;
        for(u = head->next; u != NULL;u = u->next)  
        { 
            fprintf(fp,"%s %s %s %s %s %s ",u->name,u->number,u->phone,u->depart,u->post,u->password);  
            fprintf(fp,"%d %d %d %d %d %d %d\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
        }  
        fclose(fp);  
        printf("\n\t\t\t--->信息成功存入\n");  
    }
    //读取员工文件
    void read()  
    {  
    	char a[100];//存放读取的汉字
        FILE *fp;
    	char ch;
    	fp=fopen("staff.txt","a+");          //进入程序时打开/建立该文件
    	fclose(fp);
        if((fp=fopen("staff.txt","r"))==NULL)  
        {  
            printf("\n\t\t\t--->没有找到文件!\n");  
            return ;  
        }
        ch=fgetc(fp);
        if(ch==EOF)
    		{
    			return;
    		}
    	else
    		rewind(fp);
    	fgets(a,74,fp);//读取第一行汉字信息
    	while(!feof(fp))  
    	{   
    		u = new_node(u);
    		fscanf(fp,"%s %s %s %s %s %s ",u->name,u->number,u->phone,u->depart,u->post,u->password);  
    		fscanf(fp,"%d %d %d %d %d %d %d\n",&u->z.real,&u->z.base,&u->late,&u->leave,&u->over,&u->z.cut,&u->z.bonus);
    		u->next = head->next; //头插法建立链表 
    		head->next = u;  
    	}
    	fclose(fp);
    	
    }
    //保存经理文件;
    void msave()  
    {  
    	char c[20];
    	FILE *fp;
        printf("\n\t\t\t确认保存?(y/n): ");  
    	while(1)
    	{
    	    scanf("%s",c);
    		if( (strcmp(c,"n")!=0) && (strcmp(c,"y")!=0))
    		{
    			printf("\t\t\t请输入合法字符!\n");
    			printf("\t\t\t请重新输入: ");
    			fflush(stdin); //清除缓冲区 
    		}
    		if( (strcmp(c,"n")==0) || (strcmp(c,"y")==0))
    		{
    			break;
    		}
    	}
        if((strcmp(c,"n")==0))
    	{
    		printf("\t\t\t不保存哦 ^.^\n");
            return ;
    	}  
        if((fp=fopen("manage.txt","w+"))==NULL)  
        {  
            printf("\n--->无法打开文件\n");  
            return ;  
        } 
    	fputs("姓名 工号 所管部门 密码\n",fp);
    //从头节点开始依次写入文件;
    //部门经理:  姓名 工号 所管部门 密码
        for(mu = mhead->next; mu != NULL;mu = mu->next)  
        {  
            fprintf(fp,"%s %s %s %s\n",mu->mname,mu->mnumber,mu->mdepart,mu->mpassword);  
        }  
        fclose(fp);  
        printf("\n\t\t\t--->经理信息成功存入\n");  
    }
    //读取经理文件
    void mread()  
    {  
        FILE *fp;
    	char ch,a[100];
    	fp=fopen("manage.txt","a");
    	fclose(fp);
        if((fp=fopen("manage.txt","r"))==NULL)  
        {  
            printf("\n--->没有找到文件!\n");  
            return ;  
        }
        ch=fgetc(fp);
        if(ch==EOF)
    	{
    		return;
    	}
    	else
    		rewind(fp);
    	fgets(a,25,fp);//读取第一行汉字信息
    	while(!feof(fp))  
    	{  
    
    		mu = mnew_node(mu); 
    		fscanf(fp,"%s %s %s %s\n",mu->mname,mu->mnumber,mu->mdepart,mu->mpassword);  
    		mu->next = mhead->next; //头插法建立链表 
    		mhead->next = mu;  
    	}
    	fclose(fp);	
    }
    //退出程序
    void exi()  
    {  
        char c[100];
        printf("\n\t\t\t确定退出?(y/n): ");
    	while(1)
    	{
    		scanf("%s",c); 
    		if( (strcmp(c,"n")!=0) && (strcmp(c,"y")!=0))
    		{
    			printf("\t\t\t请输入合法字符!\n");
    			printf("\t\t\t请重新输入: ");
    			fflush(stdin); //清除缓冲区 
    		}
    		if( (strcmp(c,"n")==0) || (strcmp(c,"y")==0))
    		{
    			break;
    		}
    	}
    	if((strcmp(c,"n")==0))
    	{
    		printf("\t\t\t不保存哦 ^.^\n");
    		return ;
    	}  
        system("cls");  
        printf("\n\n");  
        printf("\t\t\t     ∷ ∷ ∷ ∷ ∷ ∷ ∷ ∷ ∷\n");  
        printf("\t\t\t     ∷ 谢谢使用 ∷\n");  
        printf("\t\t\t     ∷ ∷ ∷ ∷ ∷ ∷ ∷ ∷ ∷\n");  
        printf("\t\t\t                          Thank you! ( ̄▽ ̄) \n");  
        exit(0);  
    }
    void gotoxy(int x, int y)//位置函数
    {
        COORD coord = {x, y};   
        /*COORD是Windows API中定义的一种结构,表示一个字符在控制台屏幕上的坐标。其定义为:
    
        typedef struct _COORD {
    
        SHORT X; // horizontal coordinate
    
        SHORT Y; // vertical coordinate
        } COORD;*/
    
        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
    }
    void welcome()
    {
    	int i;
    	system("color 0B");
    	printf("\n\n\n\t\t\t(* ̄︶ ̄)~*  欢 迎 进 入  FengRong's  员 工 管 理 系 统");
    	printf("\n\n\n\n\n\n\n\n\n\n");
    	printf("\t\t\t\t┌───────────┐\n\n\n");
    	printf("\n\t\t\t\t└───────────┘\n");
    	gotoxy(33,15);
    	for(i=0;i<5;i++)
    	{
    		printf("██");
    		Sleep(400);
    	}
    	system("cls");
    }  
    int main()  
    {  
    	int chioce;
    	head = wj = new_node(head);//wj,mwj用于初始文件的读取
    	mhead = mwj = mnew_node(mhead);
    	bhead = bwj = bnew_node(bhead);
    	//welcome();
    	system("color 3f");
    	read();
    	mread();
    	begread();
    	do
    	{                            
    		printf("\t\t\t┏━━━━━员工管理系统━━━━━┓\n");
    		printf("\t\t\t┃                                ┃\n");
    		printf("\t\t\t┃         1. 管理员              ┃\n");
    		printf("\t\t\t┃                                ┃\n");
    		printf("\t\t\t┃         2.普通员工             ┃\n");
    		printf("\t\t\t┃                                ┃\n");
    		printf("\t\t\t┃         3.部门经理             ┃\n"); 
    		printf("\t\t\t┃                                ┃\n");
    		printf("\t\t\t┃         0.退出管理系统         ┃\n");  
    		printf("\t\t\t┃                                ┃\n"); 
    		printf("\t\t\t┗━━━━━━━━━━━━━━━━┛\n"); 
        	printf("\t\t\t请选择登陆身份:");
        	if(scanf("%d",&chioce))
        	{
        		switch(chioce)
        		{  
        			case 0:
    					exi(); 
        	   		case 1:
                 	   admin();
            			break;
            		case 2:
                	   staff();
            			break;
    				case 3:
    					manager();
            		default:printf("\n\t\t\t请重新选择登录身份:\n");
    	        		break;
        		}
    		}
    		else
    		{
    			printf("\n\t\t\t不能输入非整型,请重新选择登录身份:\n");
    			fflush(stdin); //清除缓冲区 
    			chioce=1; //防止跳出循环 
    		} 
    
    	}while(chioce!=0);
    	system("pause");  
    }
    void mmgl()
    {
        int chioce;
    	do
    	{
    		printf("\n");
    	    printf("\t\t\t************************************\n");
         	printf("\t\t\t*        1.修改员工密码            *\n");
         	printf("\t\t\t*        2.修改经理密码            *\n");
         	printf("\t\t\t*        3.修改管理员密码          *\n");
    		printf("\t\t\t*        4.退回系统                *\n");
        	printf("\t\t\t*        0.退出                    *\n");
        	printf("\t\t\t************************************\n");
          	printf("\t\t\t请选择:");
         	if(scanf("%d",&chioce))
    		{
            	system("cls");
        		switch(chioce)
    			{  
    			case 1:stam();break;
         		case 2:manam();break;
    			case 3:adminm();break;
        		case 4:return;
        		default:printf("\n--->无效的指令!\n");
    			}
    		}
    		else
    		{
    			printf("\n\t\t\t不能输入非整型,请重新输入:");
    			fflush(stdin); //清除缓冲区 
    			chioce=1; //防止跳出循环 
    		}
    	}while(chioce!=0);
    	return;
    }
    void stam()   // 管理员修改密码--找到要修改员工的工号
    {  
    	char mm[100];    //变量:修改密码的工号,输入旧密码,修改的新密码
        n = 0;
        printf("\n\t\t\t请输入要您要修改密码的工号");  
        scanf("%s",mm);  
        for(u = head; u != NULL;u = u->next)  
        {  
            if(strcmp(u->number,mm) == 0)
            {  
                n = 1; 
    			printf("\n\t\t\t请输入旧的密码: ");
    			scanf("%s",mm);
    			if(strcmp(u->password,mm) != 0)
    			{
    				printf("\t\t\t旧密码输入错误哦\n");
    				printf("\t\t\t请谨慎输入 ^.^ 重新输入旧密码\n");
    				scanf("%s",mm);
    				if(strcmp(u->password,mm) != 0)
    				{
    					printf("\t\t\t两次输入错误了!\n");
    					printf("\t\t\t您已经没有权利修改密码了 =_= 将返回上一步\n");
    				}
    				else
    				{
    					printf("\t\t\t旧密码验证成功!\n");
    					printf("\t\t\t请输入新的密码: ");  
    					while(1)
    					{
    						scanf("%s",u->password);
    						if(strlen(u->password)>15)
    						{
    							printf("\t\t\t密码输入过长 ^.^\t请重新输入\n");
    						}
    						if(strlen(u->password)<=15)
    						{
    							break;
    						}
    					}
    					printf("\n\t\t\t--->修改成功!\n");
    					save();
    					break; 
    				} 
    			}
    			else
    			{
    				printf("\t\t\t旧密码验证成功!\n");
    				printf("\t\t\t请输入新的密码: ");  
    				while(1)
    				{
    					scanf("%s",u->password);
    					if(strlen(u->password)>15)
    					{
    						printf("\t\t\t密码输入过长 ^.^\t请重新输入\n");
    					}
    					if(strlen(u->password)<=15)
    					{
    						break;
    					}
    				} 
    				printf("\n\t\t\t--->修改成功!\n");
    				save();
    				break; 
    			}   
            }  
        }  
        if(!n)  
            printf("\n\t\t\t--->没有这个员工!\n");  
    }
    void manam()  
    {  
    	char mm[100];
        n = 0;
        printf("\n\t\t\t请输入要修改经理密码的工号 ");  
        scanf("%s",mm);  
        for(mu = mhead; mu != NULL;mu = mu->next)  
        {  
            if(strcmp(mu->mnumber,mm) == 0)  
            {  
                n = 1;
    			printf("\n\t\t\t请输入旧的密码: ");
    			scanf("%s",mm);
    			if(strcmp(mu->mpassword,mm) != 0)
    			{
    				printf("\t\t\t旧密码输入错误哦\n");
    				printf("\t\t\t请谨慎输入 ^.^ 重新输入旧密码\n");
    				scanf("%s",mm);
    				if(strcmp(mu->mpassword,mm) != 0)
    				{
    					printf("\t\t\t两次输入错误了!\n");
    					printf("\t\t\t您已经没有权利修改密码了 =_= 将返回上一步\n");
    				}
    				else
    				{
    					printf("\t\t\t旧密码验证成功!");
    					printf("\n\t\t\t请输入新的密码: ");  
    					scanf("%s",mu->mpassword); 
    					printf("\n\t\t\t--->修改成功!\n");
    					msave();
    					break; 
    				} 
    			}
    			else
    			{
    				printf("\t\t\t旧密码验证成功!");
    				printf("\n\t\t\t请输入新的密码: ");  
    				scanf("%s",mu->mpassword); 
    				printf("\n\t\t\t--->修改成功!\n");
    				msave();
    				break; 
    			} 
            }
        }  
        if(!n)  
            printf("\n\t\t\t--->没有这个经理!\n");  
    }
    
    void adminm()
    {
    	FILE *fp;
    	unsigned i;
    	char ch[100];
    	char ps[100];
    	fp=fopen("admin.txt","rt"); 
    	fscanf(fp,"%s",ps);//读取管理员密码
    	fclose(fp);
        if((fp=fopen("admin.txt","w+"))==NULL)  
        {  
            printf("\n\t\t\t--->无法打开文件\n");  
            return;  
        }
    	printf("\n\t\t\t请输入旧密码:");
    	scanf("%s",ch);
    	if(strcmp(ps,ch)!=0)
    	{
    		printf("\t\t\t旧密码输入错误哦\n");
    		printf("\t\t\t请谨慎输入 ^.^ 重新输入旧密码\n");
    		scanf("%s",ch);
    		if(strcmp(mu->mpassword,ch) != 0)
    		{
    			printf("\t\t\t两次输入错误了!\n");
    			printf("\t\t\t您已经没有权利修改密码了 =_= 将返回上一步\n");
    		}
    		else
    		{
    			printf("\n\t\t\t请输入新的管理员密码:\n");
    			scanf("%s",ch);
    			for(i=0;i<(strlen(ch));i++)
    			{
    				fputc(ch[i],fp);
    			}
    			fclose(fp);
    			return;
    		}
    	}
    	else
    	{
    		printf("\n\t\t\t请输入新的管理员密码:\n");
    		scanf("%s",ch);
    		for(i=0;i<(strlen(ch));i++)
    		{
    			fputc(ch[i],fp);
    		}
    		fclose(fp);
    		return;
    	} 
    }
    int getadmin()
    {
    	int i=0;
    	FILE *fp;
    	char password[100],password1[100];
    	char c;
    	fp=fopen("admin.txt","a");
    	fclose(fp);
    	fp=fopen("admin.txt","rt"); 
    	fscanf(fp,"%s",password);//读取管理员密码
    	fclose(fp);
    	printf("\n\n\n\n\t\t\t请输入管理员密码:");
    	//scanf("%s",password1);
    	while((c=getch())!=13)
    	{
    		if(c==8)
    		{
    			printf("\b \b");
    			i--;
    			continue;
    		}
    		password1[i++]=c;
    		putchar('*');
    	}
    	password1[i]='\0';
    	if(strcmp(password1,password)==0)
    	{
    		printf("\n\t\t\t登录中");
    		for(i=1;i<6;i++)
    		{
    			printf("★");
    			Sleep(100);
    		}
    		printf("\n");
    		return 1;
    	}
    	else
    	{
    
    	     printf("\n\t\t\t密码输入错误!密码在admin.txt中\n\t\t\t请重新输入密码:");
    		 fflush(stdin);
    		 scanf("%s",password1);
    		 if(strcmp(password1,password)==0)
    		 {
    			 printf("\n\t\t\t登录中");
    			for(i=1;i<6;i++)
    			{
    				printf("★");
    				Sleep(100);
    			}
    			printf("\n");
    			return 1;
    		 }
    		 else
    		 {
    			printf("\n\t\t\t你已经两次密码输入错误!\n\t\t\t将返回上一步,请重新选择登录身份!\n");
    			system("pause");
    			system("cls");
    			return 0;
    		 }
    	}
    }
    void adminxx()
    {
    	int chioce;
    	do
    	{
    		printf("\t\t\t┏━━━━━━━━━━━━━━━━┓\n");
    		printf("\t\t\t┃                                ┃\n");
    		printf("\t\t\t┃         1. 查询员工信息        ┃\n");
    		printf("\t\t\t┃                                ┃\n");
    		printf("\t\t\t┃         2. 修改员工信息        ┃\n");
    		printf("\t\t\t┃                                ┃\n");
    		printf("\t\t\t┃         3. 删除员工信息        ┃\n");
    		printf("\t\t\t┃                                ┃\n");
    		printf("\t\t\t┃         4. 排序员工信息        ┃\n");
    		printf("\t\t\t┃                                ┃\n");
    		printf("\t\t\t┃         5. 返回上一步          ┃\n");  
    		printf("\t\t\t┃                                ┃\n"); 
    		printf("\t\t\t┃         0.退出管理系统         ┃\n");  
    		printf("\t\t\t┃                                ┃\n"); 
    		printf("\t\t\t┗━━━━━━━━━━━━━━━━┛\n");  
          	printf("\t\t\t请选择:");
    	    if(scanf("%d",&chioce))
    		{
    			system("cls");
    			switch(chioce)  
    			{   
    				case 1:find();break;
    				case 2:modify();break;
    				case 3:del();break; 
    				case 4:sort();break;
    				case 5:return;
    				case 0:exi(); break;
    				default:printf("\n--->无效的指令!\n");  
    			}
    		}
    		else
    		{
    			printf("\n\t\t\t不能输入非整型,请重新输入:");
    			fflush(stdin); //清除缓冲区 
    			chioce=1; //防止跳出循环 
    		}
    	}while(chioce!=0);
    	return;
    }   
    void admin()
    {
    	int choice;   
    	system("color 0a");
    	system("cls");
        if(getadmin())
    	{
    	    system("cls");//*****
    		while(1)  
    		{  
    			printf("\t\t\t\t\t\t\t\t管理员模式\n\n\n\n");
    			printf("\t\t\t┏━━━━━员工管理系统━━━━━┓\n");
    			printf("\t\t\t┃                                ┃\n");
    			printf("\t\t\t┃         1. 采集信息            ┃\n");
    			printf("\t\t\t┃                                ┃\n");
    			printf("\t\t\t┃         2. 管理员工信息        ┃\n");//查询find()  修改modify() 删除del() 排序sort();
    			printf("\t\t\t┃                                ┃\n");
    			printf("\t\t\t┃         3. 浏览员工信息        ┃\n");//display()
    			printf("\t\t\t┃                                ┃\n");
    			printf("\t\t\t┃         4. 管理密码            ┃\n");
    			printf("\t\t\t┃                                ┃\n");
    			printf("\t\t\t┃         5. 管理公司机构        ┃\n"); //beg_add()
    			printf("\t\t\t┃                                ┃\n");
    			printf("\t\t\t┃         6. 查看公司机构        ┃\n"); //beg_show()
    			printf("\t\t\t┃                                ┃\n");
    			printf("\t\t\t┃         7. 返回上一步          ┃\n");  
    			printf("\t\t\t┃                                ┃\n"); 
    			printf("\t\t\t┃         0.退出管理系统         ┃\n");  
    			printf("\t\t\t┃                                ┃\n"); 
    			printf("\t\t\t┗━━━━━━━━━━━━━━━━┛\n");    
    			printf("\t\t\t       请选择功能:");
    			if(scanf("%d",&choice))   
    			{
    				system("cls");
    				switch(choice)  
    				{   
    					case 1:add();break;
    					case 2:adminxx();break;
    					case 3:display();break; 
    					case 4:mmgl();break;
    					case 5:beg_add();break;
    					case 6:beg_show();break;
    					case 7:return;
    					case 0:exi(); break;
    					default:printf("\n--->无效的指令!\n");  
    				}
    			}
    			else
    			{
    				printf("\n\t\t\t不能输入非整型,请重新输入:");
    				fflush(stdin); //清除缓冲区 
    				choice=1; //防止跳出循环 
    			}
    			printf("\n");    
    		}    
    		
    	}
    	else 
    		return ;
    }
    int sgetmima()
    {
    	int m,i=0;//控制
    	char smima[20];
    	char c;
    	m=0;
    	printf("\t\t\t请输入工号:");
    	scanf("%s",sdl);
    	if(head->next==NULL)
    	{
    		printf("\t\t\t没有员工信息\n");
    		return 0;
    	}
    	for(u=head->next;u!=NULL;u=u->next)
    	{
    		if(strcmp(u->number,sdl)==0)
    		{
    			printf("\t\t\t请输入密码:");
    			//scanf("%s",smima);
    			while((c=getch())!=13)
    			{
    				if(c==8)
    				{
    					printf("\b \b");
    					i--;
    					continue;
    				}
    				smima[i++]=c;
    				putchar('*');
    			}
    			smima[i]='\0';
    			if(strcmp(u->password,smima)==0)
    			{
    				m=1;
    				printf("\n\t\t\t登录中");
    				for(i=1;i<6;i++)
    				{
    					printf("★");
    					Sleep(100);
    				}
    				printf("\n");
    				return 1;
    			}
    			else
    			{
    				printf("\n\t\t\t请再次输入密码:");
    				scanf("%s",smima);
    				if(strcmp(u->password,smima)==0)
    				{
    					m=1;
    					printf("\n\t\t\t登录中");
    					for(i=1;i<6;i++)
    					{
    						printf("★");
    						Sleep(100);
    					}
    					printf("\n");
    					return 1;
    				}
    				else
    				{
    					printf("\t\t\t密码输入错误!\n");
    					return 0;
    				}
    			}
    
    		}
    	}
    	if(!m)
    	{
    		printf("\n\t\t\t没有此工号的员工!\n");
    		return 0;
    	}
    	return 0;
    }
    
    void modi_self()//员工修改自己基本信息
    {
    	int chioce;	
    	int j;
    	do
    	{
    		printf("\n");
    	    printf("\t\t\t*********************修改信息*********************\n");
         	printf("\t\t\t*        1.修改姓名         2.修改电话           *\n");
         	printf("\t\t\t*        3.修改密码         4.返回上一步         *\n");
    		printf("\t\t\t*        0.退出                                  *\n");
        	printf("\t\t\t**************************************************\n");
          	printf("\t\t\t请选择:");
         	if(scanf("%d",&chioce))
    		{
        	    switch(chioce)
    			{  
    			case 1:
    				{	
    					while(1)
    					{
    						printf("\t\t\t*请输入新的姓名: ");  
    						scanf("%s",u->name);
    						for(j=0;(size_t)j<strlen(u->name);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    						{
    							if(u->name[j]<'a' || u->name[j]>'z')
    							{
    								printf("\t\t\t姓名不符合常规 ^.^\t请重新输入\n");
    								break;
    							}
    							if(strlen(u->name)>15)
    							{
    								printf("\t\t\t姓名过长 ^.^\t请重新输入\n");
    								break;
    							}
    						}
    						if(strlen(u->name)<=15&&(size_t)j==strlen(u->name))
    						{
    							break;
    						}
    					}
    					printf("\n--->修改成功!\n");
    					save();
    					break;
    				}
    			case 2:
    				{
    					while(1)
    					{
    						printf("\t\t\t*请输入新的电话(11位):__\b\b");
    						scanf("%s",u->phone);
    						for(j=0;(size_t)j<strlen(u->phone);j++) //strlen函数返回的类型是size_t 实质是无符号整型
    						{
    							if(u->phone[j]<'1' || u->phone[j]>'9')
    							{
    								printf("\t\t\t电话是数字 ^.^\t请重新输入\n");
    								break;
    							}
    							if(strlen(u->phone)!=11)
    							{
    								printf("\t\t\t电话是11位 ^.^\t请重新输入\n");
    								break;
    							}
    						}
    						if(strlen(u->phone)==11&& (size_t)j==strlen(u->phone))
    						{
    							break;
    						}
    					}
    					printf("\n--->修改成功!\n");
    					save();
    					break;
    				}
    			case 3:
    				{
    					printf("\t\t\t请输入新的密码: ");  
    					while(1)
    					{
    						scanf("%s",u->password);
    						if(strlen(u->password)>15)
    						{
    							printf("\t\t\t密码输入过长 ^.^\t请重新输入\n");
    						}
    						if(strlen(u->password)<=15)
    						{
    							break;
    						}
    					}
    					printf("\n\t\t\t--->修改成功!\n");
    					save();
    					break; 
    				}
        		case 4:return;
        		default:printf("\n\t\t\t--->无效的指令!\n");
    			}
    		}
    		else
    		{
    			printf("\n\t\t\t不能输入非整型,请重新输入:");
    			fflush(stdin); //清除缓冲区 
    			chioce=1; //防止跳出循环 
    		}
    	}while(chioce!=0);
    	return;
    }
     //员工修改自己的基本信息    员工登录工号全局变量char sdl[20];
    void mself()
    {  
        for(u = head; u != NULL;u = u->next)  
        {  
            if(strcmp(u->number,sdl) == 0)  
            {  
    			printf("\t\t\t\t\t*员工初始信息*\n");
    			puts("      姓名          工号     电话        部门              职位      实际工资 基本工资 迟到 请假 加班 罚款 奖金\n");    
    			printf("%-15s %-8s %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    			printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
    			modi_self();
                break;   
            }  
        } 
    } 
    void sjinru()
    {
    	int choice;
    	system("color 3f");
        system("cls");
        while(1)  
        {   
    		printf("\t\t\t\t\t\t\t\t\t\t\t员工模式\n\n\n\n");
    		printf("\t\t\t┏━━━━━━━━━━━━━━━┓\n");         
    		printf("\t\t\t┃       1.查询信息             ┃ \n"); //员工可以查询自己和别人的信息 
    		printf("\t\t\t┃                              ┃\n");  
    		printf("\t\t\t┃       2.修改信息             ┃\n");  //该工号员工只能修改自己的基本信息(姓名 电话 密码)
    		printf("\t\t\t┃                              ┃\n");
    		printf("\t\t\t┃       3.查看加班信息         ┃\n");  //员工查看经理发布的加班时间
    		printf("\t\t\t┃                              ┃\n");
    		printf("\t\t\t┃       4.发送请假信息         ┃\n");
    		printf("\t\t\t┃                              ┃\n");
    		printf("\t\t\t┃       5.返回上一步           ┃\n"); 
    		printf("\t\t\t┃                              ┃\n");
    		printf("\t\t\t┃       0.退出管理系统         ┃\n");  
    		printf("\t\t\t┃                              ┃\n"); 
    		printf("\t\t\t┗━━━━━━━━━━━━━━━┛\n"); 
    		printf("\t\t\t请选择功能: ");
            if(scanf("%d",&choice))
    		{
    			system("cls");
    			switch(choice)  
    			{  
    				case 1:find();break;  
    				case 2:mself();break; 
    				case 3:lookover();break;
    				case 4:askleave();break;
    				case 5:return;
    				case 0:exi();break;  
    				default:printf("\n\t\t\t--->无效的指令!\n");  
    			}
    		}
    		else
    		{
    			printf("\n\t\t\t不能输入非整型,请重新输入:");
    			fflush(stdin); //清除缓冲区 
    			choice=1; //防止跳出循环 
    		}
            printf("\n"); 
            system("pause");  
            system("cls");  
        } 
    }
    void staff()
    {
       system("color 0b");
       //while(1)
      // {
    	   
    	   if(sgetmima()) //工号和密码
    	   {
    		   system("cls");
    		   sjinru();
    	   }
    	   else
    		   return;
       //}
    
    }
    int mgetmima()
    {
    	int m,i=0;//控制
    	char mmima[20];
    	char mnumber[20];
    	char c;
    	m=0;
    	printf("\t\t\t请输入部门经理工号:");
    	scanf("%s",mnumber);
    	if(mhead->next==NULL)
    	{
    		printf("\t\t\t没有经理\n");
    		return 0;
    	}
    	for(mu=mhead->next;mu!=NULL;mu=mu->next)
    	{
    		if(strcmp(mu->mnumber,mnumber)==0)
    		{
    			printf("\n\t\t\t请输入密码:");
    			//scanf("%s",mmima);
    			while((c=getch())!=13)
    			{
    				if(c==8)
    				{
    					printf("\b \b");
    					i--;
    					continue;
    				}
    				mmima[i++]=c;
    				putchar('*');
    			}
    			mmima[i]='\0';
    			if(strcmp(mu->mpassword,mmima)==0)
    			{
    				m=1;
    				strcpy(ddepart,mu->mdepart);//查看自己部门员工的信息
    				printf("\n\t\t\t登录中");
    				for(i=1;i<6;i++)
    				{
    					printf("★");
    					Sleep(100);
    				}
    				printf("\n");
    				return 1;
    			}
    			else
    			{
    				printf("\n\t\t\t请再次输入密码:");
    				scanf("%s",mmima);
    				if(strcmp(mu->mpassword,mmima)==0)
    				{
    					m=1;
    				    strcpy(ddepart,mu->mdepart);
    					printf("\n\t\t\t登录中");
    					for(i=1;i<6;i++)
    					{
    						printf("★");
    						Sleep(100);
    					}
    					printf("\n");
    					return 1;
    				}
    				else
    				{
    					printf("\t\t\t密码输入错误!\n");
    					return 0;
    				}
    			}
    
    		}
    	}
    	if(!m)
    	{
    		printf("\n\t\t\t没有此工号的经理!\n");
    		return 0;
    	}
    	return 0;
    }
     
    //查找自己部门所有员工的信息;
    void find_depart() 
    {   
        n=0; 
        for(u = head->next; u != NULL;u = u->next)  
        {  
                                     //不是该部门的员工则跳过;
            if(strcmp(u->depart,ddepart))  
                continue;                                 //如果是第一个员工则打印头信息
            if(!n)  
            puts("☆\t  姓名        工号      电话        部门             职位          实际工资  基本工资 迟到 请假 加班 罚款 奖金\n");  
        	printf("┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈\n");  
    		 n++;
    		printf("\t  ┊%-10s %-8s  %-11s %-15s %-15s ",u->name,u->number,u->phone,u->depart,u->post);
    		printf("%-8d %-8d %-4d %-4d %-4d %-4d %-4d┊\n",u->z.real,u->z.base,u->late,u->leave,u->over,u->z.cut,u->z.bonus);
    		printf("┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈\n"); 
        }  
        if(!n)  
        {  
            printf("没有这个部门员工的信息!\n");  
            return ;  
        }  
        printf("\n该部门共有 %d个员工.\n\n",n);  
    }
    void mjinru()
    {
    	int choice;
    	system("color 2f");
        system("cls");
        while(1)  
        {  
    		printf("\t\t\t\t\t\t\t\t\t\t\t>经理模式\n\n\n\n");
    		printf("\t\t\t┏━━━━━━━━━━━━━━━┓\n");   
     		printf("\t\t\t┃       1.采集员工信息         ┃\n");
    		printf("\t\t\t┃                              ┃\n");   
    		printf("\t\t\t┃       2.浏览信息             ┃\n");
    		printf("\t\t\t┃                              ┃\n"); 
    		printf("\t\t\t┃       3.查看本部门信息       ┃\n"); 
    		printf("\t\t\t┃                              ┃\n");
    		printf("\t\t\t┃       4.通知加班信息         ┃\n"); 
    		printf("\t\t\t┃                              ┃\n");
    		printf("\t\t\t┃       5.审核请假信息         ┃\n"); 
    		printf("\t\t\t┃                              ┃\n");
    		printf("\t\t\t┃       6.返回上一步           ┃\n");
    		printf("\t\t\t┃                              ┃\n");
    		printf("\t\t\t┃       0.退出管理系统         ┃\n");
    		printf("\t\t\t┃                              ┃\n"); 
    		printf("\t\t\t┗━━━━━━━━━━━━━━━┛\n"); 
    		printf("\t\t       请选择功能:");  
            if(scanf("%d",&choice))
    		{
    			system("cls");
    			switch(choice)  
    			{       
    				case 1:s_add();break;  
    				case 2:display();break;
    				case 3:find_depart();break;
    				case 4:callover();break;
    				case 5:giveleave();break;
    				case 6:return;
    				case 0:exi(); break;
    				default :system("cls");printf("\n--->请重新输入!\n");  
    			}
    		}
    		else
    		{
    			printf("\n\t\t\t不能输入非整型,请重新输入:");
    			fflush(stdin); //清除缓冲区 
    			choice=1; //防止跳出循环 
    		}
            printf("\n"); 
            system("pause");  
            system("cls");  
        }    
    }
    void manager()
    {
    	system("color 0b");
        //while(1)
      // {
    	   if(mgetmima())
    	   {
    		   system("cls");
    		   mjinru();
    	   }
    	   else
    		   return;
      // }
    }
    


    展开全文
  • 试设计一职工信息管理系统,使之能提供以下功能: 1、系统以菜单方式工作 2、职工信息录入功能(职工信息用文件保存)--输入 3、职工信息浏览功能--输出 4、职工信息查询功能--算法 查询方式 按学历查询等 按职工号...
  • C语言员工管理系统

    2013-07-28 10:38:34
    C语言员工管理系统小程序,小学期时用的,简单的信息增删改查功能
  • C语言员工管理系统

    2019-06-23 18:29:48
    该文件是假技术po主闲暇用纯C语言编写的一款员工管理系统,希望可以帮助到大家!
  • 主要为大家详细介绍了C语言实现医院管理系统,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 系统能够完成员工信息的查询、更新、插入、删除、排序等功能。 基本要求:排序:按不同关键字,对所有员工的信息进行排序;查询:按特定条件查找员工;更新,按编号对某个员工的某项信息进行修改;插入,加入新员工...
  • C语言实现员工管理系统

    千次阅读 2017-07-12 18:48:01
    这俩天写了一个小玩具程序,算一个长期以来的热门题目就是《xxx管理系统》。大致的意思整个程序分为客户端和服务器段,客户端通过登录验证后,对信息进行处理,并且客户端分为了普通用户和管理员。至于员工信息这些...

    这俩天写了一个小玩具程序,算一个长期以来的热门题目就是《xxx管理系统》。大致的意思整个程序分为客户端和服务器段,客户端通过登录验证后,对信息进行处理,并且客户端分为了普通用户和管理员。至于员工信息这些数据,舍弃了数据库的做法,改用读写普通文件的方式存放数据。

    使用流程大致如下图所示



    而服务器端和客户端都有不同的设计流程

    客户端主要为,用户登录,录入或者查询信息,发送到服务器端,接收服务器端返回的消息

    服务器端主要为,监听客户端连接,接收客户端消息,根据消息类型做出不同的操作,并更新存储信息的文件,发送反馈信息到客户端。

    为此我们需要封装一些数据结构。大致有三个:

    (1)消息结构体,主要负责携带网络传输的数据,其中包含消息的类型,消息的发送方,用户信息等等。

    (2)用户信息结构体,主要为用户的详细信息,用于查看修改。

    (3)用户结构体,包含用户名和密码,用于登录。

    /**********************************************************/

    以下为代码大致框架

    1.服务器端

    int main(int argc, const char *argv[])
    {
    	pthread_t client_th;  //定义线程号
    	socket_set  //tcp网络设置
    	open the file    //打开文件 
    	init the file	//初始化文件,写入必要的信息
    	read the file	//重新读取文件,将数据放入内存中
    	/**socket 编程,循环监听,开启新的线程*/
    	while(1)
    	{
    		if((acceptfd = accept(sockfd,(struct sockaddr *)&clientaddr,&addrlen))<0)
    		{
    			errlog("fail to accept");
    		}
    		printf("Ip:%s,bind:%d.\n",inet_ntoa(clientaddr.sin_addr),ntohs(clientaddr.sin_port));
    		
    		if(acceptfd>0)
    		{
    			pthread_create(&client_th,NULL,(void *)client_fun,(void *)acceptfd);
    			printf("new thread = %lu  join.\n",client_th);
    			pthread_detach(client_th);
    		}
    	}
    	close(sockfd);	
    	close(fp_info);
    	close(fp_user);
    	return 0;	
    #endif
    
    }
    
    #if 1
    /**
     *@arg socket描述符
     *@brief 开线程与客户端连接
     */
    void *client_fun(void *arg)
    {
    	MSG msg;   //消息结构体
    	int acceptfd=(int)arg; 
    	while(1)
    	{
    		if(recv(acceptfd,&msg,sizeof(MSG),0)<0)
    		{
    			errlog("fail to recv");
    		}
    		/**根据消息类型做出不同的操作**/
    		switch(msg.type)
    		{
    			case READ:	//查询用户信息
    			do_selectuser(acceptfd,&msg);break;
    			case CHANGE:	//修改用户信息
    			do_modifyuser(acceptfd,&msg);break;
    			case DELETE:	//删除用户
    			do_deluser(acceptfd,&msg);break;
    			case ADD:	//添加用户
    			do_adduser(acceptfd,&msg);break;
    			case LOAD:	//用户申请登录
    			do_loaduser(acceptfd,&msg);break;
    			case QUIT:	 //用户退出时发给服务器的通知消息
    			do_quituser(acceptfd,&msg);break;
    			default:
    			break;
    		}
    	
    	}	
    	close(acceptfd);
    	return NULL;
    }
    #endif
    
    /**用户登录申请处理*/
    int do_loaduser(int sockfd, MSG *msg)
    {
    }
    /**申请新增用户处理*/
    int do_adduser(int sockfd, MSG *msg)
    {
    }
    /**申请修改用户信息处理*/
    int do_modifyuser(int sockfd, MSG *msg)
    {	
    }
    /**申请查看用户信息处理*/
    int do_selectuser(int sockfd, MSG *msg)
    {	
    }
    /**用户申请退出处理*/
    int do_quituser(int sockfd, MSG *msg)
    {	
    }
    
    
    
    2.客户端

    static int status=0;	//运行状态
    static char user[N_SIZE]={0}; //当前用户名
    static int  current_no = 0; //当前用户ID
    
    int main(int argc,const char *argv[])
    {
    	socket_set  //tcp网络设置
    	/**发送连接请求*/
    	if(connect(sockfd, (struct sockaddr *)&serveraddr, addrlen) < 0)
    	{
    		errlog("fail to connect");
    	}
       /**连接成功后进入登录页面*/
    	while(1)
    	{
    		while((status==RUN_1))	//初始登录界面
    		{
    			my_printf("1.login  2.quit ");
    			printf("input your choice: ");
    			scanf("%d",&cho_num);
    			REMLINE;
    			switch(cho_num)
    			{
    				case 1:
    				do_login(sockfd,msg);break; //选择登录
    				case 2:
    				do_quit(sockfd,msg);break;	//选择退出
    				default:
    				puts("input error,please try again");	
    				break;
    			}
    		}
    		while((status==RUN_2))	//管理员登录后的操作界面
    		{
    			my_printf("1.add    2.delete    3.modify	4.select 	5.quit");
    			printf("input your choice:");
    			scanf("%d",&cho_num);
    			REMLINE;
    			switch(cho_num)
    			{
    				case 1:
    				do_add(sockfd,msg);break; //申请添加用户
    				case 2:
    				do_delect(sockfd,msg);break;	//申请删除用户
    				case 3:
    				do_modify(sockfd,msg);break; //申请修改用户
    				case 4:
    				do_select(sockfd,msg);break; //申请查询用户
    				case 5:
    				do_quit(sockfd,msg);break;   //申请退出
    				default:
    				puts("input error,please try again:");	
    				break;
    			}
    		}
    		while((status==RUN_3))	普通员员登录后的操作界面
    		{
    			my_printf("1.modify	  2.select 	3.quit");
    			printf("input your choice:");
    			scanf("%d",&cho_num);
    			switch(cho_num)
    			{
    				case 1:
    				do_modify(sockfd,msg);break;	//申请修改用户
    				case 2:
    				do_select(sockfd,msg);break;	//申请查询用户
    				case 3:
    				do_quit(sockfd,msg);break;		 //申请退出
    				default:
    				puts("input error,please try again:");	
    				break;
    			}
    		}
    	}	
    	close(sockfd);
    	return 0;
    }
    /**申请登录*/
    int do_login(int sockfd,MSG *msg)
    {
    }
    /**申请增加新的用户*/
    int do_add(int sockfd,MSG *msg)
    {
    }
    /**申请查看用户信息,非管理员模式下只能查看自己的信息
     *用户名和用户ID(name,和no)全部输入正确才能查看
     */
    int do_select(int sockfd,MSG *msg)
    {
    }
    /**申请修改用户信息,非管理员模式下只能修改自己的信息
     *用户名和用户ID(name,和no)全部输入正确才能修改
     */
    int do_modify(int sockfd,MSG *msg)
    {
    }
    /**申请退出*/
    int do_quit(int sockfd,MSG *msg)
    {
    } 
    
     
     
     
     
     
     
     
     
     
     


    这样我们俩个框架就写好了,剩下的就是补全数据类型,填充各个函数了。

    对于读文件的操作,我们使用二进制文件,然后用open,read,write,read。就可以按照先定义好的数据结构,去读写这些文件。

    例如操作一个二进制文件,user.dat,我们可以直接按定义好的结构体USER去读写该文件。省去了我们处理文本文件的各种复杂操作。

    int main(int argc, const char *argv[])
    {
    	int fp = open("user.dat",O_RDWR);
    	USER usr[MAX_USR];
    	int usrlen =sizeof(USER);
    	int i=0;
    	while(read(fp,&usr[i],usrlen)!=0);
    	{
    		i++;
    	}
    	printf("i = %d.\n",i);
    	while(i--)
    	{
    		printf("id = %d.\nname = %s.\npassword = %s.\n",usr[i].type,usr[i].name,usr[i].passwd);
    	}
    	close(fp);
    
    	return 0;
    }

    好了,有了这些代码,大家基本就可以写一个xx管理系统了。

    最后会有我自己写的程序的下载链接。

    http://download.csdn.net/download/u010916862/9896853

    展开全文
  • 6) 录入学生的缺课记录; 7) 修改某个学生的缺课记录;...11) 系统以菜单方式工作。 备注:考勤系统至少应该有以下数据项: 缺课日期、第几节课、课程名称、学生姓名、学生学号、缺课类型(迟到、早退、请假及 旷课)
  • 1.添加新员工 2.删除员工 3.查询 4.更新 5.查看工资 6.取消操作 请选择: 2 请输入要删除的员工号:  6 请输入要进行的操作: 1.添加新员工 2.删除员工 3.查询 4.更新 5.查看工资 6.取消操作 请选择: 3 请...
    #include<cstdio>
    #include<cstring>
    typedef struct Node{
    	int no;
    	char* name;
    	double salary;
    	int age;
    	char* birth;
    	Node* next;
    };
    void create(Node* s,int no,char* name,double salary,int age,char* birth){
    	Node *head=new Node;
    	head->no=no;
    	head->name=name;
    	head->salary=salary;
    	head->age=age;	
    	head->birth=birth;
    	head->next=s->next;
    	s->next=head;
    }
    void insert_staff(Node* s){
    	Node* p=new Node;
    	char name1[10];
    	char birth1[12];
    	printf("请输入添加的员工号:\n");
    	scanf("%d",&p->no);
    	printf("请输入员工的姓名:\n");
    	scanf("%s",&name1);
    	p->name=name1;
    	printf("请输入员工的工资:\n");
    	scanf("%lf",&p->salary);
    	printf("请输入员工的年龄:\n");
    	scanf("%d",&p->age);
    	printf("请输入员工的出生日期:\n");
    	scanf("%s",&birth1);
    	p->birth=birth1;
    	Node* q=new Node;
    	create(s,p->no,p->name,p->salary,p->age,p->birth);
    }
    void del_staff(Node* s){
    	int no1;
    	bool flag=false;
    	Node* p=new Node;
    	while (1)
    	{
    		printf("请输入要删除的员工号:\n ");
    		scanf("%d",&no1);
    		p=s->next;
    		while (p!=NULL){
    			if (p->no==no1){
    				flag=true;
    				break;
    			}
    			p = p->next;
    		}
    		if (flag==true) break;
    		else printf("该员工不存在!\n");
    	}
    	p=s->next;
    	if (p->no==no1) s->next=p->next;
    	while (p->next!=NULL){
    		if(p->next->no==no1) p->next=p->next->next;
    		p = p->next;
    	}
    }
    void search_staff(Node* s){
    	int no1;
    	bool flag=false;
    	Node *p=new Node;
    	while (1){
    		printf("请输入查询的员工号:\n");
    		scanf("%d",&no1);
    		p=s->next;
    		while (p!=NULL){
    			if (p->no==no1){
    				flag=true;
    				break;
    			}
    			p=p->next;
    		}
    		if(flag==true) break;
    		else printf("该员工不存在\n");
    	}
    	printf("员工号\t  姓名\t  工资\t        年龄\t  出生日期\n");
    	printf("%d\t  %s\t  %.2lf\t %d\t  %s\n",p->no,p->name,p->salary,p->age,p->birth);	
    }
    void update_staff(Node* s){
    	int no1;
    	bool flag=false;
    	Node* p=new Node;
    	while(1){
    		printf("请输入员工号:\n");
    		scanf("%d",&no1);
    		p=s->next;
    		while(p!=NULL){
    			if (p->no==no1){
    				flag=true; 
    				break;
    			}
    			p=p->next;
    		}
    		if (flag==true) break;
    		else printf("该员工不存在!\n");
    	}
    	while (1){
    		printf("请输入要更新的信息:\n");
            printf("1.员工号   2.姓名   3.工资   4.年龄   5.出生日期   6.取消操作\n");
    	    printf("请选择: ");
    	    int choose;
    	    scanf("%d",&choose);
    	    if(choose==6) break;
    	    if(choose<1||choose>6){
    	         printf("没有此选项,请重新输入!\n"); 
    	         scanf("%d",&choose);
            }
    		switch(choose){
    		case 1:
    			printf("输入新的员工号:\n");
    			scanf("%d",&p->no);
    			break;
    		case 2:
    			printf("输入新的姓名:\n");
    			scanf("%s",&p->name);
    			break;
    		case 3:
    			printf("输入新的工资:\n");
    			scanf("%lf",&p->salary);
    			break;
    		case 4:
    			printf("输入新的年龄:\n");
    			scanf("%d",&p->age);
    			break;
    		case 5:
    			printf("输入新的生日:\n");
    			scanf("%s",&p->birth);
    			break;
    		}
    	}
    }
    void sort_salary(Node* s){
    	Node* p=new Node;
    	Node* min=new Node;
    	Node* p_min=new Node;
        printf("员工号\t  姓名\t  工资\t        年龄\t  出生日期\n");
    	while (s->next!=NULL){
    		for(p=s->next,min=s->next;p->next!=NULL;p=p->next){
    			if(p->next->salary<min->salary){
    				p_min=p;
    				min=p->next;					
    			}
    		}
    		printf("%d\t  %s\t  %.2lf\t %d\t  %s\n",min->no,min->name,min->salary,min->age,min->birth);	
    		if(min==s->next) s->next=s->next->next;
    		else p_min->next=min->next;
    	}
    }
    int main(){
    	Node* s=new Node;
    	s->next=NULL;
    	create(s,1,"John",234,19,"2000.01");
    	create(s,2,"Mary",456,20,"2001.02");
    	create(s,3,"Stim",345,21,"2003.07");
    	create(s,4,"hel",278,22,"2009.01");
    	while(1)
    	{
    		printf("请输入要进行的操作:\n");
    	    printf("1.添加新员工  2.删除员工  3.查询  4.更新  5.查看工资  6.取消操作\n");
    	    printf("请选择: ");
    	    int choose;
    	    scanf("%d",&choose);
    	    if(choose==6) break;
    	    if(choose<1||choose>6){
    	         printf("没有此选项,请重新输入!\n"); 
    	         scanf("%d", &choose);
            }
    		switch(choose){
    		case 1:
    			insert_staff(s);
    			break;
    		case 2:
    			del_staff(s);
    			break;
    		case 3:
    			search_staff(s);
    			break;
    		case 4:
    			update_staff(s);
    			break;
    		case 5:
    			sort_salary(s);
    			break;
    		}
    	}
    	return 0;
    }

    请输入要进行的操作:
    1.添加新员工  2.删除员工  3.查询  4.更新  5.查看工资  6.取消操作
    请选择: 1
    请输入添加的员工号:
    6
    请输入员工的姓名:
    zhang
    请输入员工的工资:
    456
    请输入员工的年龄:
    21
    请输入员工的出生日期:
    1996.3
    请输入要进行的操作:
    1.添加新员工  2.删除员工  3.查询  4.更新  5.查看工资  6.取消操作
    请选择: 3
    请输入查询的员工号:
    6
    员工号    姓名    工资          年龄      出生日期
    6         zhang   456.00         21       1996.3
    请输入要进行的操作:
    1.添加新员工  2.删除员工  3.查询  4.更新  5.查看工资  6.取消操作
    请选择: 2
    请输入要删除的员工号:
     6
    请输入要进行的操作:
    1.添加新员工  2.删除员工  3.查询  4.更新  5.查看工资  6.取消操作
    请选择: 3
    请输入查询的员工号:
    6
    该员工不存在
    请输入查询的员工号:
    1
    员工号    姓名    工资          年龄      出生日期
    1         John    234.00         19       2000.01
    请输入要进行的操作:
    1.添加新员工  2.删除员工  3.查询  4.更新  5.查看工资  6.取消操作
    请选择: 5
    员工号    姓名    工资          年龄      出生日期
    1         John    234.00         19       2000.01
    4         hel     278.00         22       2009.01
    3         Stim    345.00         21       2003.07
    2         Mary    456.00         20       2001.02
    请输入要进行的操作:
    1.添加新员工  2.删除员工  3.查询  4.更新  5.查看工资  6.取消操作
    请选择:
    展开全文
  • 企业员工管理系统 c语言

    千次阅读 多人点赞 2010-08-24 18:44:00
    //构建员工的结构体 struct employee {  int num;//编号  char name[8];//姓名  char sex[2];//性别  int Csrq;//出生日期  char Jrsj[5];//进入时间  char Sfzh[20];//身份证号  int ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,089
精华内容 3,235
关键字:

员工管理系统c语言

c语言 订阅