课设实验-数据结构-单链表-文教文化用品品牌

题目：

代码：

正解：

#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;    
}