题目：
代码：
正解：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MaxSize 10 //定义顺序表最大长度
static int result; //字符串比较结果
static int i; //循环初始值
static bool flag; //记录结果为真/假
static int ListLen;//记录单链表长度,全局要用,一开始长度为0
//品牌型号
typedef struct
{
char model[10];
}BModel;
//品牌信息
typedef struct
{
//品牌编号
char BH[5];
//品牌名
char BN[15];
//该品牌被查找的次数
unsigned int num;
}Goods;
//存储文教文化用品(商品)的顺序表
typedef struct
{
//品牌
Goods *g;
//品牌型号数组
BModel bm[MaxSize];
//顺序表当前长度,多一个型号则长度加一
int length;
}BrandSqList;
//文教文化用品的品牌形成的单链表
typedef struct LNode
{
//指向下一个品牌的指针,类型要用struct LNode而不是LNode,原因和下一行同理
struct LNode *next;//此时不能用*LinkList,因为此时还没有定义*LinkList,这个是结构体定义完才有的
//文教文化用品的顺序表,一个结点是一个品牌顺序表
BrandSqList BList;
}LNode,*LinkList;//前者强调结点，后者强调单链表(两者等价)
//初始化顺序表
bool InitBrandSqList(BrandSqList &inBList) //记得加&,因为初始化,值改变了
{
//1.为顺序表分配数组空间
inBList.g = new Goods[MaxSize]; //new的是Goods,不是BrandSqList,因为分配给商品
//inBList.g = (Goods *)malloc(sizeof(Goods));
//2.判断
if( inBList.g )
{
//分配成功
inBList.length = 0; //一开始长度为0
return true;
}
else
{
return false;//内存不足,分配失败
}
}
//初始化单链表(带头结点)
bool InitLinkList(LinkList &L) //注意加&
{
//1.分配头结点
L = (LNode *)malloc(sizeof(LNode));
//2.判断
if(L==NULL)
{
return false; //内存不足,分配失败
}
else
{
//分配成功
L->next = NULL; //头结点之后暂时还没有结点
return true;
}
}
/*
//求单链表的长度
int funListLen(LinkList &L)
{
L = L->next;//跳过头结点
while(L!=NULL)
{
ListLen++; //先长度加一
L = L->next; //再跳到下一个结点,上下两句不能换,因为此时是跳过了头结点
}
return ListLen;
}
*/
//判断最终结果的函数
void final(bool flag)
{
if(flag)
{
printf("成功 \n");
}
else
{
printf("失败 \n");
}
}
//顺序表内容赋值
void inputInBList(BrandSqList &inBList,int i) //需要&,因为顺序表值变了
{
printf("第%d个品牌: \n",i);
//1.品牌编号
printf("请输入品牌编号:");
scanf("%s",inBList.g->BH);
//2.品牌名
printf("请输入品牌名:");
scanf("%s",inBList.g->BN); //直接给字符数组录入即可
//3.查找频次一开始为0
inBList.g->num=0;
}
/*------------------------------青格勒-------------------------------------*/
//添加品牌到单链表:在p结点之后插入下一个结点(顺序表)->该添加属于指定结点添加
/* L每次是单链表的第一个元素即头结点,
BrandSqList inBList是要插入的元素 */
//i为位序,如第一次插在第一个位置,再比如i为2代表插在第二个位置上,就要找到第一个位置插在他的后面
bool InsertNextNode(LinkList &L,BrandSqList inBList,int i) //inBList不用加&，因为只是添加到单链表,值没变
{
//1.判断位序是否合法
if(i<1)
{
return false; //位序必须是正整数
}
//此时位序合法
//2.建立指针p指向当前扫描到的结点
LNode *p;
//3.设置变量记录p扫描到第几个结点
int j=0;//一开始是头结点即为0
//4.L指向头结点,头结点是第0个元素(不存数据)
p=L;
//5.循环找到第i-1个结点
while(p!=NULL && j<i-1)
{
p = p->next;
j++;
}
//6.判断p
if(p==NULL)
{
return false; //说明i不合法
}
//7.给新结点申请内存空间
LNode *s = (LNode *)malloc(sizeof(LNode));
//8.判断s
if(s==NULL)
{
return false; //内存不足,分配失败
}
//9.把要添加的数据赋给空间s
s->BList = inBList;
//10.修改指针
s->next = p->next;
p->next = s;
//11.结果
return true;
}
//插入品牌的函数(要输入顺序表内容)
bool InsertBrand(LinkList &L,int i) //要加&,因为单链表发生了改变
{
//1.创建顺序表-->不能只在主函数中开头创建一个,因为单链表里不止一个顺序表
BrandSqList inBList; //顺序表创建后要全局用
//2.初始化顺序表
flag=InitBrandSqList(inBList);
if(flag)
{
printf("顺序表初始化成功 \n");
}
else
{
printf("顺序表初始化失败 \n");
return false;
}
//3.顺序表内容赋值
inputInBList(inBList,i); //i也是编号
//4.插入品牌
flag=InsertNextNode(L,inBList,i);
if(flag)
{
printf("*该品牌添加成功* \n");
}
else
{
printf("该品牌添加失败 \n");
return false;
}
//5.此时插入成功,单链表长度加一
ListLen++;
//6.结果
return true;
}
//删除单链表里的品牌-->对于最后一个结点有限制
/*需要单链表,要删除的品牌*/
bool DeleteNode(LinkList &L,char outBListBN[15])
{
//1.遍历单链表的品牌,找是否有与要删除的品牌所匹配的
LNode *p = L->next; //跳过头结点,用LNode结点记录,这样稳妥,不容易出bug
while(p!=NULL)
{
result = strcmp(p->BList.g->BN,outBListBN);
if(result==0)
{
break; //找到了,跳出循环,此时L不为NULL
}
else
{
p = p->next; //没找到,后移
}
}
//2.判断L结点
if(p==NULL) return false; //此时代表没找到
//3.此时找到了,开始删除对应的结点L即修改指针
//3.1.令q指向*L的后继结点
LNode *q = p->next;
//3.2.和后继结点交换数据域
p->BList = q->BList;
//3.3.将*q结点从链中断开
p->next = q->next;
//3.4.释放后继结点的存储空间
free(q);
//4.单链表长度减一
ListLen--;
//5.结果
return true;
}
/*------------------------------青格勒-------------------------------------*/
/*------------------------------王豪杰-------------------------------------*/
//查找品牌
/*需要单链表,要查找的品牌*/
LinkList LocateElem(LinkList &L,char findBListBN[15])
{
/*
//1.跳过没数据的头结点
L = L->next;//这行改变传入的 L 指针，这可能会导致调用者在后续操作出现问题。*/
// 1.跳过没数据的头结点,定义q来记录结点
LNode *q = L->next;
//2.遍历单链表开始查找
while( q!=NULL)
{
result=strcmp(q->BList.g->BN,findBListBN );//判断品牌名是否匹配
if(result==0)
{
break; // 找到了,跳出循环
}
q = q->next;
}
//3.判断
if(q==NULL) //要么到了最后一个结点都没找到,要么全都没有
{
printf("品牌%s不存在 \n",findBListBN);
return NULL; //代表此时没找到,返回NULL,别写返回q,有问题
}
//此时找到了,查找频次域加一
printf("品牌%s存在 \n",findBListBN);
q->BList.g->num++;
return q;
}
//改变商品的内容
/* 需要要改变的品牌,单链表 */
LinkList changeGoods(LinkList &L,char inBListBN[15])
{
//ListLen=funListLen(L); //求出单链表长度
//1.查找要改变的品牌是否存在
LNode *q=LocateElem(L,inBListBN);
if(q==NULL)
{
//此时不存在
printf("要改变的品牌不存在 \n");
return L;
}
//此时存在
//2.改变品牌内容,重新赋值
inputInBList(q->BList,ListLen);
//3.结果
return L;
}
/*------------------------------王豪杰-------------------------------------*/
/*------------------------------杨志-------------------------------------*/
//显示所有品牌(头结点没数据,但不为NULL->最终不能打印头结点)
void displayAllBrands(LinkList &L)
{
//1.记录所在结点
LNode *q = L;
//2.遍历单链表开始显示
while(q!=NULL)
{
//3.第一次时跳过没数据的头结点
q = q->next;
//3.判断结点是否为空
if (q == NULL)
{
printf("显示完毕，没有品牌信息可以显示。\n");
return;
}
printf("品牌编号:%s,品牌名:%s,查找频次为:%d \n",
q->BList.g->BH , q->BList.g->BN , q->BList.g->num );
}
}
//查找最后一名品牌
void findLastBrand(LinkList &L)
{
if(L!=NULL)
{
while(L->next != NULL)
{
L = L->next;
}
printf("最后一名品牌编号:%s,品牌名:%s,查找频次为:%d \n",
L->BList.g->BH , L->BList.g->BN , L->BList.g->num );
}
}
/*------------------------------杨志-------------------------------------*/
/*------------------------------青格勒-------------------------------------*/
//记录品牌频次的函数
/*需要单链表,当前单链表的长度,新的单链表*/
LinkList funNewLinkList(LinkList &L)
{
LNode *q = L; //记录头结点
LNode *p = L; //记录头结点
LNode *Lp = L->next;//跳过头结点
//1.定义旧的单链表的频次数组
int arrListLen[ListLen];
//2.把单链表里的品牌被查找的次数存入频次数组
for(i=0;i<ListLen;i++)
{
arrListLen[i]=Lp->BList.g->num;//赋值频次
Lp = Lp->next; //下一个结点
}
//3.把频次数组按照降序的顺序排序(冒泡排序)
//3.1.外循环:循环轮数,长度减一,因为最后一个直接成型
for(int j=0 ; j<ListLen-1 ; j++)
{
//3.2.内循环:相邻两个数依次比较
for(i=0 ; i<ListLen-1-j ; i++ )
{
//3.3.判断
if(arrListLen[i]<arrListLen[i+1])
{
int temp=arrListLen[i];
arrListLen[i]=arrListLen[i+1];
arrListLen[i+1]=temp;
}
}
}
//4.根据降序后的频次改变结点位置(要按照频次降序排序)
//4.1.遍历频次数组(此时已经降序排序)取出元素,元素就是品牌查找频次
/*这里i+1可以作为结点位置,从1开始好一些,i一开始为0加一即为1
因为频次数组的索引,如第一个索引即1对应的频次,对应的品牌,就是要插在单链表第一个结点的品牌,*/
for(i=0;i<ListLen;i++)
{
/*一定能找到对应的频次,因为数组里的元素就是在旧链表的元素的频次取的,只是换了个位置
先记录对应频次的品牌,
然后删除掉(单链表长度减一),再添加到单链表对应位置(单链表长度加一)
->单链表长度相当于没变*/
//4.2.每次把p弄为头结点,因为要遍历单链表所有内容去找
p=q; //p为头结点
LNode *prev = NULL; // 记录前一个结点
LNode *current = p->next; // 当前结点
//4.3.遍历旧链表找出与此次循环中频次相同的元素
while (current != NULL)
{
if (arrListLen[i] == current->BList.g->num)// 匹配上了
{
// 4.2. 记录该品牌
BrandSqList newBList = current->BList;
// 4.3. 单链表先删除该品牌
if (prev == NULL) {
p->next = current->next;
} else {
prev->next = current->next;
}
free(current);
// 4.4. 单链表再添加该品牌
/*LNode *newNode = (LNode *)malloc(sizeof(LNode));
newNode->BList = newBList;
newNode->next = p->next;
p->next = newNode;*/
InsertNextNode(L,newBList,i+1);
// 4.5. 跳出里循环
break;
}
prev = current;
current = current->next;
}
}
//5. 返回新的排好序的单链表
return L;
}
/*
//4.3.遍历旧链表找出与此次循环中频次相同的元素
while(p!=NULL) //p是头结点,要跳过
{
p = p->next;
//4.4.频次匹配(注:一定能找到,因为数组里的元素就是在旧链表的元素的频次取的,只是换了个位置)
if(arrListLen[i]==p->BList.g->num) //匹配上了
{
//4.5.记录该品牌
BrandSqList newBList=p->BList;//这个内容已经有了,不用初始化
//4.6.单链表先删除该品牌
DeleteNode(L,newBList.g->BN);
//4.7.单链表再添加该品牌
InsertNextNode(L,newBList,i+1);
//4.8.跳出里循环
break;
}
}
}
displayAllBrands(L);
//5.返回新的排好序的单链表
return L;
*/
/*
//4.根据降序后的频次把结点添加到新单链表中
//for(i=0;i<ListLen;i++) printf("%d ",arrListLen[i]);
//4.1.遍历频次数组(此时已经降序排序)取出元素,元素就是品牌查找频次
for(i=0;i<ListLen;i++)
{
//4.2.遍历旧链表找出与此次循环中频次相同的元素
while(p!=NULL) //p是头结点,要跳过
{
p=p->next;
//4.3.频次匹配(注:一定能找到,因为数组里的元素就是在旧链表的元素的频次取的,只是换了个位置)
if(arrListLen[i]==p->BList.g->num)
{
//4.4.找到了,添加到新链表中
flag=InsertNextNode(newL,p->BList,i+1); //此时i+1才表示位序
//4.5.判断
printf("添加"); final(flag);
//4.6.跳出循环
break;
}
}
//4.7.
p=q;
}
//5.返回新的单链表
return newL;
*/
/*------------------------------青格勒-------------------------------------*/
/*------------------------------刘佳鑫-------------------------------------*/
//给某个品牌添加型号
/* 需要单链表，品牌 */
bool InsertBModel(LinkList &L,char inBListBN[15])
{
//1.判断该品牌是否存在,返回品牌对应的结点
LNode *q=LocateElem(L,inBListBN);
if(q==NULL)
{
printf("该品牌不存在 \n");
return false;
}
//此时品牌存在
//2.输入品牌中要插入的型号
printf("品牌存在,请输入要插入的型号:");
char inBModel[10];
scanf("%s",inBModel);
//3.输入型号要插入的位置
printf("请输入型号要插入的位置:");
int address;
scanf("%d",&address);
//4.赋值给单链表里的顺序表里的品牌型号
//4.1.判断插入的位置是否合法
if(address<1|| address > q->BList.length+1 )
{
return false;
}
//4.2.判断是否存满
if(q->BList.length>=MaxSize) //这里要取等,当等于MaxSize时,说明存满了,就无法后移来空位置添加元素了,上面的L.BList.length+1同理
{
return false;
}
//4.3.走到这儿说明能插入数据
for(int j=q->BList.length;j>=address;j--)
{
//q->BList.bm[j]=q->BList.bm[j-1];
strcpy(q->BList.bm[j].model, q->BList.bm[j-1].model);
}
//4.4.最终空出address位置,进行添加
strcpy(q->BList.bm[address-1].model,inBModel);
//5.顺序表长度加一
q->BList.length++;
//6.结果
return true;
}
/*------------------------------刘佳鑫-------------------------------------*/
int main()
{
//1.创建品牌单链表
LinkList L;
//2.初始化单链表
flag=InitLinkList(L);
printf(" 单链表初始化"); final(flag);
//3.求出单链表长度
//ListLen=funListLen(L);这儿不用也不能求单链表长度,因为长度定义为全局变量了,而且现在求了第一次长度为0,添加的函数中在本操作中无法添加成功
printf("------------------------------------------------------------- \n");
//4.文教文化用品页面
printf(" 欢迎来到文教文化用品页面 \n");
printf(" 请选择你的操作 \n");
printf(" 1.插入品牌 2.删除品牌 \n");
printf(" 3.修改品牌内容 4.查找品牌 \n");
printf(" 5.显示所有品牌内容 6.查找最后一个品牌 \n");
printf(" 7.由频次而降序排列品牌 8.添加品牌中商品型号 \n");
printf(" 9.退出 \n");
printf("------------------------------------------------------------- \n");
//5.进行操作
while(true)
{
//5.开始选择
printf("请输入操作序号:");
int choice;
scanf("%d",&choice);
switch(choice)
{
case 1:
{
static int index=0; //记录品牌代号即编号,不是第几个
printf("请输入插入品牌的个数:");
int size;
scanf("%d",&size);
for(i=0;i<size;i++)
{
index++;
flag=InsertBrand(L,index);
if(!flag) continue;//代表此次有误,跳过本次循环
}
printf("------------------------------------------------------------- \n");
break;
}
case 2:
{
char outBListBN[15];
printf("请输入要删除的品牌:");
scanf("%s",outBListBN);
flag=DeleteNode(L,outBListBN);
printf("删除"); final(flag);
printf("------------------------------------------------------------- \n");
break;
}
case 3:
{
char changeBListBN[15];
printf("请输入要修改的品牌:");
scanf("%s",changeBListBN);
flag=changeGoods(L,changeBListBN);
printf("修改"); final(flag);
printf("------------------------------------------------------------- \n");
break;
}
case 4:
{
char findBListBN[15];
printf("请输入要查找的品牌:");
scanf("%s",findBListBN);
flag=LocateElem(L,findBListBN);
printf("查找"); final(flag);
printf("------------------------------------------------------------- \n");
break;
}
case 5:
{
printf(" 所有品牌如下 \n");
displayAllBrands(L);
printf("------------------------------------------------------------- \n");
break;
}
case 6:
{
findLastBrand(L);
printf("------------------------------------------------------------- \n");
break;
}
case 7:
{
L=funNewLinkList(L);
printf("新链表顺序生成成功 \n");
printf("------------------------------------------------------------- \n");
break;
}
case 8:
{
printf("请输入要修改的品牌:");
char inBListBN[15];
scanf("%s",inBListBN);
flag=InsertBModel(L,inBListBN);
printf("品牌中的商品型号插入"); final(flag);
printf("------------------------------------------------------------- \n");
break;
}
default: exit(0);
}
}
return 0;
}
草稿1：
#include<stdio.h>
#include<stdlib.h>
//定义文教文化用品品牌类型
struct brand
{
unsigned int BH; //品牌编号
char BN[20]; //品牌名
struct stationery *BList; //品牌商品表指针,这里不能用LNode,因为LNode是结构体定义完才有的，此时还没有
struct stationery *next; //指向下一个结点
};
//定义文教文化用品品牌单链表
typedef struct
{
struct brand info; //info为品牌信息
}LNode,*LinkList;//前者强调结点，后者强调单链表(两者等价)
//初始化单链表(带头结点)
bool InitList(LinkList &L)
{
L = (LNode *)malloc(sizeof(LNode)); //分配头结点
if(L==NULL) return false; //代表内存不足,头结点分配失败
//此时头结点分配成功
L->next = NULL;//头结点之后即第一个结点暂时还没有结点
return true;
}
//判断单链表是否为空
bool isEmpty(LinkList L)
{
if(L->next==NULL) return true; //头结点之后为NULL,为空
else return false;//代表不为空
}
//在第i个位置增加元素goods
bool ListInsert(LinkList &L,LNode goods,int i)
{
//1.判断位序
if(i<0) return false; //位序有误,添加失败
//2.定义变量记录当前的结点,一开始已经定义了单链表,一开始指向头结点,然后一个一个添加
LNode *p;
//3.定义变量记录当前是第几个结点
int j=0;//一开始为0即头结点
//4.从头开始找当前结点的前一个结点
while(p!=NULL&&j<i-1)
{
p = p->next;
j++;
}
if(p==NULL) return false; //说明i值不合法
//5.插入元素,此时指向第i-1个元素
//5.1.申请一个空间装要插入的元素
LNode *s=(LNode *)malloc(sizeof(LNode));
//5.2.放入要插入的元素
s->info = goods;
//5.3.修改指针
s.info->next = p.info->next;
p.info->next = s.info;
//6.插入成功
return true;
}
int main()
{
//1.声明单链表
LinkList L;
//2.初始化单链表,需要判断是否分配成功
bool flag=InitList(L);
if(flag) printf("单链表初始化成功 \n"); //分配失败，异常退出
else exit(1);
return 0;
}
草稿2：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MaxSize 10 //定义顺序表最大长度
static int result; //字符串比较结果
static int i; //循环初始值
static bool flag; //记录结果为真/假
//文教文化用品信息
typedef struct info
{
//品牌编号
unsigned int BH;
//品牌名
char BN[15];
}Goods;
//文教文化用品的品牌形成的单链表
typedef struct LNode
{
//文教文化用品
Goods g;
//该品牌被查找的次数
unsigned int num;
//指向下一个元素的指针,类型要用struct LNode而不是LNode,原因和下一行同理
struct LNode *next;//此时不能用*LinkList,因为此时还没有定义*LinkList,这个是结构体定义完才有的
}LNode,*LinkList;//前者强调结点，后者强调单链表(两者等价)
//存储品牌单链表的顺序表
typedef struct
{
//品牌单链表
LNode L; //LinkList L,不要用这个,因为LinkList是一个指针
//顺序表当前长度
int length;
}BrandSqList;
//初始化顺序表
void InitBList(BrandSqList BList[MaxSize]) //BList为数组名,就是地址,无需&
{
for(i=0;i<MaxSize;i++)
{
//BList[i].L=NULL;不要这么赋值,不好
BList = new BrandSqList[MaxSize];
}
BList[MaxSize].length=0; //一开始长度为0
}
//初始化单链表(带头结点)
bool InitList(LinkList &L)
{
//1.分配头结点
L = (LNode *)malloc(sizeof(LNode));
//2.判断是否分配成功
if(L==NULL)
{
return false; //内存不足,分配失败
}
//3.此时分配成功
L->next = NULL; //头结点之后暂时还没有结点
return true;
}
//顺序表添加元素(静态添加10个)
bool BListInsert(BrandSqList BList[MaxSize])
{
//1.品牌名
strcpy(BList[0].L.g.BN,"UME");
strcpy(BList[1].L.g.BN,"Staples");
strcpy(BList[2].L.g.BN,"YiWu");
strcpy(BList[3].L.g.BN,"Flash");
strcpy(BList[4].L.g.BN,"Parker");
strcpy(BList[5].L.g.BN,"LM");
strcpy(BList[6].L.g.BN,"HERO");
strcpy(BList[7].L.g.BN,"MaLi");
strcpy(BList[8].L.g.BN,"deli");
strcpy(BList[9].L.g.BN,"MG");
//2.编号以及查找次数
for(i=0;i<MaxSize;i++)
{
BList[i].L.g.BH=i+1;
BList[i].L.num=MaxSize-i;
BList->length++;
}
//3.判断是否越界
if(BList->length>MaxSize) return false;
//4.结尾
return true;
}
//顺序表删除元素
bool BListDelete(BrandSqList BList[MaxSize],char deleteL[15])
{
int index; //记录索引
//1.先查找要删除的元素是否存在
for(i=0;i<MaxSize;i++)
{
result=strcmp(deleteL,BList[i].L.g.BN);
if(result==0)
{
index=i;
break;
}
}
//2.如果result不为0时说明不存在,跳出函数
if(result!=0) return false;
//3.此时说明存在,开始删除
for(int j=index;j<BList->length;j++) //元素前移
{
BList[j]=BList[j+1];
}
//4.顺序表长度减一
BList->length--;
//5.结果
return true;
}
//显示所有品牌
void display(BrandSqList BList[MaxSize])
{
for(i=0;i<BList->length;i++)
{
printf("该品牌的名字为%s,编号为%d,查找频次为%d \n", BList[i].L.g.BN , BList[i].L.g.BH , BList[i].L.num);
}
}
//查找前10个品牌的最后一名
//需要要查找的位序,该位序上要找的商品品牌,顺序表
void findGoods(int index,char findBN[15],BrandSqList BList[MaxSize])
{
//先判断要查找的位序是否合法
if(index >= BList->length || index<0 )
{
return;
}
else if(index<9)
{
printf("不存在第十个品牌 \n");
return;
}
result = strcmp(BList[index].L.g.BN,findBN);
if( result==0 )
{
printf("前10个品牌的最后一名的品牌与要找的品牌%s匹配 \n",findBN);
//增加该品牌的查找频次
BList[index].L.num++;
}
else
{
printf("前10个品牌的最后一名的品牌与要找的品牌%s不匹配 \n",findBN);
}
}
//判断最终结果的函数
void final(bool flag)
{
if(flag)
{
printf("成功 \n");
}
else
{
printf("失败 \n");
exit(0);
}
}
int main()
{
//1.定义品牌商品顺序表
BrandSqList BList[MaxSize];
//2.初始化品牌商品顺序表
InitBList(BList); //传数组名即可
//3.顺序表添加元素
flag=BListInsert(BList);
final(flag); //判断结果
//4.显示所有品牌
display(BList);
printf("------------------------------------------------------ \n");
//5.查找前10个品牌的最后一名
char findBN[15];
findGoods(9,strcpy(findBN,"MG"),BList);
printf("------------------------------------------------------ \n");
//6.删除品牌
char deleteL[15];
flag=BListDelete(BList,strcpy(deleteL,"YiWu"));
final(flag); //判断结果
if(flag) display(BList); //删除成功的话显示结果
printf("------------------------------------------------------ \n");
//7.发生查找时按查找频次更改品牌的顺序
//7.1.查找两次MG
return 0;
}
草稿3：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MaxSize 10 //定义顺序表最大长度
static int result; //字符串比较结果
static int i; //循环初始值
static bool flag; //记录结果为真/假
static int ListLen;//记录单链表长度,全局要用,一开始长度为0
//品牌型号
typedef struct
{
char model[10];
}BModel;
//品牌信息
typedef struct
{
//品牌编号
char BH[5];
//品牌名
char BN[15];
//该品牌被查找的次数
unsigned int num;
}Goods;
//存储文教文化用品(商品)的顺序表
typedef struct
{
//品牌
Goods *g;
//品牌型号数组
BModel bm[MaxSize];
//顺序表当前长度,多一个型号则长度加一
int length;
}BrandSqList;
//文教文化用品的品牌形成的单链表
typedef struct LNode
{
//指向下一个品牌的指针,类型要用struct LNode而不是LNode,原因和下一行同理
struct LNode *next;//此时不能用*LinkList,因为此时还没有定义*LinkList,这个是结构体定义完才有的
//文教文化用品的顺序表,一个结点是一个品牌顺序表
BrandSqList BList;
}LNode,*LinkList;//前者强调结点，后者强调单链表(两者等价)
//初始化单链表(带头结点)
bool InitLinkList(LinkList &L) //注意加&
{
//1.分配头结点
L = (LNode *)malloc(sizeof(LNode));
//2.判断
if(L==NULL)
{
return false; //内存不足,分配失败
}
else
{
//分配成功
L->next = NULL; //头结点之后暂时还没有结点
return true;
}
}
//初始化顺序表
bool InitBrandSqList(BrandSqList &inBList) //记得加&,因为初始化,值改变了
{
//1.为顺序表分配数组空间
inBList.g = new Goods[MaxSize]; //new的是Goods,不是BrandSqList,因为分配给商品
//2.判断
if( inBList.g )
{
//分配成功
inBList.length = 0; //一开始长度为0
return true;
}
else
{
return false;//内存不足,分配失败
}
}
//判断最终结果的函数
void final(bool flag)
{
if(flag)
{
printf("成功 \n");
}
else
{
printf("失败 \n");
}
}
//顺序表内容赋值
void inputInBList(BrandSqList &inBList,int i) //需要&,因为顺序表值变了
{
printf("第%d个品牌: \n",i);
//1.品牌编号
printf("请输入品牌编号:");
scanf("%s",inBList.g->BH);
//2.品牌名
printf("请输入品牌名:");
scanf("%s",inBList.g->BN); //直接给字符数组录入即可
//3.查找频次一开始为0
inBList.g->num=0;
}
//添加品牌到单链表:在p结点之后插入下一个结点(顺序表)->该添加属于指定结点添加
/* L每次是单链表的第一个元素即头结点,
BrandSqList inBList是要插入的元素 */
//i为位序,如第一次插在第一个位置,再比如i为2代表插在第二个位置上,就要找到第一个位置插在他的后面
bool InsertNextNode(LinkList &L,BrandSqList inBList,int i) //inBList不用加&，因为只是添加到单链表,值没变
{
//1.判断位序是否合法
if(i<1)
{
printf("--");
return false; //位序必须是正整数
}
//此时位序合法
//2.建立指针p指向当前扫描到的结点
LNode *p;
//3.设置变量记录p扫描到第几个结点
int j=0;//一开始是头结点即为0
//4.L指向头结点,头结点是第0个元素(不存数据)
p=L;
//5.循环找到第i-1个结点
while(p!=NULL && j<i-1)
{
p = p->next;
j++;
}
//6.判断p
if(p==NULL)
{
return false; //说明i不合法
}
//7.给新结点申请内存空间
LNode *s = (LNode *)malloc(sizeof(LNode));
//8.判断s
if(s==NULL)
{
return false; //内存不足,分配失败
}
//9.把要添加的数据赋给空间s
s->BList = inBList;
//10.修改指针
s->next = p->next;
p->next = s;
//11.结果
return true;
}
//插入品牌的函数(要输入顺序表内容)
bool InsertBrand(LinkList &L,int i) //要加&,因为单链表发生了改变
{
//1.创建顺序表-->不能只在主函数中开头创建一个,因为单链表里不止一个顺序表
BrandSqList inBList; //顺序表创建后要全局用
//2.初始化顺序表
InitBrandSqList(inBList);
//3.顺序表内容赋值
inputInBList(inBList,i); //i也是编号
//4.插入品牌
flag=InsertNextNode(L,inBList,i);
if(flag)
{
printf("*该品牌添加成功* \n");
}
else
{
printf("该品牌添加失败 \n");
return false;
}
//5.此时插入成功,单链表长度加一
ListLen++;
//6.结果
return true;
}
//删除单链表里的品牌-->对于最后一个结点有限制
/*需要单链表,要删除的品牌*/
bool DeleteNode(LinkList &L,char outBListBN[15])
{
//1.遍历单链表的品牌,找是否有与要删除的品牌所匹配的
LNode *p = L->next; //跳过头结点,用LNode结点记录,这样稳妥,不容易出bug
while(p!=NULL)
{
result = strcmp(p->BList.g->BN,outBListBN);
if(result==0)
{
break; //找到了,跳出循环,此时L不为NULL
}
else
{
p = p->next; //没找到,后移
}
}
//2.判断L结点
if(p==NULL) return false; //此时代表没找到
//3.此时找到了,开始删除对应的结点L即修改指针
//3.1.令q指向*L的后继结点
LNode *q = p->next;
//3.2.和后继结点交换数据域
p->BList = q->BList;
//3.3.将*q结点从链中断开
p->next = q->next;
//3.4.释放后继结点的存储空间
free(q);
//4.单链表长度减一
ListLen--;
//5.结果
return true;
}
//查找品牌
/*需要单链表,要查找的品牌*/
LinkList LocateElem(LinkList &L,char findBListBN[15])
{
//1.跳过没数据的头结点
L = L->next;
//2.定义q来记录结点
LNode *q = L;
//3.遍历单链表开始查找
while( q!=NULL && (result=strcmp(q->BList.g->BN,findBListBN )!=0) )
{
q = q->next;
}
//4.判断
if(q==NULL) //要么到了最后一个结点都没找到,要么全都没有
{
printf("品牌%s不存在 \n",findBListBN);
return L; //代表此时没找到
}
//此时找到了,查找频次域加一
printf("品牌%s存在 \n",findBListBN);
q->BList.g->num++;
return L;
}
//改变商品的内容
/* 需要要改变的品牌,单链表 */
LinkList changeGoods(LinkList &L,char inBListBN[15])
{
//ListLen=funListLen(L); //求出单链表长度
//1.查找要改变的品牌是否存在
LNode *q=LocateElem(L,inBListBN);
if(q==NULL)
{
//此时不存在
printf("要改变的品牌不存在 \n");
return L;
}
//此时存在
//2.改变品牌内容,重新赋值
inputInBList(q->BList,ListLen);
//3.结果
return L;
}
int main()
{
//1.创建品牌单链表
LinkList L;
//2.初始化单链表
InitLinkList(L);
static int index=0; //记录品牌代号即编号,不是第几个
printf("请输入插入品牌的个数:");
int size;
scanf("%d",&size);
for(i=0;i<size;i++)
{
index++;
InsertBrand(L,index);
}
printf("------------------------------------------------------------- \n");
char outBListBN[15];
printf("请输入要删除的品牌:");
scanf("%s",outBListBN);
flag=DeleteNode(L,outBListBN);
printf("删除"); final(flag);
printf("------------------------------------------------------------- \n");
char changeBListBN[15];
printf("请输入要修改的品牌:");
scanf("%s",changeBListBN);
L=changeGoods(L,changeBListBN);
//printf("修改"); final(flag);
printf("------------------------------------------------------------- \n");
char findBListBN[15];
printf("请输入要查找的品牌:");
scanf("%s",findBListBN);
flag=LocateElem(L,findBListBN);
printf("查找"); final(flag);
printf("------------------------------------------------------------- \n");
return 0;
}
![[Linux] Linux 的进程如何调度——Linux的 O(1)进程调度算法](https://i-blog.csdnimg.cn/direct/2e68aaca6a914648bc6e3b0528c6667f.png)
![LeetCode[中等] 763. 划分字母区间](https://i-blog.csdnimg.cn/direct/de3cea7784674187b67f6ccf68c889fe.png)
