精华内容
下载资源
问答
  • 再给同学们呈上我大二时的数据结构课程设计,完全又本人完成,无雷同版。题目为宿舍管理系统,里面有详细代码和分工,包括文件操作,代码风格清晰,有注释,仅供参考。
  • 宿舍进行查询,数据结构课程设计C语言版
  • (1)为宿舍管理人员编写一个宿舍管理查询软件, 程序设计要求: A.采用交互工作方式 B可按关键字(姓名、学号、房号)进行排序(冒泡、选择、插入排序等任选一种) (2)查询菜单: (用二分查找实现以下操作) A.按姓名...
  • 学生宿舍管理系统课程设计报告=代码
  • 数据结构课程设计之学生宿舍信息管理系统

    千次阅读 多人点赞 2020-06-21 10:14:38
    数据结构课程设计之学生宿舍信息管理系统,宿舍对于大学生在校生活来说相当于家的存在,而宿舍管理又是学校后勤管理的重要环节,如何直观的了解宿舍的入住情况和每位同学的住宿位置是提高工作效率的重要课题,根据...

    一、问题陈述

    宿舍对于大学生在校生活来说相当于家的存在,而宿舍管理又是学校后勤管理的重要环节,如何直观的了解宿舍的入住情况和每位同学的住宿位置是提高工作效率的重要课题,根据我们所学的C语言和数据结构课程中有关链表的内容,为宿舍管理人员编写宿舍管理查询软件,就可以轻松满足实现上述需求。
    任务:

    1. 为宿舍管理人员编写一个宿舍管理查询软件, 程序设计要求:
      • 采用交互工作方式
      • 可按关键字(姓名、学号、房号)进行排序
    2. 查询菜单: (用二分查找实现以下操作)
      • 按姓名查询
      • 按学号查询
      • 按房号查询
    3. 打印任一查询结果(可以连续操作)

    二、概要设计

    2.1 概要简述

    根据系统要求,即本系统具有信息的录入,显示,排序显示、查找,插入、删除、结束程序等功能,先设计出详细的系统流程图,然后将源代码输入程序,进行编译调试即可。
    程序总体分10个项目:输入记录、显示记录、按姓名排序并显示、按房间号排序并显示 、按学号排序并显示 、按姓名查找并显示 、按房间号查找并显示 、按学号查找并显示、插入一条记录按学号排序并显示以及结束程序。

    2.2 线性表存储结构表示

    typedef struct {
    	char name[20];
    	int num;            //学号和房号都为整型
    	int room;
    } stu;
    
    typedef struct {
    	int length; //当前长度
    	stu *elem;  //存储空间基址
    	int listsize;  //当前分配的存储容量
    } linklist;
    

    2.3 详细设计

    2.3.1 系统流程图

    在这里插入图片描述

    2.3.2 三种排序方法及二分查找法
    2.3.2.1 冒泡排序(按姓名排序)
    //按姓名排序(采用冒泡排序)
    void sort1(linklist &L) { 
    	int i, j;
    	stu temp;
    	for (i = 0; i<L.length - 1; i++)
    		for (j = 0; j<L.length-1-i; j++)
    			if (strcmp(L.elem[j].name, L.elem[j+1].name)>0) {
    				temp = L.elem[j];
    				L.elem[j] = L.elem[j+1];
    				L.elem[j+1] = temp;
    			}
    }
    
    2.3.2.2 折半插入排序(按学号排序)
    //按学号排序(采用折半插入排序)
    void sort2(linklist &L) { 
    	int i, j, mid, low, high;
    	stu temp;
    	for (i = 1; i < L.length; i++) {
    		if(L.elem[i].num<L.elem[i-1].num) {
    			temp = L.elem[i];
    			low = 0;
    			high = i-1;
    			while (low <= high) {
    				mid = (low + high) / 2;
    				if (temp.num < L.elem[mid].num)
    					high = mid - 1;
    				else
    					low = mid + 1;
    			}
    			for (j = i - 1; j >= high+1; j--)
    				L.elem[j+1]=L.elem[j];
    			L.elem[high+1]=temp;
    		}
    	}
    }
    
    2.3.2.3 简单选择排序(按房号排序)
    //按房号排序(采用简单选择排序)
    void sort3(linklist &L) { 
    	int i,j,k;
    	stu temp;
    	for(i=0; i<L.length-1; i++) {
    		k=i;
    		for(j=i+1; j<L.length; j++)
    			if(L.elem[j].room<L.elem[k].room)
    				k=j;
    		if(k!=i){
    			temp = L.elem[i];
    			L.elem[i] = L.elem[k];
    			L.elem[k] = temp;
    		}
    	}
    }
    
    2.3.2.4 二分查找法(以按姓名查找为例)
    //按姓名从小到大查找(采用二分查找)
    void search1(linklist &L) { 
    	if (L.length == 0) {
    		printf("已无学生记录!\n");
    		Ret();
    		Menu();
    	} else {
    		int low = 0, high = L.length, mid, flag = 0;
    		printf("\n");
    		printf("按姓名查找-->请输入要查找的姓名:");
    		char a[15], ch;
    		scanf("%s", a);
    		while (low <= high) {
    			mid = (low + high) / 2;
    			if (strcmp(a, L.elem[mid].name) == 0) {
    				flag = 1;
    				break;
    			} else if (strcmp(a, L.elem[mid].name)>0)
    				low = mid + 1;
    			else
    				high = mid - 1;
    		}
    		if (flag == 1) {
    			printf("查找成功-->该学生信息为:\n");
    			printf("姓名       学号    房号\n");
    			printf("%-10s %-2d %-5d\n", L.elem[mid].name, L.elem[mid].num, L.elem[mid].room);
    			if (Select())
    				search1(L);
    			else {
    				system("cls");
    				Menu();
    			}
    		} else {
    			printf("该学生不存在!");
    			if (Select())    search1(L);
    			else {
    				system("cls");
    				Menu();
    			}
    		}
    	}
    }
    

    三、测试与运行

    3.1 系统界面

    在这里插入图片描述

    3.2 新建宿舍名单

    在这里插入图片描述

    3.3 排序(以姓名排序为例)

    在这里插入图片描述

    3.4 查询(以学号查询为例)

    在这里插入图片描述

    3.5 插入学生信息

    在这里插入图片描述 在这里插入图片描述

    3.6 删除学生信息

    在这里插入图片描述 在这里插入图片描述

    四、代码实现

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<windows.h>
    #define N 40 //线性表存储空间的初始分配量
    #define increase 10 //线性表存储空间的分配量增量
    int choice;  //定义全局变量
    typedef struct {
    	char name[20];
    	int num;            //学号和房号都为整型
    	int room;
    } stu;
    stu stud;
    typedef struct {
    	int length; //当前长度
    	stu *elem;  //存储空间基址
    	int listsize;  //当前分配的存储容量
    } linklist;
    
    //线性表初始化
    void Init(linklist &L) { 
    	L.length = 0;
    	L.elem = (stu *)malloc(N * sizeof(stu));
    	L.listsize = N;
    }
    
    //操作菜单
    void Menu() { 
    	printf( "**************************************\n" );
    	printf( "***       欢迎进入宿舍管理系统     ***\n" );
    	printf( "**************************************\n" );
    	printf( "*        1.  新建宿舍名单            *\n" );
    	printf( "*        2.  排序宿舍信息            *\n" );
    	printf( "*        3.  查询宿舍信息            *\n" );
    	printf( "*        4.  插入宿舍信息            *\n" );
    	printf( "*        5.  删除宿舍信息            *\n" );
    	printf( "*        0.  退出系统                *\n" );
    	printf( "**************************************\n" );
    	printf("请输入菜单(0-5):");
    	scanf("%d", &choice);
    	if (choice<0 || choice>5) {
    		system("cls");
    		printf("输入数字不对,请重新!\n");
    		printf("\n");
    		Menu();
    	}
    
    }
    
    //打印学生信息
    void Display(linklist &L) { 
    	int i;
    	printf("姓名       学号    房号\n");
    	for (i = 0; i<L.length; i++)
    		printf("%-10s %-2d %5d\n", L.elem[i].name, L.elem[i].num, L.elem[i].room);
    }
    
    //返回主界面
    void Ret() {    
    	char c;
    	fflush(stdin);
    	printf("\n");
    	printf("请按任意键进入主界面:");
    	scanf("%c", &c);
    	system("cls");
    }
    
    //创建学生信息表
    void Create(linklist &L) { 
    	if (L.length >= L.listsize) { //判断学生的人数是否超过初值,如果超过,则重新分配
    		stu *newbase;
    		newbase = (stu*)realloc(L.elem, (N + increase) * sizeof(stu));
    		L.elem = newbase;
    		L.listsize += increase;
    	}
    	int i = 2;
    	char ch;
    	printf("********开始创建学生信息**********\n");
    	printf("\n");
    	printf("请输入第1个学生的信息\n");
    	printf("请输入姓名:");
    	fflush(stdin);      // 清空输入缓冲区,得到正确的输入数据
    	gets(stud.name);    //输入一行字符串(姓名)
    	printf("请输入学号:");
    	scanf("%d", &stud.num);
    	printf("请输入房号:");
    	scanf("%d", &stud.room);
    	ch = getchar();
    	strcpy(L.elem[L.length].name, stud.name);
    	L.elem[L.length].num = stud.num;
    	L.elem[L.length].room = stud.room;
    	L.length++;
    	printf("\n");
    	printf("是否继续输入?<y/n>:");
    	scanf("%c", &ch);
    	printf("\n");
    	while (ch == 'y') {
    		printf("请输入第%d个学生的信息\n", i);
    		printf("请输入姓名:");
    		fflush(stdin);      // 清空输入缓冲区,得到正确的输入数据
    		gets(stud.name);    //输入一行字符串(姓名)
    		printf("请输入学号:");
    		scanf("%d", &stud.num);
    		printf("请输入房号:");
    		scanf("%d", &stud.room);
    		strcpy(L.elem[L.length].name, stud.name);
    		L.elem[L.length].num = stud.num;
    		L.elem[L.length].room = stud.room;
    		i++;
    		L.length=i-1;
    		ch = getchar();
    		printf("\n");
    		printf("是否继续输入?<y/n>:");
    		scanf("%c", &ch);
    		printf("\n");
    	}
    	if (ch == 'n')
    		system("cls");
    }
    
    //按姓名排序(采用冒泡排序)
    void sort1(linklist &L) { 
    	int i, j;
    	stu temp;
    	for (i = 0; i<L.length - 1; i++)
    		for (j = 0; j<L.length-1-i; j++)
    			if (strcmp(L.elem[j].name, L.elem[j+1].name)>0) {
    				temp = L.elem[j];
    				L.elem[j] = L.elem[j+1];
    				L.elem[j+1] = temp;
    			}
    }
    
    //按学号排序(采用折半插入排序)
    void sort2(linklist &L) { 
    	int i, j, mid, low, high;
    	stu temp;
    	for (i = 1; i < L.length; i++) {
    		if(L.elem[i].num<L.elem[i-1].num) {
    			temp = L.elem[i];
    			low = 0;
    			high = i-1;
    			while (low <= high) {
    				mid = (low + high) / 2;
    				if (temp.num < L.elem[mid].num)
    					high = mid - 1;
    				else
    					low = mid + 1;
    			}
    			for (j = i - 1; j >= high+1; j--)
    				L.elem[j+1]=L.elem[j];
    			L.elem[high+1]=temp;
    		}
    	}
    }
    
    //按房号排序(采用简单选择排序)
    void sort3(linklist &L) { 
    	int i,j,k;
    	stu temp;
    	for(i=0; i<L.length-1; i++) {
    		k=i;
    		for(j=i+1; j<L.length; j++)
    			if(L.elem[j].room<L.elem[k].room)
    				k=j;
    		if(k!=i){
    			temp = L.elem[i];
    			L.elem[i] = L.elem[k];
    			L.elem[k] = temp;
    		}
    	}
    }
    //排序函数
    void Sort(linklist &L) { 
    	int c;
    	printf("请输入排序的方式(1:按名字排序,2:按学号排序,3:按房号排序):");
    	scanf("%d", &c);
    	switch (c) {
    		case 1:
    			sort1(L);
    			if (L.length == 0) {
    				printf("已无学生记录!\n");
    				Ret();
    				Menu();
    			} else {
    				printf("按姓名排序:\n");
    				Display(L);
    				Ret();  //调用返回主界面
    				Menu();
    			}
    			break;
    		case 2:
    			sort2(L);
    			if (L.length == 0) {
    				printf("已无学生记录!\n");
    				Ret();
    				Menu();
    			} else {
    				printf("按学号排序:\n");
    				Display(L);
    				Ret();  //调用返回主界面
    				Menu();
    			}
    			break;
    		case 3:
    			sort3(L);
    			if (L.length == 0) {
    				printf("已无学生记录!\n");
    				Ret();
    				Menu();
    			} else {
    				printf("按房号排序:\n");
    				Display(L);
    				Ret();  //调用返回主界面
    				Menu();
    			}
    			break;
    		default:
    			break;
    	}
    }
    
    //选择是否继续查找
    int Select() { 
    	char ch;
    	scanf("%c", &ch);
    	printf("是否继续查找?<y/n>:");
    	fflush(stdin);
    	scanf("%c", &ch);
    	if (ch == 'y') {
    		system("cls");
    		return 1;
    	} else
    		return 0;
    }
    
    //按姓名从小到大查找(采用二分查找)
    void search1(linklist &L) { 
    	if (L.length == 0) {
    		printf("已无学生记录!\n");
    		Ret();
    		Menu();
    	} else {
    		int low = 0, high = L.length, mid, flag = 0;
    		printf("\n");
    		printf("按姓名查找-->请输入要查找的姓名:");
    		char a[15], ch;
    		scanf("%s", a);
    		while (low <= high) {
    			mid = (low + high) / 2;
    			if (strcmp(a, L.elem[mid].name) == 0) {
    				flag = 1;
    				break;
    			} else if (strcmp(a, L.elem[mid].name)>0)
    				low = mid + 1;
    			else
    				high = mid - 1;
    		}
    		if (flag == 1) {
    			printf("查找成功-->该学生信息为:\n");
    			printf("姓名       学号    房号\n");
    			printf("%-10s %-2d %-5d\n", L.elem[mid].name, L.elem[mid].num, L.elem[mid].room);
    			if (Select())
    				search1(L);
    			else {
    				system("cls");
    				Menu();
    			}
    		} else {
    			printf("该学生不存在!");
    			if (Select())    search1(L);
    			else {
    				system("cls");
    				Menu();
    			}
    		}
    	}
    }
    
    //按学号从小到大查找(采用二分查找)
    void search2(linklist &L) { 
    	if (L.length == 0) {
    		printf("\n");
    		printf("已无学生记录!\n");
    		Ret();
    		Menu();
    	} else {
    		int low = 0, high = L.length, mid, flag = 0;
    		int n;
    		char ch;
    		printf("\n");
    		printf("按学号查找-->请输入要查找的学号:");
    		scanf("%d", &n);
    		while (low <= high) {
    			mid = (low + high) / 2;
    			if (n == L.elem[mid].num) {
    				flag = 1;
    				break;
    			} else if (n>L.elem[mid].num)
    				low = mid + 1;
    			else
    				high = mid - 1;
    		}
    		if (flag == 1) {
    			printf("查找成功----->该学生信息为:\n");
    			printf("姓名       学号    房号\n");
    			printf("%-1s0 %-2d %-5d\n", L.elem[mid].name, L.elem[mid].num, L.elem[mid].room);
    			if (Select())
    				search2(L);
    			else {
    				system("cls");
    				Menu();
    			}
    		} else {
    			printf("该学生不存在!");
    			if (Select())
    				search2(L);
    			else {
    				system("cls");
    				Menu();
    			}
    		}
    	}
    }
    
    //按房号从小到大查找(采用二分查找)
    void search3(linklist &L) { 
    	if (L.length == 0) { //此函数功能为:返回主界面
    		printf("\n");
    		printf("已无学生记录!\n");
    		Ret();
    		Menu();
    	} else {
    		int low = 0, high = L.length, mid, flag = 0;//flag作为标志符,为1则表示查找成功,否则没有所要查找的学生
    		int m;
    		char ch;
    		printf("\n");
    		printf("按房号查找-->请输入要查找的房号:");
    		scanf("%d", &m);
    		while (low <= high) {
    			mid = (low + high) / 2;
    			if (m == L.elem[mid].room) {
    				flag = 1;
    				break;
    			} else if (m>L.elem[mid].room)
    				low = mid + 1;
    			else
    				high = mid - 1;
    		}
    		if (flag == 1) {
    			printf("查找成功-->该学生信息为:\n");
    			printf("姓名       学号    房号\n");
    			printf("%-10s %-2d %-5d\n", L.elem[mid].name, L.elem[mid].num, L.elem[mid].room);
    			if (Select())    //调用判断函数1
    				search3(L);
    			else {
    				system("cls");
    				Menu();
    			}
    		} else {
    			printf("该学生不存在!");
    			if (Select())  //调用判断函数2
    				search3(L);
    			else {
    				system("cls");
    				Menu();
    			}
    		}
    	}
    }
    
    //查找函数
    void Search(linklist &L) { 
    	int c;
    	printf("请输入查找的方式(1:按名字查找,2:按学号查找,3:按房号查找):");
    	scanf("%d", &c);
    	switch (c) {
    		case 1:
    			sort1(L);
    			search1(L);
    			break;//先进行二分查找排序
    		case 2:
    			sort2(L);
    			search2(L);
    			break;
    		case 3:
    			sort3(L);
    			search3(L);
    			break;
    		default:
    			break;
    	}
    }
    
    //按学号从小到大插入该学生
    void Insert(linklist &L) { 
    	int i, j, k;
    	char ch;
    	printf("\n");
    	printf("插入的学生信息为:\n");
    	printf("姓名:");
    	fflush(stdin);// 清空输入缓冲区,得到正确的输入数据
    	gets(stud.name);
    	printf("学号:");
    	scanf("%d", &stud.num);
    	printf("房号:");
    	scanf("%d", &stud.room);
    	if (L.length == 0) {
    		strcpy(L.elem[L.length].name, stud.name);
    		L.elem[L.length].num = stud.num;
    		L.elem[L.length].room = stud.room;
    	}
    	for (i = 0; i<L.length; i++) {
    		if (stud.num<L.elem[i].num) {
    			k = i;
    			for (j = L.length; j>k; j--)
    				L.elem[j] = L.elem[j - 1];
    			strcpy(L.elem[k].name, stud.name);
    			L.elem[k].num = stud.num;
    			L.elem[k].room = stud.room;
    			break;
    		} else {
    			strcpy(L.elem[L.length].name, stud.name);
    			L.elem[L.length].num = stud.num;
    			L.elem[L.length].room = stud.room;
    		}
    	}
    	L.length++;
    	fflush(stdin);
    	printf("\n");
    	printf("是否继续插入?<y/n>:");
    	scanf("%c", &ch);
    	if (ch == 'y') Insert(L);
    	else system("cls");
    }
    
    //按学号删除该学生
    void Delete(linklist &L) { 
    	int i, j, k = -1;
    	char ch;
    	printf("\n");
    	printf("\n");
    	printf("请输入要删除学生的学号:");
    	scanf("%d", &stud.num);
    	for (i = 0; i<L.length; i++) {
    		if (stud.num == L.elem[i].num) {
    			printf("该学生的信息为:\n");
    			printf("姓名:%s \n学号:%d \n房号:%d\n", L.elem[i].name, L.elem[i].num, L.elem[i].room);
    			k = i;
    			for (j = k; j<L.length - 1; j++)
    				L.elem[j] = L.elem[j + 1];
    			printf("已成功删除\n");
    
    			break;
    		}
    	}
    	if (i >= L.length) printf("该学生不存在\n");
    	if (k >= 0)L.length--;
    	fflush(stdin);
    	printf("\n");
    	printf("是否继续删除操作?<y/n>:");
    	scanf("%c", &ch);
    	system("cls");
    	if (ch == 'y') Delete(L);
    	else system("cls");
    }
    
    //主函数
    int main() {  
    	linklist L;    //定义线性表 L
    	Init(L);
    	Menu();        //调用主菜单函数
    	while (choice != 0) {
    		system("cls");
    		switch (choice) {
    			case 1:
    				Create(L);    //调用线性表创建函数
    				Menu();
    				break;
    			case 2:
    				Sort(L);
    				break;//调用排序函数
    			case 3:
    				Search(L);
    				break;//调用查找函数进行(二分)查找
    			case 4:
    				sort2(L);      //调用学号排序函数
    				Insert(L);        //按学号序列插入
    				system("cls");
    				printf("插入后的学生信息:\n");
    				Display(L);
    				Ret();
    				Menu();
    				break;
    			case 5:
    				Delete(L);    //调用删除函数
    				if (L.length == 0) {
    					printf("\n");
    					printf("学生记录已被删除完!\n");
    					Ret();
    					Menu();
    				} else {
    					printf("显示删除后的学生信息:\n");
    					Display(L);
    					Ret();
    					Menu();
    				}
    				break;
    		}
    	}
    }
    
    
    展开全文
  • 宿舍管理人员编写一个宿舍管理查询软件。 要求: 1)建立数据文件,数据文件按关键字(姓名,学号,房号)进行排序(冒泡,选择,插入排序等任意一种) 2)查询菜单(用二分法实现以下操作) A.按姓名查询 B...
  • 数据机构 课程设计 C++ 二分查找 直接插入排序 折半插入排序 快速排序
  • 数据结构课程设计-宿舍管理系统

    万次阅读 多人点赞 2015-12-27 19:36:52
    为期三天的课程设计到此就告一段落,一个宿舍系统的也已经初具雏形。以下是我的代码及演示。 /***************************************** *版权所有(c)2015,Yao Zhaoyan; *文件名称:宿舍系统 *文件标识:无 *内容...
            为期三天的课程设计到此就告一段落,一个宿舍系统的也已经初具雏形。以下是我的代码及演示。
    /*****************************************
    *版权所有(c)2015,Yao Zhaoyan;
    *文件名称:宿舍系统
    *文件标识:无
    *内容摘要:该代码用于宿舍管理
    *其他内容:无
    *当前版本:v1.0
    *作者:姚昭彦
    *完成日期:20151225
    *****************************************/
    头文件Header.h:
    #ifndef LIST_H_INCLUDED//防止重复定义出错
    #define LIST_H_INCLUDED
    
    #define MaxSize 700//宏定义变量
    #define MaxLen 12                //单词的最大长度
    #define Radix  10   
    typedef char String[MaxLen+1];  //定义String为字符数组类型
    typedef struct member//定义结构体
    {
    	String stu_num;//学号
    	char sushe[5];//宿舍号
    	char name[20];//名字长20字符
    	struct member *next;
    
    }Mem;//定义700个学生,数组序号即为宿舍号
    
    //MSD
    void Distribute(Mem *R,Mem *head[],Mem *tail[],int j,int n);//分配
    void Collect(Mem *R,Mem *head[]);//收集
    void RadixSort(Mem *R,int top);//基数排序
    //FIND
    int BinSearch1(Mem R[],int low,int high,String k);
    
    void hello();//欢迎界面
    void getinformation(Mem *p);//录入学生信息
    void showinformation(Mem *p);//打印学生信息
    void disinformation(Mem *p);//消除学生信息函数
    void print(Mem *p);
    void over();//退出程序
    void savedate();
    void readdate();
    void memb();
    
    #endif

    各主要功能函数other.cpp:
    #include"Header.h"
    #include <stdio.h>//清屏头文件
    #include<fstream>//读写文件表头
    #include<iostream>//C++头文件
    #include<iomanip>//输出格式的头文件
    using namespace std;
    
    Mem M[MaxSize];
    int top;
    int num;//作为用户做出选择时,输入的变量
    /***************************************
    *功能描述:输出程序选择界面
    *输入参数:num,
    *输出参数:
    *返回值:
    *其他说明:消息字段之间用分号(;)分隔
    ***************************************/
    void hello()//欢迎界面
    {
    	system("cls");//清屏
    	cout<<"*******************************"<<endl;
    	cout<<"**  ╭╮       ╭╮  ***"<<endl;  
    	cout<<"** ││**号楼管理系统││  ***"<<endl;  
    	cout<<"**╭┴┴———————┴┴╮***"<<endl;
    	cout<<"**│ ●       ● │***"<<endl;
    	cout<<"**│○  ╰┬┬┬╯  ○│***"<<endl;
    	cout<<"**│    ╰—╯    │***"<<endl;
    	cout<<"**╰——┬O———O┬——╯***"<<endl;
    	cout<<"**   ╭╮    ╭╮     ***"<<endl;
    	cout<<"**   ╰┴————┴╯     ***"<<endl;
    	cout<<"******* <1>录入学生信息 *******"<<endl;
    	cout<<"******* <2>查询宿舍信息 *******"<<endl;
    	cout<<"******* <3>消除学生信息 *******"<<endl;
    	cout<<"******* <4>所有学生信息 *******"<<endl;
    	cout<<"******* <0>退出管理系统 *******"<<endl;
    	cout<<"*******************************"<<endl;
    	cout<<"Please Enter Your Selection:";
    	
    	cin>>num;//输入选项
    	switch(num)
    	{
    		case 1:getinformation(M);break;//进入录入信息函数
    		case 2:showinformation(M);break;//进入打印信息函数
    		case 3:disinformation(M);break;//进入消除信息界面
    		case 4:print(M);break;
    		case 0:over();break;//结束程序
    	}	
    }
    /***************************************
    *功能描述:录入学生信息
    *输入参数:M(学生信息通过指针p输入)
    *输出参数:
    *返回值:
    *其他说明:消息字段之间用分号(;)分隔
    ***************************************/
    void getinformation(Mem *p)//录入学生信息函数
    {
    	system("cls");//清屏
    	String k;
    	int j;
    	for(int i=0;i<MaxSize;i++)//持续循环输入
    	{	
    		cout<<"请输入宿舍号"<<endl;
    		cin>>(p+top)->sushe;
    		cout<<"请输入名字:"<<endl;
    		cin>>(p+top)->name;
    		cout<<"请输入学号:"<<endl;
    		cin>>(p+top)->stu_num;
    		strcpy(k,(p+top)->stu_num);
    		j=BinSearch1(p,0,top-1,k);
    		if(j==0)
    		{
    			top++;//人数加1
    			cout<<"========================================================"<<endl;
    			cout<<"		1.next"<<"		"<<"2.back"<<endl;//next继续录入下一个,back返回主界面
    			cout<<"========================================================"<<endl;
    			cin>>num;//输入选择(1 or 2)
    			if(num==2) break;//num=1 不作处理,for循环继续。num=2中断循环。
    		}
    		else
    		{
    			cout<<"========================================================"<<endl;
    			cout<<"               该学号的学生已存在!"<<endl;
    			cout<<"========================================================"<<endl;
    			break;
    		}
    	}
    	RadixSort(p,top);//基数排序
    	savedate();//——————————————————————保存
    	cout<<"按任意键返回"<<endl;
    	system("pause");
    	hello();//返回主界面
    }
    /***************************************
    *功能描述:按宿舍打印信息
    *输入参数:room(宿舍号)
    *输出参数:M(学生信息通过指针p输出)
    *返回值:
    *其他说明:消息字段之间用分号(;)分隔
    ***************************************/
    void showinformation(Mem *p)//按宿舍打印信息
    {
    	char room[5];//用户输入查询的宿舍
    	int j,k=1;
    	system("cls");//清屏
    	cout<<"输入宿舍号"<<endl;
    	cin>>room;
    	system("cls");//清屏
    	cout<<"====================================================="<<endl;
    	cout<<"===========您现在查看的是"<<room<<"宿舍的学生信息==========="<<endl;
    	cout<<"====================================================="<<endl;
    	cout<<"========================================================"<<endl;
    	cout<<setiosflags(ios::right)<<setw(15)<<"姓名"<<setw(15)<<"学号"<<setw(15)<<"值日"<<endl;
    	cout<<"========================================================"<<endl;
    
    	for(int i=0;i<top;i++)//循环查询每个结构体中的宿舍号
    	{
    		j=strcmp(room,(p+i)->sushe);//数组比较函数,两数组相等时返回0
    		if(j==0&&k<7)//如果返回0,输出这个人的信息,最多输出6个人
    		{
    			
    			cout<<setiosflags(ios::right)<<setw(15)<<(p+i)->name<<setw(15)<<(p+i)->stu_num<<setw(15)<<"周"<<k<<endl;
    			cout<<"========================================================"<<endl;
    			k++;
    		}
    	}
    
    	cout<<"按任意键返回"<<endl;
    	system("pause");
    	hello();//调用主界面
    }
    /******************************************************
    *功能描述:按宿舍打印信息
    *输入参数:studentnum(用户输入要查询的学生的学号),num
    *输出参数:M(学生信息通过指针p输出)
    *返回值:
    *其他说明:消息字段之间用分号(;)分隔
    *******************************************************/
    void disinformation(Mem *p)//消除学生信息函数
    {
    	system("cls");//清屏
    	String studentnum;
    	int j,k;
    	cout<<"请输入学号:"<<endl;
    	cin>>studentnum;//用户输入要查询的学生的学号
    	j=BinSearch1(p,0,top-1,studentnum);
    
    	if(j==0)//如果没有找到此学号的学生,输出错误信息
    		{
    		cout<<"没有此人信息!"<<endl;
    		cout<<"按任意键返回"<<endl;
    		system("pause");
    		}
    	else
    		{
    			cout<<"========================================================"<<endl;
    			cout<<setiosflags(ios::right)<<setw(15)//输出这个学生的信息加以确认
    				<<(p+j)->sushe<<"宿舍"<<setw(15)
    				<<(p+j)->name<<setw(15)
    				<<(p+j)->stu_num<<setw(15)<<endl;
    			cout<<"========================================================"<<endl;
    			cout<<"你确定要消除信息吗?"<<endl;
    				
    			cout<<"========================================================"<<endl;
    			cout<<"		1.next"<<"		"<<"2.back"<<endl;
    			cout<<"========================================================"<<endl;
    			cin>>num;
    			if(num==1) //输入1继续消除
    			{
    				for(k=j+1;k<top;k++)//循环把之后每人的信息前移一个
    				{
    					strcpy((p+k-1)->sushe,(p+k)->sushe);
    					strcpy((p+k-1)->name,(p+k)->name);
    					strcpy((p+k-1)->stu_num,(p+k)->stu_num);
    				}
    				top--;//总人数减少一人
    				system("cls");//清屏
    
    				savedate();//——————————————————————保存
    				cout<<"信息消除成功!"<<endl;//输出成功信息
    				cout<<"按任意键返回"<<endl;
    				system("pause");
    			}
    		}
    	hello();//调用主界面
    }
    
    /******************************************************
    *功能描述:结束程序
    *输入参数:
    *输出参数:
    *返回值:
    *其他说明:消息字段之间用分号(;)分隔
    *******************************************************/
    void over()//结束程序函数
    {
    	return;
    }
    /******************************************************
    *功能描述:打印所有学生信息
    *输入参数:
    *输出参数:M(学生信息通过指针p输出)
    *返回值:
    *其他说明:消息字段之间用分号(;)分隔
    *******************************************************/
    void print(Mem *p)//打印所有学生信息
    {
    
    	system("cls");//清屏
    	for(int i=0;i<top;i++)
    	{
    		cout<<setiosflags(ios::right)<<setw(15)
    			<<(p+i)->stu_num<<setw(15)
    			<<(p+i)->sushe<<"宿舍"<<setw(15)
    			<<(p+i)->name<<endl;
    	}
    	cout<<"按任意键返回"<<endl;
    	system("pause");
    	hello();//调用主界面
    }
    
    /******************************************************
    *功能描述:打印所有学生信息
    *输入参数:
    *输出参数:top(现存录入学生信息条数),M(学生信息通过指针p输出)
    *返回值:
    *其他说明:消息字段之间用分号(;)分隔
    *******************************************************/
    void savedate()//——————————————————————保存
    {
    	ofstream outfile("Acount.dat",ios::binary);
    	if(!outfile)
    	{
    		cerr<<"open error!"<<endl;
    		abort();
    	}
    	outfile.write((char*)&top,sizeof(top));
    	for(int i=0;i<=top;i++)
    		outfile.write((char*)&M[i],sizeof(M[i]));
    	outfile.close();
    }
    /******************************************************
    *功能描述:打印所有学生信息
    *输入参数:【通过文件写入】top(现存录入学生信息条数),M(学生信息通过指针p输出)
    *输出参数:
    *返回值:
    *其他说明:消息字段之间用分号(;)分隔
    *******************************************************/
    void readdate()//——————————————————————读取
    {
    	top=0;
    	ifstream infile("Acount.dat",ios::binary);
    	if(!infile)
    	{
    		cerr<<"open error!"<<endl;
    		abort();
    	}
    	infile.read((char*)&top,sizeof(top));
    	for(int i=0;i<top;i++)		
    		infile.read((char*)&M[i],sizeof(M[i]));
    	infile.close();
    }

    基数排序MSD.cpp:
    #include"Header.h"
    #include <stdio.h>
    #include <malloc.h>
    #include <string.h>
    
    /***************************************
    *功能描述:基数排序-分配
    *输入参数:
    *输出参数:
    *返回值:
    *其他说明:消息字段之间用分号(;)分隔
    ***************************************/
    void Distribute(Mem R[],Mem *head[],Mem *tail[],int j,int top)
    //按关键字的第j个分量进行分配,进入此过程时各队列一定为空
    {
        int i,k;
        Mem *p;
        for (i=0; i<top; i++)         //依次扫描R[i],将其入队
        {           
            k=R[i].stu_num[j]-48;//从最低位开始扫描,0时放入0号队列中,1时放入1号队列中,…
            p=(Mem *)malloc(sizeof(Mem)); //创建新结点
    
            strcpy(p->stu_num,R[i].stu_num);//赋值,数据全部跟着关键字“学号”转移
    		strcpy(p->sushe,R[i].sushe);
    		strcpy(p->name,R[i].name);
            p->next=NULL;//指针指向空
    		//赋head,tail
            if (head[k]==NULL)//如果这个队列还没有数的话
            {
                head[k]=p;
                tail[k]=p;
            }
            else//如果已有其他数
            {
                tail[k]->next=p;
                tail[k]=p;
            }
        }
    }
    /***************************************
    *功能描述:基数排序-收集
    *输入参数:
    *输出参数:
    *返回值:
    *其他说明:消息字段之间用分号(;)分隔
    ***************************************/
    void Collect(Mem R[],Mem *head[])
    //依次将各非空队列中的记录收集起来
    {
        int k=0,i;
        Mem *p;
        for (i=0; i<Radix; i++)	//i取1-10
    	{
            for (p=head[i]; p!=NULL; p=p->next)//p作为循环变量,循环一次指向下一个数据
    		{
                strcpy(R[k].stu_num,p->stu_num);//把经过排序的数据覆盖到原来的数组
    			strcpy(R[k].sushe,p->sushe);
    			strcpy(R[k].name,p->name);
    			k++;
    		}
    	}
    }
    /***************************************
    *功能描述:基数排序
    *输入参数:
    *输出参数:
    *返回值:
    *其他说明:消息字段之间用分号(;)分隔
    ***************************************/
    void RadixSort(Mem R[],int top)    //进行基数排序
    {
        Mem *head[Radix],*tail[Radix]; //定义Radix个队列
        int i,j;
        for (i=MaxLen-1; i>=0; i--)             //从低位到高位做d趟箱排序 (最后一位,i>0,从最后一位往前数)
        {
            for (j=0; j<Radix; j++)				//Radix基数,十进制为10		
    		{head[j]=tail[j]=NULL;}  //队列置空
    
            Distribute(R,head,tail,i,top);        //分配
            Collect(R,head);                    //收集
        }
    }
    

    折半查找FIND.cpp
    #include"Header.h"
    #include<iostream>//C++头文件
    using namespace std;
    /***************************************
    *功能描述:折半查找
    *输入参数:
    *输出参数:
    *返回值:
    *其他说明:消息字段之间用分号(;)分隔
    ***************************************/
    int BinSearch1(Mem R[],int low,int high,String k)//low为0,high为top-1
    {
        int mid;
        if (low<=high)      //查找区间存在一个及以上元素
        {
            mid=(low+high)/2;  //求中间位置
            if (strcmp(R[mid].stu_num,k)==0) //查找成功返回其逻辑序号mid+1
                return mid;
            if (strcmp(R[mid].stu_num,k)>0)  //在R[low..mid-1]中递归查找
                BinSearch1(R,low,mid-1,k);
            else              //在R[mid+1..high]中递归查找
                BinSearch1(R,mid+1,high,k);
        }
        else
            return 0;
    }

    主函数main.cpp:
    #include"Header.h"
    #include <stdio.h>//清屏头文件
    #include<iostream>//C++头文件
    #include<string>//字符串头文件
    using namespace std;
    
    int main()
    {	
    	string ID,key;//进入程序所需账号密码
    	cout<<"pleace enter your username:";//管理员名	
    	for(int i=0;i<3;i++)	
    	{
    		cin>>ID;
    		if(ID!="admin") 
    		{
    			cout<<"ID can't be found!"<<endl;
    			cout<<"pleace enter your username:";
    			if(i==2)exit(0);//三次错误跳出
    		}
    		else break;
    	}
    	
    	cout<<"pleace enter your password:";//管理员密码	
    	for(i=0;i<3;i++)
    	{
    		cin>>key;
    		if(key!="admin") 
    		{
    			cout<<"key is wrong!"<<endl;
    			cout<<"pleace enter your password:";
    			if(i==2)exit(0);//三次错误跳出
    		}
    		else break;
    	}
    
    	readdate();//——————————————————————读取
    	hello();//欢迎界面		
    
    	cout<<"按任意键返回"<<endl;
    	system("pause");
    	
    	return 0;
    }

    运行结果:
    1.验证管理员用户的账号和密码,三次不对跳出程序。

    2.登陆后的主选择界面

    3.选择1,录入学生信息,完成后选择1.next继续输入下一个,选择2.back返回选择界面

    4.如果录入的学号已经存在,则出现提示信息并返回选择界面。

    5.选择2查询宿舍信息,输入要查询的宿舍号,则出现宿舍全员的信息。

    6.选择3消除学生信息,输入要消除学生的学号,若没有此人则出现提示并返回选择界面,若查找到则弹出学生信息加以确认,删除后返回选择界面。

    7.选择4打印所有学生信息,则出现按学号排序的所有学生信息



    展开全文
  • 题目:宿舍管理系统(为宿舍管理人员编写一个宿舍管理查询软件) 要求: 1.采用交互工作方式 2.建立数据文件,数据文件按关键字(姓名、学号、房号)进行排序(冒泡、选择、插入排序等任选一种) 3.查询菜单:用...

    题目:宿舍管理系统(为宿舍管理人员编写一个宿舍管理查询软件)
    要求:

       1.采用交互工作方式
       2.建立数据文件,数据文件按关键字(姓名、学号、房号)进行排序(冒泡、选择、插入排序等任选一种)
       3.查询菜单:用二分查找实现以下操作,并输出查询结果(可以连续操作)
                          A.按姓名查询 
                          B.按学号查询
                          C.按房号查询
    

    代码:
    list.cpp

    #include<iostream>
    #include<string.h>
    
    using namespace std;
    
    struct Node { //定义结构体,存放学生信息
       string sname;
       int sid;
       int sroom;
       Node *next;
       Node(); //构造函数
    };
    
    Node::Node()
    {
        sid = 0;
        sname = '\0';
        sroom = 0;
        next = NULL;
    }
    
    class List {
    public:
        List();  //构造函数
        int size() const; //返回线性表的大小
        Node *set_position(int position) const; //让指针指向指定位置
        void insert(const Node &x);//插入数据
        void sid_sort(); //按学号排序
        void sname_sort(); //按姓名排序
        void sroom_sort(); //按房号排序
        void sidbinary_search(int target); //按学号查找
        void snamebinary_search(string target); //按名字查找
        void sroombinary_search(int target); //按宿舍号查找
        void print();
        ~List(); //析构函数
    protected:
        int count; //计数器
        Node *head; //头指针
    };
    
    List::List()  //构造函数
    {
        count = 0; //计数器置0
        head = NULL;
    }
    
    int List::size() const  //返回线性表大小
    {
        return count;
    }
    
    Node *List::set_position(int position) const  //让指针指到指定位置
    {
       Node *q = head;
       for (int i = 0; i < position; i++) q = q->next; //遍历,找到指定位置
       return q;
    }
    
    void List::insert(const Node &x)//插入数据
    {
        Node *p = new Node();
        p->sid = x.sid;
        p->sname = x.sname;
        p->sroom = x.sroom;
        p->next = NULL;
        if(count == 0)//如果原链表没有数据则插入的是表头
        {
            head = p;
        }
        else
        {
            Node *q = head;
            while(q->next != NULL)
            {
                q = q->next;
            }
            q->next = p;
        }
        count++;
        cout << "Success!" << endl;
    }
    
    void List::sid_sort()//按学号排序
    {
        if(count == 0)
        {
            cout << "No Student Information!" << endl;
            return ;
        }
    
        Node *first_unsorted;//指向无序结点
        Node *position; //指向可以插入结点位置
        Node *inter; //找到的可以插入的结点
        Node *current;//用来指向有序链表的结点
        first_unsorted = head->next;//开始无序结点是current的下一个结点
        current = head;
        current->next = NULL;
    
        while(first_unsorted)//直到链表最后一个结点结束
    	{
    		inter = first_unsorted;//每次从一个新的无序结点开始
    		first_unsorted = first_unsorted ->next;//指向下一个无序结点
    
    		current = head;
    		//而有序结点则从第一个开始,每次从最小的开始比较;如果比当前最小的还小放在它前面
    
    		while(current && (current->sid < inter->sid))//如果比当前有序结点大,则和下一个有序结点比较
    		{
    			position = current;
    			current = current->next;
    		}
    
    		if(current == head )//即比第一个有序结点还小,则头插
    			head = inter;
    		else //要插入的不是头结点则把它插入找出的合适的位置
                position->next = inter;
    		inter->next = current;//将新结点与后面的链表连接起来
    	}
    	cout << "Sort Success!" << endl;
    }
    
    void List::sname_sort()//按姓名排序
    {
        if(count == 0)
        {
            cout << "No Student Information!" << endl;
            return ;
        }
        Node *first_unsorted;//指向无序结点
        Node *position; //指向可以插入结点位置
        Node *inter; //找到的可以插入的结点
        Node *current;//用来指向有序链表的结点
    
    
        current = head;//开始认为第一个结点有序
        first_unsorted = head->next;//开始无序结点是current的下一个结点
        current->next = NULL;
    
        while(first_unsorted)//直到链表最后一个结点结束
    	{
    		inter = first_unsorted;//每次从一个新的无序结点开始
            first_unsorted = first_unsorted ->next ;//指向下一个无序结点
    
    		current = head ;
    		//而有序结点则从第一个开始,每次从最小的开始比较;如果比当前最小的还小放在它前面
    
    		while(current && (current->sname < inter->sname))//如果比当前有序结点大,则和下一个有序结点比较
    		{
    			position = current;
    			current = current->next ;
    		}
    
    		if(current == head )//即比第一个有序结点还小,则头插
    			head = inter;
    		else //要插入的不是头结点则把它插入找出的合适的位置
                position->next = inter;
    		inter->next = current;//将新结点与后面的链表连接起来
    	}
    	cout << "Sort Success!" << endl;
    }
    
    void List::sroom_sort()//按房号排序
    {
        if(count == 0)
        {
            cout << "No Student Information!" << endl;
            return ;
        }
        Node *first_unsorted;//指向无序结点
        Node *position; //指向可以插入结点位置
        Node *inter; //找到的可以插入的结点
        Node *current;//用来指向有序链表的结点
    
    
        current = head;//开始认为第一个结点有序
        first_unsorted = head->next;//开始无序结点是current的下一个结点
        current->next = NULL;
    
        while(first_unsorted)//直到链表最后一个结点结束
    	{
    		inter = first_unsorted;//每次从一个新的无序结点开始
    
            first_unsorted = first_unsorted ->next;//指向下一个无序结点
    
    		current = head ;
    		//而有序结点则从第一个开始,每次从最小的开始比较;如果比当前最小的还小放在它前面
    
    		while(current && (current->sroom < inter->sroom))//如果比当前有序结点大,则和下一个有序结点比较
    		{
    			position = current;
    			current = current->next ;
    		}
    
    		if(current == head )//即比第一个有序结点还小,则头插
    			head = inter;
    		else //要插入的不是头结点则把它插入找出的合适的位置
                position->next = inter;
    		inter->next = current;//将新结点与后面的链表连接起来
    	}
    	cout << "Sort Success!" << endl;
    }
    
    void List::print() //按顺序打印出线性表数据
    {
        Node *p = head;
        cout << "sid     sname     sroom" << endl;
        while(p != NULL)
        {
            cout << p->sid << "     " << p->sname << "     " << p->sroom << endl;
            p = p->next;
        }
    }
    
    void List::sidbinary_search(int target) //按学号查找
    {
        Node *mid;
    
        int frontnum = 0;
        int lastnum = count - 1;//前后下标,用来规定范围
    
        while (frontnum < lastnum)  //当前下标小于后下标,继续循环
        {
            int midnum = (frontnum + lastnum) / 2;//找出中间坐标
    
            mid = set_position(midnum);
            if(mid->sid < target)
                frontnum = midnum + 1; //如果中间的值小于要查找的值,说明要查找的值在后半部分,前下标移到中间位置的后一个位置
            else
                lastnum = midnum; //如果中间的值大于要查找的值,说明要查找的值在前半部分,后下标移到中间位置
        }
        if (lastnum < frontnum)
        {
            cout << "Student information is not exit!" << endl; //当前下标大于后下标时,说明没有找到
        }
        else //当前后下标指向同一个元素
        {
            mid = set_position(frontnum);
            if (mid->sid == target) //判断这个结点中的数据与所查找的数据是否一致,如果一致则输出,该位置一定是在这个线性表中第一次出现的位置
            {
                cout <<  "sid" << "     "<< "sname" << "     "<< "sroom" << endl;
                cout << mid->sid << "     " << mid->sname << "     " << mid->sroom << endl;
            }
            else //如果不是则说明表中没有这个数据
            {
                cout << "Student information is not exit!" << endl;
            }
        }
    }
    
    void List::snamebinary_search(string target) //按姓名查找
    {
        Node *mid;
    
        int frontnum = 0;
        int lastnum = count - 1;//前后下标,用来规定范围
    
        while (frontnum < lastnum)  //当前下标小于后下标,继续循环
        {
            int midnum = (frontnum + lastnum) / 2;//找出中间坐标
    
            mid = set_position(midnum);
            if (mid->sname < target)
                frontnum = midnum + 1; //如果中间的值小于要查找的值,说明要查找的值在后半部分,前下标移到中间位置的后一个位置
            else//当前后下标指向同一个元素
                lastnum = midnum; //如果中间的值大于要查找的值,说明要查找的值在前半部分,后下标移到中间位置
        }
        if (lastnum < frontnum) //当前下标大于后下标时,说明没有找到
        {
            cout << "Student information is not exit!" << endl;
        }
        else
        { //当前后下标指向同一个元素
            mid = set_position(frontnum);
            if (mid->sname == target)//判断这个结点中的数据与所查找的数据是否一致,如果一致则输出,该位置一定是在这个线性表中第一次出现的位置
            {
                cout <<  "sname" << "     "<< "sid" << "     "<< "sroom" << endl;
                cout << mid->sname << "     " << mid->sid << "     " << mid->sroom << endl;
                if(mid->next != NULL)
                {
                    Node *p = mid->next;
                    while(p && (p->sname == mid->sname)) //查找后面还有没有相同的数据
                    {
                        cout << p->sname << "     " << p->sid << "     " << p->sroom << endl;
                        p = p->next;
                    } //如果这个位置的值等于要查找的值,则该位置一定是在这个表中第一次出现的位置
                }
    
            }
            else//如果不是则说明表中没有这个数据
            {
                    cout << "Student information is not exit!" << endl;
            }
        }
    }
    
    void List::sroombinary_search(int target) //按房号查找
    {
        Node *mid;
    
        int frontnum = 0;
        int lastnum = count - 1;//前后下标,用来规定范围
    
        while (frontnum < lastnum)  //当前下标小于后下标,继续循环
        {
            int midnum = (frontnum + lastnum) / 2;//找出中间坐标
    
            mid = set_position(midnum);
            if (mid->sroom < target)
                frontnum = midnum + 1; //如果中间的值小于要查找的值,说明要查找的值在后半部分,前下标移到中间位置的后一个位置
            else
                lastnum = midnum; //如果中间的值大于要查找的值,说明要查找的值在前半部分,后下标移到中间位置
        }
        if (lastnum < frontnum)//当前下标大于后下标时,说明没有找到
        {
            cout << "Student information is not exit!" << endl;
        }
        else { //当前后下标指向同一个元素
                mid = set_position(frontnum);
                if (mid->sroom == target)
                {
                    cout <<  "sroom" << "     "<< "sid" << "     "<< "sname" << endl;
                    cout << mid->sroom << "     " << mid->sid << "     " << mid->sname <<  endl;
                    if(mid->next != NULL)
                    {
                        Node *p = mid->next;
                        while(p && (p->sroom == mid->sroom))//查找后面还有没有相同的数据
                        {
                            cout << p->sroom << "     " << p->sid << "     " << p->sname << endl;
                            p = p->next;
                        }//如果这个位置的值等于要查找的值,则该位置一定是在这个表中第一次出现的位置
                    }
    
                }
                else//如果不是则说明表中没有这个数据
                {
                    cout << "Student information is not exit!" << endl;
                }
        }
    }
    
    List::~List()  //析构函数
    {
        Node *p,*q;
        for(p = head;p;p = q)
        {
            q = p->next;
            delete p;
        }  //遍历,有数据的释放空间
        count = 0;
        head = NULL; //置空
    }
    
    

    main.cpp

    #include <iostream>
    #include <fstream>
    #include "list.cpp"
    
    using namespace std;
    
    void print(List const &nowlist) //将线性表中的数据写入文件中
    {
        ofstream ofs;
        ofs.open("student.txt",ios::out);
        ofs.clear();
        Node *p;
    
        ofs << "sid" << "     " << "sname" << "     "  << "sroom" << endl;
        for(int i = 0;i < nowlist.size();i++)
        {
            p = nowlist.set_position(i);
            ofs << p->sid << "     " << p->sname << "     "  << p->sroom<< endl;
        }
        ofs.close();
    }
    
    int main()
    {
        List list1;
        ofstream ofs;
        ofs.open("student.txt",ios::out);
        ofs << "sid" << "     " << "sname" << "     "  << "sroom" << endl;
    
        int t = 1;
        char i = 0;
        cout << "---------------------------------------------------" << endl;
        cout << "欢迎进入宿舍查询软件" << endl;
        cout << "---------------------------------------------------" << endl;
        while(t)
        {
            cout << "1.插入学生信息  2.排序  3.查询  4.退出" << endl << "请选择要进行的操作:";
            cin >> i;
    
            switch(i)
            {
                case '1': //插入学生信息
                    {
                        Node newstu;
    
                        cout << "请输入该学生的学号:";
                        cin >> newstu.sid;
                        if(cin.fail())
                        {
                            cout << "Please enter the correct number!" << endl;
                            cin.clear(); //清除std::cin的错误状态
                            cin.sync(); //清空输入缓冲区
                            break;
                        }
                        cout << "请输入该学生的姓名:";
                        cin >> newstu.sname;
                        cout << "请输入该学生的房号:";
                        cin >> newstu.sroom;
                        if(cin.fail())
                        {
                            cout << "Please enter the correct number!" << endl;
                            cin.clear(); //清除std::cin的错误状态
                            cin.sync(); //清空输入缓冲区
                            break;
                        }
    
                        list1.insert(newstu);
    
                        ofs << newstu.sid << "     " << newstu.sname << "     "  << newstu.sroom<< endl;
                        break;
                    }
                case '2': //排序
                    {
                        char ch;
                        cout << "A.按姓名排序  B.按学号排序  C.按房号排序" << endl << "请选择排序的方式:";
                        cin >> ch;
                        switch(ch)
                        {
                            case 'A': //按姓名排序
                                {
                                    list1.sname_sort();
                                    print(list1);
                                    continue;
                                }
                            case 'B': // 按学号排序
                                {
                                    list1.sid_sort();
                                    print(list1);
                                    continue;
                                }
                            case 'C': //按房号排序
                                {
                                    list1.sroom_sort();
                                    print(list1);
                                    continue;
                                }
                            default:
                                {
                                    cout << "无此选项,请重新选择" << endl;
                                    continue;
                                }
                        }
                    }
                case '3': //查询
                    {
                        char ch;
                        cout << "A.按姓名查询  B.按学号查询   C.按房号查询 " << endl << "请选择查询的方式:";
                        cin >> ch;
                        switch(ch)
                        {
                            case 'A': //按姓名查询
                                {
                                    string name;
                                    cout << "请输入要查询的学生的姓名:";
                                    cin >> name;
                                    list1.sname_sort();
                                    list1.snamebinary_search(name);
                                     continue; //问题:运行这部分完程序直接结束
                                }
                            case 'B': //按学号查询
                                {
                                    int id;
                                    cout << "请输入要查询的学生的学号:";
                                    cin >> id;
                                    if(cin.fail())
                                    {
                                        cout << "Please enter the correct number!" << endl;
                                        cin.clear(); //清除std::cin的错误状态
                                        cin.sync(); //清空输入缓冲区
                                        break;
                                    }
                                    list1.sid_sort();
                                    list1.sidbinary_search(id);
                                    continue;
                                }
                            case 'C': //按房号查询
                                {
                                    int room;
                                    cout << "请输入要查询的房号:";
                                    cin >> room;
                                    if(cin.fail())
                                    {
                                        cout << "Please enter the correct number!" << endl;
                                        cin.clear(); //清除std::cin的错误状态
                                        cin.sync(); //清空输入缓冲区
                                        break;
                                    }
                                    list1.sroom_sort();
                                    list1.sroombinary_search(room);
                                     continue;
                                }
                            default:
                                {
                                    cout << "无此选项,请重新选择" << endl;
                                    continue;
                                }
                        }
                    }
                case '4': //退出
                    {
                        t = 0;
                        break;
                    }
    
                default:
                    {
                        cout << "无此选项,请重新选择" << endl;
                        break;
                    }
            }
        }
        return 0;
    }
    
    
    展开全文
  • 数据结构课程设计宿舍管理查询系统,实验代码和实验报告
  • 数据库的概念数据库是一种存储数据并对数据进行操作的工具。数据库的作用在于组织和表达信息,简而言之,数据库就是信息的集合。计算机的数据库可以分为两类:非关系...Java web 课程设计宿舍管理系统)数据库部分。
  • 宿舍管理查询 数据结构课程设计 完整源代码 c语言编写 分模块设计
  • 山东大学数据结构课程设计——宿舍管理查询软件 问题描述 1)编写一个宿舍管理查询软件,程序设计要求 A采用交互工作方式 B建立数据文件,数据文件按照关键字(姓名,学号,房号)进行排序 2)查询菜单 A按照姓名...

    数据结构课程设计——宿舍管理查询软件

    问题描述
    1)编写一个宿舍管理查询软件,程序设计要求
    A采用交互工作方式
    B建立数据文件,数据文件按照关键字(姓名,学号,房号)进行排序
    2)查询菜单
    A按照姓名查询
    B按照学号查询
    C按照房号查询
    3)打印任意查询结果(可以连续操作)

    程序设计
    1,读取数据文件(xxx.txt),如不存在该文件,则创建同名文件(添加 增加和删除 两项操作)。
    2,对数据文件可以进行关键字排序
    3,可以按照关键字进行查询
    4,可以对查询结果进行修改(多次查询结果累加,可以进行连续的删除)
    5,使用循环实现交互式工作

    算法设计和数据结构
    算法设计:
    对数据文件进行初始化操作采用及时终止的冒泡排序,复杂度为O(n^2),如果两次采用相同的排序方式,复杂度为O(1)
    进行查询,插入,删除操作复杂度都是O(n)

    数据结构:
    采用自动扩容的数组存储,使用结构组织数据

    你可能会需要注意的地方
    1,在txt文件中存储的格式如下:
    Amy 10000010 101
    Ben 10000001 101

    注意:格式为名字 学号 宿舍号。名字与学号,学号与宿舍号之间为一个空格,每条数据占一行,文件最后留一空行。
    2,你可能必须要在文件位置输入时加上.txt
    3,在文件直接输入中文读取时可能产生乱码
    4,可以直接输入文件名称,默认为当前目录下,如果没有则会自动生成同名文件

    代码展示

    #include <iostream>
    #include <cstring>
    #include <fstream>
    #include <sstream>
    #include <string>
    using namespace std;
    
    struct Student//储存数据的结构
    {
      string name;
      long id;
      int room;
    };
    
    string file_name ;//输入的文件名称,只支持txt文件
    
    void manage(Student* s,int i,int& length,Student* store,int& store_length,int arr)
    //s存储全部数据,i为输入的指令,length为s的数据个数,store为查询得到的数据,store_length为store的数据个数,arr为最开始所选择的排序方式
    {
      if(i==0)//主菜单
      {
        cout<<"Welcome"<<endl;
        cout<<"0 for The Start"<<endl;
        cout<<"1 for Insert"<<endl;
        cout<<"2 for Delete"<<endl;
        cout<<"3 for QueryByName"<<endl;
        cout<<"4 for QueryById"<<endl;
        cout<<"5 for QueryByRoom"<<endl;
        cout<<"6 for Print What You Query"<<endl;
        cout<<"7 for Print All"<<endl;
        cout<<"8 for Delete What You Query"<<endl; 
        cout<<"9 for The End"<<endl;
      }
      else if(i==1)//对文件进行插入操作
      {
        Student temp;
        cout<<"Name:";
        cin>>temp.name;
        cout<<"Id:";
        cin>>temp.id;
        cout<<"Room:";
        cin>>temp.room;
    
        for(int p=0;p<length;p++)
        {
          bool bo;
          switch (arr)
          {
          case 1:bo=(temp.name<s[p].name);
            break;
          case 2:bo=(temp.id<s[p].id);
            break;
          case 3:bo=(temp.room<s[p].room);
            break;
          case 4:bo=(temp.name>s[p].name);
            break;
          case 5:bo=(temp.id>s[p].id);
            break;
          case 6:bo=(temp.room>s[p].room);
            break;       
          default:
            break;
          }      
          if(bo)
          {
            for(int c=length;c>p;c--)
              {
                s[c]=s[c-1];
              }
              s[p]=temp;
              length++;
              break;
          }
          if(p==length-1)
          {
            s[length]=temp;
            length++;
            break;
          }
        }
        if(length==0)
        {
          s[0]=temp;
          length++;
        }
        ofstream of;
        of.open(file_name,ios::out|ios::trunc);
        if(of.is_open()){
          for(int k=0;k<length;k++){
            of<<s[k].name<<" "<<s[k].id<<" "<<s[k].room<<"\n";
          }     
        }
        of.close();
        cout<<"Insert successfully"<<endl;
      }
      else if(i==2)//对文件进行删除操作
      {
        cout<<"Which one ?";
        int de;cin>>de;
        if(de<=length&&de>0)
        {
        for(int p=de;p<length;p++)
          {
            s[p-1]=s[p];     
          }
        length--;
        ofstream of;
        of.open(file_name,ios::out|ios::trunc);
        if(of.is_open()){
          for(int k=0;k<length;k++){
            of<<s[k].name<<" "<<s[k].id<<" "<<s[k].room<<"\n";
          }     
        }
        of.close();
        cout<<"Deleted successfully"<<endl;
        }
        else 
        cout<<"Wrong !"<<endl;
      }
      else if(i==3)//对文件进行姓名查询
      {
        cout<<"Name ?";
        string na;int count=0;
        cin>>na;
        for(int i=0;i<length;i++){
          if(s->name==na){
            cout<<"Name: "<<s->name<<"  Id: "<<s->id<<"  Room: "<<s->room<<endl;
            store[store_length]=*s;
            store_length++;
            count++;
          }
          s++;
        }
        if(count==0)cout<<"NULL"<<endl;  
      }
      else if(i==4)//对文件进行学号查询
      {
        cout<<"Id ?";
        long na;int count=0;
        cin>>na;
        for(int i=0;i<length;i++){
          if(s->id==na){
            cout<<"Name: "<<s->name<<"  Id: "<<s->id<<"  Room: "<<s->room<<endl;
            store[store_length]=*s;
            store_length++;
            count++;
          }
          s++;
        }
        if(count==0)cout<<"NULL"<<endl; 
      }
      else if(i==5)//对文件进行房间号查询
      {
        cout<<"Room ?";
        int na;int count=0;
        cin>>na;
        for(int i=0;i<length;i++){
          if(s->room==na){
            cout<<"Name: "<<s->name<<"  Id: "<<s->id<<"  Room: "<<s->room<<endl;
            store[store_length]=*s;
            store_length++;
            count++;
          }
          s++;
        }
        if(count==0)cout<<"NULL"<<endl; 
      }
      else if(i==6)//输出查询结果
      {
        for(int k=0;k<store_length;k++){
          cout<<"Name: "<<store[k].name<<"  Id: "<<store[k].id<<"  Room: "<<store[k].room<<endl;
        }    
      }
      else if(i==7)//输出全部数据
      {
        for(int q=0;q<length;q++){
          cout<<"Name: "<<s[q].name<<"  Id: "<<s[q].id<<"  Room: "<<s[q].room<<endl;
        }
      }
      else if(i==8)//对查询结果进行删除操作
      {
        int start,end;
        cout<<"The start:";
        cin>>start;
        cout<<"The end:";
        cin>>end;
        if(end>store_length||start<1||end<start){
          cout<<"wrong"<<endl;
        }
        else{
        int b=store_length;
        for(int e=b;e<b+(end-start+1);e++){
          store[e].name="a";
          store[e].id=0;
          store[e].room=0;
        }
        int d=end;
        for(int o=start;o<b+(end-start+1);o++){
          store[o-1]=store[d];
          d++;
        }
        for(int p=0;p<b;p++){
          if(store[p].id==0)
          store_length--;
        }
        }
      }
    }
    
    void sort(int a,int length,Student* so)//对文件数据进行排序,采用及时终止的冒泡排序
    {
      if(a==1){
        for(int i=0;i<length;i++){
          int count=0;
          for(int j=0;j<length-1;j++){
            if(so[j].name>so[j+1].name){
              Student s=so[j];
              so[j]=so[j+1];
              so[j+1]=s;
              count++;
            }
          }
          if(count==0) break;
        }
      }
      else if(a==2){
        for(int i=0;i<length;i++){
          int count=0;
          for(int j=0;j<length-1;j++){
            if(so[j].id>so[j+1].id){
              Student s=so[j];
              so[j]=so[j+1];
              so[j+1]=s;
              count++;
            }
          }
          if(count==0) break;
        }
      }
      else if(a==3){
        for(int i=0;i<length;i++){
          int count=0;
          for(int j=0;j<length-1;j++){
            if(so[j].room>so[j+1].room){
              Student s=so[j];
              so[j]=so[j+1];
              so[j+1]=s;
              count++;
            }
          }
          if(count==0) break;
        }
      }
      else if(a==4){
        for(int i=0;i<length;i++){
          int count=0;
          for(int j=0;j<length-1;j++){
            if(so[j].name<so[j+1].name){
              Student s=so[j];
              so[j]=so[j+1];
              so[j+1]=s;
              count++;
            }
          }
          if(count==0) break;
        }
      }
      else if(a==5){
        for(int i=0;i<length;i++){
          int count=0;
          for(int j=0;j<length-1;j++){
            if(so[j].id<so[j+1].id){
              Student s=so[j];
              so[j]=so[j+1];
              so[j+1]=s;
              count++;
            }
          }
          if(count==0) break;
        }
      }
      else if(a==6){
        for(int i=0;i<length;i++){
          int count=0;
          for(int j=0;j<length-1;j++){
            if(so[j].room<so[j+1].room){
              Student s=so[j];
              so[j]=so[j+1];
              so[j+1]=s;
              count++;
            }
          }
          if(count==0) break;
        }
      }
    
      ofstream of;
    
      of.open(file_name,ios::out|ios::trunc);
    
      if(of.is_open()){
        for(int k=0;k<length;k++){
          of<<so[k].name<<" "<<so[k].id<<" "<<so[k].room<<"\n";
        }     
      }
      of.close();
    }
    
    int main(){
    
      cout<<"Your File :";
      cin>>file_name;//输入在同一目录的下的txt文件名称,如果没有将会创建一个新的同名文件
    
      cout<<"1 name ascend"<<endl;
      cout<<"2 id ascend"<<endl;
      cout<<"3 room ascend"<<endl;
      cout<<"4 name descend"<<endl;
      cout<<"5 id descend"<<endl;
      cout<<"6 room descend"<<endl;
    
      int arr;cin>>arr;//选择排序方式
    
      while(arr!=1&&arr!=2&&arr!=3&&arr!=4&&arr!=5&&arr!=6){
        cout<<"Wrong Number !"<<endl;
        cout<<"Again:";
        cin>>arr;
      }
    
      ifstream infile;
    
      string str;
    
      infile.open(file_name);
    
      if(!infile.is_open()){
    
        ofstream fout(file_name);
    
        if(fout){
          fout.close();
        }
    
      }
      int Number=0;
      while(getline(infile,str)){
        Number++;
      }
      
      Number+=2000;//创建的数组为原文件加2000,确保在使用该程序输入过程中不会发生数组越界
    
      Student stu[Number],store[Number];
    
      infile.close();
      
      infile.open(file_name);
    
      int length=0;
      int store_length=0;
    
      while(getline(infile,str))//将文件中的数据读入并存入数组
      {
    
        char* co=new char[str.length()+1];
    
        strcpy(co,str.c_str());
    
        char *p=strtok(co," ");
    
    
        while(p!=0){
         
            stu[length].name=p;
            p=strtok(NULL," "); 
    
            string o1(p);
            stringstream s1;
            s1<<o1;
            s1>>stu[length].id;
            p=strtok(NULL," ");
    
            string o2(p);
            stringstream s2;
            s2<<o2;
            s2>>stu[length].room;
            p=strtok(NULL," ");
    
        }
        length++;
        delete[] co;
      }  
    
      infile.close();
    
      sort(arr,length,stu);//对文件进行排序,并重写文件内容
    
      int order=0; 
    
      while(order!=9)//实现交互式操作
      {
        manage(stu,order,length,store,store_length,arr);
        cin>>order;
      }   
      return 0;
      //粗制滥造,感谢观看
    }
    

    测试文本
    在这里插入图片描述
    结果展示
    在这里插入图片描述

    展开全文
  • 学生宿舍管理系统的某些信息应当能够以报表形式打印出来。基本上应该能够实现学生基本信息的报表打印、某宿舍具体住宿情况的报表打印、某栋宿舍楼的所有员工信息打印、所有学生各年度宿舍交费情况打印、学生物品出入...
  • 学生通讯录管理系统设计;2 概要设计;3 详细设计;int main) { int choose; book b; while (choose = b.face) { switch (choose) {case 1: b.find;////查询联系人 break; case 2: b.add_person;////添加联系人 break; ...
  • 学生宿舍管理系统数据库的课程设计,包括需求分析说明书,E-R图,建库源码,总结等各种课程设计所需....
  • 第四章 系统总体设计 8 4.1 系统功能图 8 4.2 系统流程图 8 第五章 系统详细设计 10 5.1 用户模块设计 10 5.2 数据库设计 11 5.2.1数据库设计的原则 11 5.2.2数据库表的设计 11 第六章 系统实现 14 6.1 系统功能实现...
  • 学号 20XX-20XX年 第 20XX-20XX年 第一学期 数据结构 课程设计汇报 题目 宿舍管理查询系统实现 专业 班级 姓名 学号 指导老师 成绩 计算机和信息工程系 20XX年 10 月25 日 目 录 TOC \o "1-1" \h \u 26667 1设计任务...
  • C语言源代码(学生成绩管理系统,图书馆管理系统,管理,二叉树...二叉树遍历学生宿舍管理系统图书馆管理系统此资源是数据结构中的代码,您需要下载它,对您所有人都有帮助. 它已调试,没有错误!C语言课程设计图书管...
  • 宿舍管理系统Java课程设计 Java 课程设计设计(论文) 题目: 宿舍管理系统 所 在 院: 专 业 : 班 级 : 学 生 姓 名: 学 号: 指 导 教 师: 年 月 日课程设计(论文)任务书设计题目: 宿舍管理系统 专业 : 班级:...
  • 成绩 徐州工程学院 课 程 设 计 报 告 课 程 名 称 数据结构课程设计 专 业 计算机科学与技术 班 级 09 计单 学 生 姓 名 黄 晨 学 号 * 设 计 题 目 宿舍查询管理系统 指 导 教 师 * 设计起止时间 2011 年 6 月 20...
  • 课程设计——宿舍管理系统c语言

    千次阅读 2021-01-20 22:32:27
    《数据结构》课程主要介绍最常用的数据结构,进行数据结构课程设计要达到以下目的: (1)了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力; (2)初步掌握软件开发过程的问题分析、系统设计、程序...
  • 数据结构课程设计

    2017-01-22 16:14:10
    数据结构课程设计,包含求字符串之间距离,后缀表达式计算,两个小游戏,二叉树结点染色问题,打印机任务队列,约瑟夫双向生死游戏,求解布尔表达式,谣言传播问题,分形问题,网络布线,数独游戏,中国邮路问题,...
  • 成绩 徐州工程学院 课 程 设 计 报 告 课 程 名 称 数据结构课程设计 专 业 计算机科学与技术 班 级 09计单 学 生 姓 名 黄 晨 学 号 * 设 计 题 目 宿舍查询管理系统 指 导 教 师 * 设计起止时间2011 年 6 月20日...
  • 这是我做的数据结构课程设计,使用的是c语言编译,该程序实现了较多的宿舍管理查询功能。供大家参考,谢谢。
  • 宿舍管理人员设计一个宿舍管理查询系统,程序采用交互工作方式;实现下列功能:建立合适的数据结构作为查找表并输入数据;数据分别按关键字姓名、学号、宿舍号进行排序;设计查询菜单,分别按关键字姓名、学号、...
  • 计算机与信息工程系 数据结构课程设计报告学号2014-2015 学年 第一学期数据结构课程设计报告题 目 宿舍管理查询系统的实现 专 业 班 级 姓 名 学 号 指导教师 成 绩 计算机与信息工程系2014 年 10 月 25 日计算机与...
  • 数据结构课程设计 宿舍管理系统C++语言编写
  • 数据结构宿舍管理查询系统的实现课程设计汇本.doc

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,033
精华内容 813
关键字:

宿舍管理系统数据结构课程设计

数据结构 订阅
友情链接: CPP.rar