图书信息管理系统（顺序表）

最新推荐文章于 2024-03-19 20:27:57 发布
最新推荐文章于 2024-03-19 20:27:57 发布
阅读量5.9k 收藏 118
点赞数 11
分类专栏： 作品 文章标签： c++ c语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JamesZhou13/article/details/120412011
版权

图书信息管理系统（顺序表）

任务需求

       读取给定的图书文件book.txt中的信息，完成一个图书信息管理系统，该系统的各个功能模块利用菜单选项进行选择，要求程序具有正确性、可读性（变量函数命名规范、核心语句添加注释）、健壮性（数据非法时能够进行相应处理）。

输出：读取book.txt中的文件信息并依次输出所有图书信息（书号、书名、价格）。

插入：根据指定的位置i（1≤i≤n+1）和给定的一本图书信息，将该图书插入到位置i，并将变化后的图书信息回写到book.txt。

删除：根据指定的位置i（1≤i≤n），删除该位置上的图书信息，并将变化后的图书信息回写到book.txt。

查找
       1、按位置进行查找：根据输入的位置i（1≤i≤n），查找位置i上的图书信息并输出；
       2、按书名进行查找：根据输入的书名，查找该图书的信息并输出（如果有多本，则全部输出）。

修改：将价格小于25元的图书价格提高20%，价格大于等于25元的图书价格提高10%，将修改后的图书信息写入文件book_newprice.txt中。

排序：按书的价格由低到高排序写入文件book_newsort.txt中。（必须包含冒泡排序，其他排序任选）

注意:book.txt的内容如下图所示

图书管理系统的采购表

代码

#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;

const int MAXSIZE = 1e5+7;	//最多数据元素个数 
const int MAXLEN = 107;	//字符串类型数据的最长长度
const int INF = 0x3f3f3f3f;	//整型的无穷大 

typedef struct{
	char no[MAXLEN];	//图书编号 
	char name[MAXLEN];	//图书名字 
	double price;	//图书价格 
}Book;

typedef struct{
	Book *elem;	//存储空间的基地址 
	int length;	//图书表中当前图书的个数 
}SqList;

void Init(SqList &L);	//初始化 
void ReadFromFile(SqList &L);	//读文件 
void WriteIntoFile(SqList &L, const char *file);	//写文件 
void IllegalInput(string menu);	//非法输入 

void ShowMainMenu();	//显示主菜单 

void ShowAll(SqList &L);	//显示所有图书信息 
void Insert(SqList &L);	//插入图书信息 
void Erase(SqList &L);	//删除图书信息 
void Modify(SqList &L);	//修改图书信息 
void Quit();	//退出 

void ShowSearchMenu();	//显示查找菜单 
void SearchByPosition(SqList &L);	//通过位置查找图书信息 
void SearchByName(SqList &L);	//通过书名查找图书信息 

void ShowSortMenu();	//显示排序菜单 
void InsertionSort(SqList &L);	//插入排序 
void ShellSort(SqList &L);	//希尔排序 
void SelectionSort(SqList &L);	//选择排序 
void HeapSort(SqList &L);	//堆排序 
void BubbleSort(SqList &L);	//冒泡排序
void QuickSort(SqList &L);	//快速排序 
void MergeSort(SqList &L);	//归并排序


int main(){
	
	ShowMainMenu();
	
	return 0;
}


//主菜单界面 
void ShowMainMenu(){
	system("cls");
	printf("*************************图书管理系统*************************\n");
	printf("显示所有图书信息---------------------------------------------1\n");
	printf("插入---------------------------------------------------------2\n");
	printf("删除---------------------------------------------------------3\n");
	printf("查找---------------------------------------------------------4\n");
	printf("修改---------------------------------------------------------5\n");
	printf("排序---------------------------------------------------------6\n"); 
	printf("退出---------------------------------------------------------7\n\n");
	printf("请输入想进入的二级菜单：");

	SqList L;
	Init(L);
	ReadFromFile(L);

	int op;
	scanf("%d", &op);
	switch(op){
		case 1:{	//输入1，显示所有书本 
			ShowAll(L);
			break;
		}
		case 2:{	//输入2，插入功能 
			Insert(L);
			break;
		}
		case 3:{	//输入3，删除功能 
			Erase(L);
			break;
		}
		case 4:{	//输入4，显示搜索界面 
			ShowSearchMenu();
			break;
		}
		case 5:{	//输入5，修改 
			Modify(L);
			break;
		} 
		case 6:{	//输入6，显示排序界面 
			ShowSortMenu();
			break;
		}
		case 7:{	//输入7，退出程序 
			Quit();
			break;
		}
		default:{	//非法输入 
			IllegalInput("main");
			break;
		}
	}
	delete [] L.elem;	//释放空间 
}


//查找界面
void ShowSearchMenu(){
	system("cls");
	printf("************************请选择查找方式************************\n");
	printf("按位置查找---------------------------------------------------1\n"); 
	printf("按书名查找---------------------------------------------------2\n");
	printf("返回一级菜单-------------------------------------------------3\n\n"); 
	printf("请输入您所选的排序方式：");

	SqList L;
	Init(L);
	ReadFromFile(L);
	
	int op;
	scanf("%d", &op);
	switch(op){
		case 1:{	//输入1，根据位置查找 
			SearchByPosition(L);
			break;
		}
		case 2:{	//输入2，根据名字查找 
			SearchByName(L); 
			break;
		}
		case 3:{	//输入3，返回主菜单 
			ShowMainMenu();
			break;
		}
		default:{	//非法输入 
			IllegalInput("search");
			break;
		}
	}
	delete [] L.elem;	//释放空间 
} 


//排序界面 
void ShowSortMenu(){
	system("cls");	//清屏 
	
	printf("************************请选择排序方式************************\n");
	printf("插入排序-----------------------------------------------------1\n"); 
	printf("希尔排序-----------------------------------------------------2\n");
	printf("选择排序-----------------------------------------------------3\n");
	printf("堆排序-------------------------------------------------------4\n"); 
	printf("冒泡排序-----------------------------------------------------5\n");
	printf("快速排序-----------------------------------------------------6\n");
	printf("归并排序-----------------------------------------------------7\n");
	printf("返回一级菜单-------------------------------------------------8\n\n"); 
	printf("请输入您所选的排序方式：");

	SqList L;
	Init(L);
	ReadFromFile(L);
	
	int op;
	scanf("%d", &op);
	switch(op){
		case 1:{	//输入1，执行插入排序 
			InsertionSort(L);
			break;
		}
		case 2:{	//输入2，执行希尔排序 
			ShellSort(L); 
			break;
		}
		case 3:{	//输入3，执行选择排序 
			SelectionSort(L);
			break;
		}
		case 4:{	//输入4，执行堆排序 
			HeapSort(L);
			break;
		}
		case 5:{	//输入5，执行冒泡排序 
			BubbleSort(L);
			break;
		}
		case 6:{	//输入6，执行快速排序 
			QuickSort(L);
			break;
		}
		case 7:{	//输入7，执行归并排序 
			MergeSort(L);
			break;
		}
		case 8:{	//输入8，返回主菜单 
			ShowMainMenu();
			break;
		}
		default:{	//非法输入 
			IllegalInput("sort");
			break;
		}
	}
	delete [] L.elem;	//释放空间 
}


//初始化 
void Init(SqList &L){
	L.elem = new Book [MAXSIZE];	//分配新空间 
	if (! L.elem){ 
		exit(-2);	//存储分配失败，则退出
	}
	L.length = 0;
}


//读文件 
void ReadFromFile(SqList &L){
	ifstream rd("book.txt");	//新建一个文件输出流指针，打开文件book.txt 

	if (! rd){
		exit(0);	//如果打开失败，异常结束 
	}
	
	char title[MAXLEN];
	char noTitle[MAXLEN], nameTitle[MAXLEN], priceTitle[MAXLEN]; 
	rd >> title;	//读取标题 
	rd >> noTitle >> nameTitle >> priceTitle;	//读取标题 
	
	Book book;
	while (rd >> book.no >> book.name >> book.price){
		L.elem[L.length] = book;	//将新的图书放在第L.length位置上 
		L.length++;	//表长加1 
	}
	
	rd.close();	//关闭文件流指针 
}


//写文件 
void WriteIntoFile(SqList &L, const char *file){
	ofstream w(file);	//新建一个文件输入流指针，打开文件file 
	
	if (! w){
		exit(0);	//如果打开失败，异常结束 
	}
	
	w << "北京林业大学图书馆计算机类图书采购列表" << endl;
	w << "ISBN	                  书名	                定价" << endl;
	
	for (int i = 0; i < L.length; i++){
		w << L.elem[i].no << " " << L.elem[i].name << " " << L.elem[i].price << endl;	//将图书信息写入文件中 
	}
	
	w.close();	//关闭文件流指针 
}


//非法输入
void IllegalInput(string menu){
	printf("输入失败，请重新输入！");
	system("pause");	//需要输入一个字符程序才能执行 
	getchar();	//读取字符 
	
	//根据menu分别进入不同的菜单 
	if (menu == "main"){
		ShowMainMenu();
	}else if (menu == "search"){
		ShowSearchMenu();
	}else if (menu == "sort"){
		ShowSortMenu();
	}
} 


//显示所有图书信息
void ShowAll(SqList &L){
	system("cls");	//清屏 
	
	if (L.length == 0){	//表长为0，没有图书 
		printf("暂无图书！"); 
	}else{ 
		printf("所有的图书信息:\n\n");
		printf("    ISBN                      书名                          定价\n");
		printf("=================================================================\n");
		for (int i = 0; i < L.length; i++){
			printf("%-20s%-40s%.2f\n", L.elem[i].no, L.elem[i].name, L.elem[i].price);	//按顺序输出所有的图书信息
		}
		printf("=================================================================\n\n");
	}
	
	//按任意键返回主菜单 
	system("pause");
	ShowMainMenu();
}


//插入图书信息
void Insert(SqList &L){
	system("cls");	//清屏 
	
	int pos;
	Book book;
	
	printf("请输入要插入的位置(1~%d)：", L.length+1);
	scanf("%d", &pos);
	
	//若想要插入的位置不在区间[1,L.length+1]，则插入的位置不合法，需要重新输入位置
	while (pos < 1 || pos > L.length+1){
		printf("输入不正确,请重新输入：");
		scanf("%d", &pos);
	}
	
	//依次输入图书编号、书名、价格 
	printf("请输入图书编号：");
	scanf("%s", book.no);
	printf("请输入图书书名：");
	scanf("%s", book.name);
	printf("请输入图书价格：");
	scanf("%lf", &book.price);
	
	for (int i = L.length-1; i >= pos-1; i--){
		L.elem[i+1] = L.elem[i];	//区间[pos,L.length-1]中的每个图书信息都要向后移动
	}
	L.elem[pos-1] = book;	//将新的图书信息放入pos-1的位置上 
	L.length++;	//表长加1 
	
	WriteIntoFile(L, "book.txt");	//将插入后的所有图书信息重新写入到book.txt中 
	printf("\n\n插入成功!\n");
	
	//按任意键返回主菜单 
	system("pause");
	ShowMainMenu();
}


//删除图书信息 
void Erase(SqList &L){
	system("cls");	//清屏 
	
	int pos;
	Book book;
	
	printf("请输入要删除的位置(1~%d)：", L.length);
	scanf("%d", &pos);
	
	//若想要删除的位置不在区间[1,L.length]，则删除的位置不合法，需要重新输入位置
	while (pos < 1 || pos > L.length){
		printf("输入不正确,请重新输入：");
		scanf("%d", &pos);
	}
	
	for (int i = pos; i <= L.length-1; i++){
		L.elem[i-1] = L.elem[i];	//区间[pos+1,L.length-1]中的每个图书信息都要向前移动
	}
	L.length--;	//表长减1 
	
	WriteIntoFile(L, "book.txt");	//将删除后的所有图书信息重新写入到book.txt中 
	printf("\n\n删除成功!\n");
	
	//按任意键返回主菜单 
	system("pause");
	ShowMainMenu();
}


//修改图书信息 
void Modify(SqList &L){
	system("cls");	//清屏 
	
	//依次遍历所有图书，按要求提高价格 
	for (int i = 0; i < L.length; i++){
		if (L.elem[i].price < 25){
			L.elem[i].price *= 1.2;
		}else{
			L.elem[i].price *= 1.1;
		}
	}
	
	//显示所有修改后的图书信息 
	printf("修改后所有的图书信息:\n\n");
	printf("    ISBN                      书名                          定价\n");
	printf("=================================================================\n");
	for (int i = 0; i < L.length; i++){
		printf("%-20s%-40s%.2f\n", L.elem[i].no, L.elem[i].name, L.elem[i].price);
	}
	printf("=================================================================\n");
	printf("因某些不可抗力，图书价格小于25元的书价格提高20%，图书价格大于等于25元的书价格提高10%。敬请谅解！\n\n");
	
	WriteIntoFile(L, "book.txt");	//将修改后的所有图书信息重新写入到book.txt中 
	WriteIntoFile(L, "book_newprice.txt");	//将修改后的所有图书信息写入到book_newprice.txt中 
	
	//按任意键返回主菜单 
	system("pause");
	ShowMainMenu();
}


//退出 
void Quit(){
	system("cls");	//清屏 
	
	printf("确定要退出？y/n:");
	char op;
	scanf("%c", &op);
	if (op == 'n' || op == 'N'){
		ShowMainMenu();
	}else if (op != 'y' && op != 'Y'){
		Quit();
	}
}



//下面为2种查找： 
 
//按位置查找图书信息
void SearchByPosition(SqList &L){
	system("cls");	//清屏 
	
	int pos;
	printf("请输入要查找的图书位置(1~%d)：", L.length);
	scanf("%d", &pos);
	
	//若想要查找的位置不在区间[1,L.length]，则查找的位置不合法，需要重新输入位置
	while (pos < 1 || pos > L.length){
		printf("输入不正确,请重新输入：");
		scanf("%d", &pos);
	}
	
	printf("\n\n位于%d位的图书信息:\n\n", pos);
	printf("    ISBN                      书名                          定价\n");
	printf("=================================================================\n");
	printf("%-20s%-40s%.2f\n", L.elem[pos-1].no, L.elem[pos-1].name, L.elem[pos-1].price);	//因为指针的下标从0开始，所以要输出pos-1位置的图书信息 
	printf("=================================================================\n\n");
	
	//按任意键返回主菜单 
	system("pause");
	ShowSearchMenu();
}

 
//按书名查找图书信息
void SearchByName(SqList &L){
	system("cls");
	
	char name[MAXLEN];
	printf("请输入想要查找的书名:");
	scanf("%s", name);
	
	SqList tmp;	//建立一个新的线性表，用于存储书名为所找书名的图书信息 
	Init(tmp);
	
	for (int i = 0; i < L.length; i++){	//依次遍历所有图书 
		if (strcmp(L.elem[i].name, name) == 0){	//找到书名为name的图书 
			tmp.elem[tmp.length] = L.elem[i];	//将这本书的信息放入顺序表tmp的tmp.length的位置 
			tmp.length++;	//tmp表长加1 
		}
	}
	
	if (tmp.length == 0){	//找不到书名为name的书，tmp的表长为0 
		printf("\n\n对不起,查无此书!\n\n");
	}else{
		printf("\n\n所有书名为%s图书信息:\n\n", name);
		printf("    ISBN                      书名                          定价\n");
		printf("=================================================================\n");
		for (int i = 0; i < tmp.length; i++){
			printf("%-20s%-40s%.2f\n", tmp.elem[i].no, tmp.elem[i].name, tmp.elem[i].price);	//依次输出tmp的图书信息 
		}
		printf("=================================================================\n\n");
	}
	delete tmp.elem;	//释放tmp的空间 
	
	//按任意键返回查找菜单页面 
	system("pause");
	ShowSearchMenu();
}




//下面的为各种排序： 

//插排 
//O(N*N)，稳定 
void InsertionSort(SqList &L){
	system("cls");
	
	//插入排序实现过程： 
	for (int i = 1; i < L.length; i++){	//i是当前数
		for (int j = i-1 ; j >= 0; j--){	//j是从i-1开始向前移动，每次与i图书比较
			if (L.elem[i].price < L.elem[j].price){	//若 i图书的价格 < j图书的价格，说明i图书当前是要插入到j图书之前
				swap(L.elem[i], L.elem[j]);	//交换i图书和j图书的位置 
				i = j-1;	//互换后i也要向前移动一位
			}else{
				break;	//直到i图书的价格比j图书大，因为前面从小到大已经排好序，所以没有必要继续向前判断了					
			}
		}
	}
	
	printf("经过插入排序后,所有的图书信息:\n\n");
	printf("    ISBN                      书名                          定价\n");
	printf("=================================================================\n");
	for (int i = 0; i < L.length; i++){
		printf("%-20s%-40s%.2f\n", L.elem[i].no, L.elem[i].name, L.elem[i].price);	//依次输出排序后的图书信息 
	}
	printf("=================================================================\n\n");
	
	WriteIntoFile(L, "book_newsort.txt");	//将修改后的所有图书信息写入到book_newsort.txt中 
	
	//按任意键返回排序菜单页面 
	system("pause");
	ShowSortMenu();
}


//希尔排序 
//O(N*sqrt(N))，不稳定 
void ShellSort(SqList &L){
	system("cls");
	
	int h = 1;
	while (h < L.length / 3){
		h = 3 * h + 1;	//分段 
	}
	while (h >= 1){
		//将数组变为h有序，两个for循环组成插入排序
		for (int i = h; i < L.length; i++){
			for (int j = i; j >= h && L.elem[j].price < L.elem[j-h].price; j -= h){	//相隔h的元素进行比较，从后往前迭代
				swap(L.elem[j], L.elem[j-h]);	//交换 j图书 和  j+h图书 
			}
		}
		h = h / 3;
	}
	
	printf("经过希尔排序后,所有的图书信息:\n\n");
	printf("    ISBN                      书名                          定价\n");
	printf("=================================================================\n");
	for (int i = 0; i < L.length; i++){
		printf("%-20s%-40s%.2f\n", L.elem[i].no, L.elem[i].name, L.elem[i].price);	//依次输出排序后的图书信息 
	}
	printf("=================================================================\n\n");
	
	WriteIntoFile(L, "book_newsort.txt");	//将修改后的所有图书信息写入到book_newsort.txt中 
	
	//按任意键返回排序菜单页面 
	system("pause");
	ShowSortMenu();
}


//选择排序 
//O(N*N)，不稳定 
void SelectionSort(SqList &L){
	system("cls");
	
	//选择排序实现过程： 
	for (int i = 0; i < L.length; i++){
		int idx = i;	//记录这趟排序价格最小的图书 
		for (int j = i+1; j < L.length; j++){
			if (L.elem[idx].price > L.elem[j].price){	//如果价格比idx图书的价格还小 
				idx = j;	//idx指向这趟排序价格最小的图书
			}
		}
		swap(L.elem[idx], L.elem[i]);	//交换idx图书和i图书 
	}
	
	printf("经过选择排序后,所有的图书信息:\n\n");
	printf("    ISBN                      书名                          定价\n");
	printf("=================================================================\n");
	for (int i = 0; i < L.length; i++){
		printf("%-20s%-40s%.2f\n", L.elem[i].no, L.elem[i].name, L.elem[i].price);	//依次输出排序后的图书信息 
	}
	printf("=================================================================\n\n");
	
	WriteIntoFile(L, "book_newsort.txt");	//将修改后的所有图书信息写入到book_newsort.txt中 
	
	//按任意键返回排序菜单页面 
	system("pause");
	ShowSortMenu();
}


//堆排
//O(N*log N)，不稳定 
void Adjust(SqList &L, int i, int n){
	int parent = i;	//父节点 
	int child = 2 * i + 1;	//左子节点 
	while (child < n){
		if (child +1 < n && L.elem[child].price < L.elem[child+1].price){
			child++; 	//变成右子节点 
		}
		if (L.elem[parent].price < L.elem[child].price){
			swap(L.elem[child], L.elem[parent]); 	//交换父子节点 
			parent = child;	//子节点就变为父节点 
		}
		child = child * 2 + 1;
	}
}
void HSort(SqList &L){	//建立小根堆 
	for (int i = L.length/2-1; i >= 0; i--){
		Adjust(L, i, L.length);
	}
	for (int i = L.length-1; i > 0; i--){
		swap(L.elem[i], L.elem[0]);	//将堆顶记录与当前未排序的序列[0, i-1]中的最后一个元素交换 
		Adjust(L, 0, i);	//将[0,i]调整为小根堆 
	}
}
void HeapSort(SqList &L){
	system("cls");
	
	HSort(L);	//堆排序 
	
	
	printf("经过堆排序后,所有的图书信息:\n\n");
	printf("    ISBN                      书名                          定价\n");
	printf("=================================================================\n");
	for (int i = 0; i < L.length; i++){
		printf("%-20s%-40s%.2f\n", L.elem[i].no, L.elem[i].name, L.elem[i].price);	//依次输出排序后的图书信息 
	}
	printf("=================================================================\n\n");
	
	WriteIntoFile(L, "book_newsort.txt");	//将修改后的所有图书信息写入到book_newsort.txt中 
	
	//按任意键返回排序菜单页面 
	system("pause");
	ShowSortMenu();
}
 

//冒泡 
//O(N*N)，稳定 
void BubbleSort(SqList &L){
	system("cls");	//清屏 
	
	//冒泡排序实现过程： 
	for (int i = 0; i < L.length-1; i++){	//执行L.length-1遍，每遍将无序中的最大的那个沉底 
		for (int j = 0; j < L.length-i-1; j++){	//因为后面i个都已经有序，只需排前面L.length-i-1个 
			if (L.elem[j].price > L.elem[j+1].price){	//若j图书的价格 > j+1图书的价格
				swap(L.elem[j], L.elem[j+1]);	//j和j+1的图书交换位置
			}
		}
	}
	
	printf("经过冒泡排序后,所有的图书信息:\n\n");
	printf("    ISBN                      书名                          定价\n");
	printf("=================================================================\n");
	for (int i = 0; i < L.length; i++){
		printf("%-20s%-40s%.2f\n", L.elem[i].no, L.elem[i].name, L.elem[i].price);	//依次输出排序后的图书信息 
	}
	printf("=================================================================\n\n");
	
	WriteIntoFile(L, "book_newsort.txt");	//将修改后的所有图书信息写入到book_newsort.txt中 
	
	//按任意键返回排序菜单页面 
	system("pause");
	ShowSortMenu();
}


//快排
//O(N*log N)，不稳定 
void QSort(SqList &L, int l, int r){	//对区间[l,r]的快速排序 
	if (l >= r){
		return ;	//当左 >= 右时，返回 
	}
	Book x = L.elem[(l+r)>>1];	//哨兵 
	int i = l-1, j = r+1;
	while (i < j){
		//把比哨兵小的左移，比哨兵大的右移 
		do{
			i++;
		}while (L.elem[i].price < x.price);
		do{
			j--;
		}while (L.elem[j].price > x.price); 
		if (i < j){
			swap(L.elem[i], L.elem[j]); 
		}
	}
	QSort(L, l, j);	//对左半边再次快速排序 
	QSort(L, j+1, r);	//对右半边再次快速排序 
}
void QuickSort(SqList &L){
	system("cls");
	
	QSort(L, 0, L.length-1);
	
	printf("经过快速排序后,所有的图书信息:\n\n");
	printf("    ISBN                      书名                          定价\n");
	printf("=================================================================\n");
	for (int i = 0; i < L.length; i++){
		printf("%-20s%-40s%.2f\n", L.elem[i].no, L.elem[i].name, L.elem[i].price);	//依次输出排序后的图书信息 
	}
	printf("=================================================================\n\n");
	
	WriteIntoFile(L, "book_newsort.txt");	//将修改后的所有图书信息写入到book_newsort.txt中 
	
	//按任意键返回排序菜单页面 
	system("pause");
	ShowSortMenu();
}


//归并排序 
//O(N*log N)，不稳定 
void Merge(SqList &L, int l, int r){	//合并[l,r] 
	int mid = (l + r) >> 1;
	int n1 = mid - l + 1;
	int n2 = r - mid;
	Book *left = new Book[n1+1];	//左半部分 
	Book *right = new Book[n2+1];	//右半部分 
	left[n1].price = INF;	//定义为无穷大
	right[n2].price = INF;	//定义为无穷大
	int tmp = l;
	for (int i = 0; i < n1; i++){
		left[i] = L.elem[tmp];	//将L.elem左半部分放入left中 
		tmp++;
	}
	tmp = mid + 1;
	for (int i = 0; i < n2; i++){
		right[i] = L.elem[tmp];	//将L.elem右半部分放入right中
		tmp++;
	}
	for (int i = 0, j = 0, k = l; k <= r; k++){
		if (left[i].price <= right[j].price){	//根据左右大小依次放入L.elem中 
			L.elem[k] = left[i];
			i++;
		}else{
			L.elem[k] = right[j];
			j++;
		}
	}
	delete [] left;	//释放空间 
	delete [] right;	//释放空间 
}
void MSort(SqList &L, int l, int r){
	if (l >= r){
		return ;	//当 左 >= 右 时，返回 
	}
	int mid = (l + r) >> 1;
	MSort(L, l, mid);	//对左半边归并排序 
	MSort(L, mid+1, r);	//对右半边归并排序 
	Merge(L, l, r);	//将左右半边合并 
}
void MergeSort(SqList &L){
	system("cls");
	
	MSort(L, 0, L.length-1);
	
	
	printf("经过归并排序后,所有的图书信息:\n\n");
	printf("    ISBN                      书名                          定价\n");
	printf("=================================================================\n");
	for (int i = 0; i < L.length; i++){
		printf("%-20s%-40s%.2f\n", L.elem[i].no, L.elem[i].name, L.elem[i].price);	//依次输出排序后的图书信息 
	}
	printf("=================================================================\n\n");
	
	WriteIntoFile(L, "book_newsort.txt");	//将修改后的所有图书信息写入到book_newsort.txt中 
	
	//按任意键返回排序菜单页面 
	system("pause");
	ShowSortMenu();
}
Chosen_One_13
关注
  • 11
    点赞
  • 踩
  • 118
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
基于顺序表的图书管理系统，文章附带的资源
04-06
基于顺序表的图书管理系统，文章附带的资源
基于C语言的顺序表实现图书管理系统
01-06
1.动态内存管理 2.C语言编写 3.超级人性化，欢迎大家下载查询
数据结构使用顺序表实现图书信息管理系统的代码实现(c语言)
最新发布
2403_83147124的博客
03-19 391
对顺序表进行初始化，参数的传递要考虑到对能够对结构体数据的传入，申请1000个空间内存，判断内存是否申请成功，不成功就退出程序。对插入位置进行判断是否合理，当内存空间满的时候对空间进行扩充。先对删除对象的位置进行判断，再将删除位置后面的值向前传递。因为顺序表是随机存取，可以用指针变量接受数据。给length和capacity分别赋值。通过循环对数据进行输出打印。
顺序表实现的图书管理
06-19
定义图书类型结构，定义顺序表；完成功能：初始化构建空表、插入新记录到第i个位置、删除表中第i个记录、按图书名称进行查找、按作者进行查找、按价格区间进行查找。
顺序表实现图书信息管理系统
qq_62175345的博客
04-13 4210
设计一个图书信息管理系统，每本图书包含ISBN号、书名、定价信息， 要求实现取值、查找、插入、删除等功能 #include <cstring> #include <iostream> #include <stdlib.h> #define ok 1 #define error 0 #define overflow -2 #define MaxSize 100 using namespace std; typedef int status; //定义 t..
数据结构课程设计图书信息管理系统报告(顺序表)（模板）
09-19
使用顺序表完成的数据结构课设报告 随着计算机的广泛应用，其逐步成为现代化的标志。图书馆在正常运行过程中总是面对大量的读者信息，书籍信息以及两者相互作用产生的借书信息、还书信息。因此需要对读者资源、书籍资源、借书信息、还书信息进行管理，及时了解各个环节中信息的变更，要对因此而产生的单据进行及时的处理，为了提高图书馆或者企业内部对图书存销的自动化的管理，能够更快速的满足读者的要求，提高各种工作的效率，现对其设计相应的系统，以达到上述的目的。
图书管理系统（顺序表实现）
Doraemon021212的博客
10-10 9136
图书信息表包括以下10项常用的基本操作:图书信息表的创建和输出、排序、修改、逆序存储、最贵图书的查找、最爱图书的查找、最佳位置图书的查找、新图书的入库、旧图书的出库、图书去重。 代码： #include<iostream> #include<iomanip> #include<string> using namespace std; //函数结果状态代码 #define OK 1 #define ERROR 0 #define OVERFLOW -2 //Statu
基于顺序表的图书管理系统(C语言)
weixin_55797565的博客
03-03 9202
Visual Studio编译环境 功能： 0、退出。 1、基于顺序存储结构的图书信息表的创建和输出。 2、基于顺序存储结构的图书信息表的新图书的入库。 3、基于顺序存储结构的图书信息表的旧图书的出库。 4、基于顺序存储结构的图书信息表按书号查找。 5、基于顺序存储结构的图书信息表按价格区间查找。 6、基于顺序存储结构的按图书价格升序排序...
基于线性表的图书管理系统 源代码 顺序表&链表
05-31
基于线性表的图书管理系统，《数据结构（C语言版 第2版）》严蔚敏 实验一
图书信息管理系统（C语言）（结构体数组）
06-29
1.软件：Dev-C++ 2.测试页面及结构体信息见我专栏《资源》下的《C语言系统资源测试》 3.代码一64行，功能有输入、排序、浏览 4.代码排版有序，注释多，易于新手下载学习 ...6.采用结构体数组（顺序表）实现
基于顺序表的图书管理系统
qq_43575301的博客
10-07 5551
#include #include #include #include <string.h> #define MAXSIZE 100 using namespace std; char s0[20],s1[20],s2[20],s3[20],s4[30]; int num; typedef struct //图书类型Book定义 { char no[20]; //书号 cha...
图书管理信息系统
05-14
很好的模板，适合初学者
用顺序表实现图书信息管理（增删改查）---c语言版
sdmdnf的博客
04-10 2931
用顺序表实现图书信息管理（增删改查）---c语言版
顺序表：实现图书管理系统
m0_63040701的博客
03-27 1564
Book;Book* elem;int length;}SqList;
数据结构——图书信息管理系统的顺序表实现
热门推荐
辞树
05-04 1万+
大部分代码来自严蔚敏老师的《数据结构》教材，但对于书上的伪代码，有编译运行不了的地方，我进行了修改，使得程序可以正常运行，功能正常使用。 代码利用顺序表制作了一个图书信息管理系统，可以进行增、删、查、看等功能。 初成代码，如果有bug， 还望指出。 #include <bits/stdc++.h> using namespace std; #define OK true...
数据结构/C语言_线性表之顺序表_图书信息管理系统
fmxs
10-14 4330
最近在看严蔚敏的《数据结构C语言版|第2版》，看完了线性表，写了用顺序表实现的图书信息管理系统。 数据结构（C语言版） 第二章 线性表 知识梳理+作业习题详解 经测试可以成功运行。但是输入小数就会出bug。 操作系统：Windows 10 编译器：Visual Studio 2022 preview 个人撰写，仅供参考。 然后说一下代码实现的主要功能，一共是6个功能。输入数字执行对应功能。 1 - 添加图书 2 - 查找图书 3 - 删除图书 4 - 打印图书信息 （方便查看运行结果） 5 - 插入图
数据结构——基于顺序表管理图书信息
weixin_52595313的博客
10-13 2390
#include <iostream> #include<iomanip> #include<string> using namespace std; #define MAXSIZE 10000 typedef struct { string no; string name; double price; }Book; typedef struct { Book *elem; int num; }SqList; //价格处理 void Aver(SqList.
图书信息管理系统(数据结构顺序表,c语言版）
Linux518的博客
07-18 1万+
严蔚敏数据结构(C语言版)第2版，数据结构顺序表，课本第21页图书信息管理系统实验。
利用顺序表建立简单图书管理系统
m0_64160559的博客
07-05 3239
采用线性表中的顺序储存方式，实现对书籍的增加，删除，查找，展示等基础功能。
顺序表构建图书管理系统
10-07
顺序表图书管理系统可以通过定义图书类型结构和顺序表来实现。首先，你可以使用定义好的图书类型结构来表示每本书的信息，包括图书名称、作者和价格等。然后，你可以使用顺序表来存储这些图书信息，使得可以方便地进行插入、删除和查找等操作。 为了实现顺序表图书管理系统，你可以按照以下步骤进行操作： 1. 初始化构建空表：创建一个空的顺序表，用于存储图书信息。 2. 插入新记录到第i个位置：根据用户输入的图书信息，将新的记录插入到指定位置的顺序表中。可以通过移动其他记录的位置，将新的记录插入到指定位置。 3. 删除表中第i个记录：根据用户输入的位置，从顺序表中删除指定位置的记录。可以通过移动其他记录的位置，将待删除的记录删除。 4. 按图书名称进行查找：根据用户输入的图书名称，在顺序表中查找匹配的记录。可以逐个比较顺序表中每条记录的图书名称，找到匹配的记录并输出。 5. 按作者进行查找：根据用户输入的作者，在顺序表中查找匹配的记录。可以逐个比较顺序表中每条记录的作者，找到匹配的记录并输出。 6. 按价格区间进行查找：根据用户输入的价格区间，在顺序表中查找匹配的记录。可以逐个比较顺序表中每条记录的价格，找到符合价格区间的记录并输出。 以上是顺序表图书管理系统的基本构建和功能。通过定义图书类型结构和使用顺序表，可以实现对图书的插入、删除和查找等操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Chosen_One_13

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

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

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

打赏作者

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

抵扣说明：

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

余额充值