#include <stdlib.h>/*标准库函数*/
#include <stdio.h>/*I/O函数*/
#include <string.h>/*字符串函数*/
#include <ctype.h>/*字符操作函数*/
typedef struct bookinfo
{
int id;
char name[20];
int count;
char nametype[20];//分类名称
char descript[50];//描述
int country;//国家
}bookinfo;
static bookinfo books;
typedef struct bookcontent
{
int sectionid;//第一章索引
char sectionname[10];//第一章
char paragraphname[10];//第二段
}bookcontent;
typedef enum booktype
{
STORY=0,
TECHNOLOGY,
MISC
}booktype;
typedef enum countrytype
{
INNER=0,//国内
OUTER, //国外
}countrytype;
//初始化信息
int bookinfo_init(void)
{
memset(&books, 0x00, sizeof(books));
books.id=1;
strcpy((char *)books.name,"方欣");
books.count=50;
strcpy((char *)books.nametype,"武打");
strcpy((char *)books.descript,"方欣2011年09月01日正式入读国定实验幼儿园，她很开心！");
books.country=-1;
return 1;
}
//int的指针的指针 变量存放的是指针
int bookcode=33;
int bookinfo_get_bookcode(int **ppbookcode)
{
if(NULL == ppbookcode)
{
return 0;
}
*ppbookcode = &bookcode;//数值变量地址->（&数值变量）
return 1;
}
//char的指针的指针 变量存放的是指针
char bookserial[20]="FX0000000098";
int bookinfo_get_bookserial(char **ppbookserial)
{
if(NULL == ppbookserial)
{
return 0;
}
*ppbookserial = bookserial;//数组变量地址->（数组变量名）
return 1;
}
//复合结构的指针的指针 变量存放的是指针
int bookinfo_get(bookinfo **ppbooks)
{
if(NULL == ppbooks)
{
return 0;
}
*ppbooks = &books;
return 1;
}
//获取 subtitle
int bookinfo_get_subtitle(char* title)
{
int len;
len = sizeof(char);
title== (char*)malloc(len);
memset(title,0x00,len);//初始化指针内存
strcpy(title,"方欣上学");
return 1;
}
//设置 bookcontent
int bookinfo_set_bookcontent(bookcontent *pbookcontent)
{
if (NULL == pbookcontent)
{
return 0;
}
pbookcontent->sectionid = 12;
strcpy(pbookcontent->sectionname,"第72章");
strcpy(pbookcontent->paragraphname,"第3回");
return 1;
}
//获取 bookcontent
int bookinfo_get_bookcontent(bookcontent *pbkcontent)
{
if (NULL == pbkcontent)
{
return 0;
}
bookcontent pkcontent;
int vr;
vr=bookinfo_set_bookcontent(&pkcontent);
if (0 == vr)
{
return 0;
}
pbkcontent->sectionid = pkcontent.sectionid;
strcpy(pbkcontent->sectionname,pkcontent.sectionname);
strcpy(pbkcontent->paragraphname,pkcontent.paragraphname);
return 1;
}
int bookinfo_get_id(int* id)
{
bookinfo *pbook;
int r;
r = bookinfo_get(&pbook);
if ((1!= r) || (NULL == pbook))
{
return 0;
}
(*id) = pbook->id;
return 1;
}
int bookinfo_get_name(char* name)
{
bookinfo *pbook;
int r;
r = bookinfo_get(&pbook);
if ((1!= r) || (NULL == pbook)| (NULL == name))
{
return 0;
}
strcpy(name,pbook->name);
return 1;
}
int bookinfo_get_count(int* count,int type)
{
bookinfo *pbook;
int r;
r = bookinfo_get(&pbook);
if ((1!= r) || (NULL == pbook))
{
return 0;
}
switch(type)
{
case 0:
*count= pbook->count;
break;
case 1:
*count= 80;
break;
}
return 1;
}
int bookinfo_get_nametype(char* nametype,booktype type)
{
bookinfo *pbook;
int r;
r = bookinfo_get(&pbook);
if ((1!= r) || (NULL == pbook))
{
return 0;
}
switch(type)
{
case STORY:
strcpy(nametype,"故事");
break;
case TECHNOLOGY:
strcpy(nametype,"技术");
break;
case MISC:
strcpy(nametype,pbook->nametype);
break;
default:
break;
}
return 1;
}
//获取描述
int bookinfo_get_descript(char* descript)
{
bookinfo *pbook;
int r;
r = bookinfo_get(&pbook);
if ((1!= r) || (NULL == pbook)||(NULL == descript))
{
return 0;
}
if(strcmp(pbook->descript, "") == 0)
{
descript[0]='\0';//获取 descript[0]={0};
return 1;
}
strcpy(descript,pbook->descript);
return 1;
}
//设置描述
int bookinfo_set_descript(char* descript)
{
bookinfo *pbook;
int r;
r = bookinfo_get(&pbook);
if ((1!= r) || (NULL == pbook)||(NULL == descript))
{
return 0;
}
strcpy(pbook->descript, descript);
return 1;
}
//获取地区
int bookinfo_get_country(countrytype* country)
{
bookinfo *pbook;
int r;
r = bookinfo_get(&pbook);
if ((1!= r) || (NULL == pbook))
{
return 0;
}
*country=pbook->country;
return 1;
}
//设置地区
int bookinfo_set_country(countrytype country)
{
bookinfo *pbook;
int r;
r = bookinfo_get(&pbook);
if ((1!= r) || (NULL == pbook))
{
return 0;
}
pbook->country=country;
return 1;
}
//遍历二维数组
int foreachArray()
{
int a[5][3]={0};
int i=0;
int j=0;
int count=0;
for(i=0;i<5;i++)
{
for(j=0;j<3;j++)
{
count++;
a[i][j] =(i+j);
printf("%d ",a[i][j]);
if((count%3)==0)
{
printf("%d\n",a[i][j]);
}
}
}
return 1;
}
/*********************单链表***************************/
//单链表头节点（序号为0） 无数据域 有指针域 存放第一个节点的首地址
//单链表尾节点 有数据域 有指针域 地址域值为NULL空
typedef struct student
{
int id;
char name[15];
struct student* next;//下一个节点的指针
}student;
//初始化线性表，即置单链表的表头指针为空
void init_link(student **pphead)
{
*pphead=NULL;
printf("init_link函数执行，初始化成功\n");
}
/*尾插法建立链表*/
student* creat_single_tail_link(student* phead)
{
student* pstudent;//工作节点
student* ptail;//尾节点
pstudent=NULL;
ptail=NULL;
int i=0;
while(i<5)
{
pstudent=(student*)malloc(sizeof(student));
if(pstudent==NULL)exit(0);//内存分配失败
memset(pstudent,0,sizeof(student));
pstudent->id=i;
sprintf(pstudent->name,"%s%d","方欣_",i);
if (phead==NULL)
{
phead=pstudent;//新结点插入空表
}
else
{
ptail->next=pstudent;//将新结点插到ptail之后
}
ptail=pstudent;//尾指针指向新表尾
i++;
}
if (ptail!=NULL)ptail->next=NULL;//对于非空表，将尾结点指针域置空head=s;
return phead;
}
/*头插法建立链表*/
student* creat_single_head_link(student* phead)
{
student* pstudent;//工作节点
pstudent=NULL;
phead=NULL;
int i=0;
while(i<5)
{
/*头插法建立链表*/
pstudent=(student*)malloc(sizeof(student));
if(pstudent==NULL)exit(0);//内存分配失败
memset(pstudent,0,sizeof(student));
pstudent->id=i;
sprintf(pstudent->name,"%s%d","方欣_",i);
pstudent->next= phead;//第i=0时 pstudent->next=NULL; 链尾
phead=pstudent;
i++;
}
return phead;
}
//打印链表，链表的遍历
void print_link(student *phead)
{
if(phead==NULL) //链表为空
{
printf("print_link函数执行，链表为空\n");
return;
}
while(phead !=NULL)
{
printf("%d %s\n",phead->id,phead->name);
phead = phead->next; //指针下移
// phead指向下一个结点 ，类似于数组里面的 i++
}
printf("\n");
}
/*打印链表，链表的遍历
void display(student *phead)
{
struct student *p = NULL;
for(p = phead; p != NULL; p = p->next)
{
printf("%d %d\n",p->number,p->grade);
}
} */
//释放单链表中所有的结点，使之成为一个空表
void clear_link(student *phead)
{
if(phead == NULL)
{
printf("clear_link函数执行，链表为空\n");
return;
}
while(phead->next != NULL)
{
student *ptmp= phead->next;//保存下一结点的指针
free(phead); // 释放内存
phead = ptmp;//表头下移
}
printf("clear_link函数执行，链表已经清除\n");
}
//清除单链表
void delete_all_link(student *phead)
{
if(phead == NULL)
{
printf("clear_link函数执行，链表为空\n");
return;
}
while(phead->next != NULL)
{
student *ptmp= phead->next;//保存下一结点的指针
free(phead); // 释放内存
phead = ptmp;//表头下移
}
printf("clear_link函数执行，链表已经清除\n");
}
//返回单链表的长度
int length_link(student *phead)
{
int i = 0;
while(phead != NULL)
{
i++; //遍历链表大小比链表的实际长度小1
phead = phead->next;
}
printf("length_link函数执行，链表长度 %d \n",i);
return i; //链表的实际长度
}
//检查单链表是否为空，若为空则返回１，否则返回０
int isempty_link(student *phead)
{
if(phead == NULL)
{
printf("isempty_link函数执行，链表为空\n");
return 1;
}
printf("isempty_link函数执行，链表非空\n");
return 0;
}
//返回单链表中第p个结点中的元素，若p超出范围，则停止程序运行
int get_node_link(student *phead, int p)
{
int i=0;
if(p < 1)
{
printf("get_node_link函数执行，p值非法\n");
return 0;
}
if(phead == NULL)
{
printf("get_node_link函数执行，链表为空\n");
return 0;
}
while(phead !=NULL)
{
//i++ ：先引用后增加
//++i ：先增加后引用
++i;
if(i == p)
{
break;
}
phead = phead->next; //移到下一结点
}
if(i < p) //链表长度不足则退出
{
printf("get_node_link函数执行，p值超出链表长度\n");
return 0;
}
return phead->id;
}
//从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL
int* get_node_address_link(student *phead, int x)
{
if(NULL == phead)
{
printf("get_node_address_link函数执行，链表为空\n");
return NULL;
}
if(x < 0)
{
printf("get_node_address_link函数执行，给定值X不合法\n");
return NULL;
}
while((phead->id != x) && (NULL != phead->next)) //判断是否到链表末尾，以及是否存在所要找的元素
{
phead = phead->next;
}
if((phead->id != x) && (phead != NULL))
{
printf("get_node_address_link函数执行，在链表中未找到x值\n");
return NULL;
}
if(phead->id == x)
{
printf("get_node_address_link函数执行，元素 %d 的地址为 0x%x\n",x,&(phead->id));
}
return &(phead->id);//返回元素的地址
}
//把单链表中第p个结点的值修改为x的值，若修改成功返回１，否则返回０
int update_node_link(student *phead,int p,int x)
{
student *pstudent;
pstudent = phead;
int i = 0;
if(pstudent==NULL)
{
printf("update_node_link函数执行，链表为空\n");
return 0;
}
if(p < 1)
{
printf("update_node_link函数执行，p值非法\n");
return 0;
}
while(pstudent !=NULL)
{
++i;
if(i == p)
{
break;
}
pstudent = pstudent->next; //移到下一结点
}
if(i < p) //链表长度不足则退出
{
printf("update_node_link函数执行，p值超出链表长度\n");
return 0;
}
phead =pstudent;
phead->id = x;
printf("update_node_link函数执行\n");
return 1;
}
//向单链表的表头插入一个元素 */
int insert_head_link(student **pphead,student node)
{
student *pstudent;
pstudent = (student *)malloc(sizeof(student));
memset(pstudent,0,sizeof(student));
pstudent->id = node.id;
strcpy(pstudent->name,node.name);
pstudent->next = *pphead; //当前节点的下一节点就是表头
*pphead = pstudent;
printf("insert_head_link函数执行，向表头插入元素成功\n");
return 1;
}
//向单链表的末尾添加一个元素 */
int insert_tail_link(student **pphead,student node)
{
student *pstudent; //新节点
student *ptail;
student *ptmp; //定义一个临时链表节点用来存放第一个节点
ptail = *pphead;
ptmp = ptail;
pstudent = (student *)malloc(sizeof(student)); //新节点分配内存
memset(pstudent,0,sizeof(student));
pstudent->id = node.id;
strcpy(pstudent->name,node.name);
while(ptail->next != NULL)
{
ptail = ptail->next;
}
ptail->next = pstudent; //将链表末尾节点的下一结点指向新添加的节点
*pphead = ptmp;
printf("insert_tail_link函数执行，向表尾插入元素成功\n");
return 1;
}
//删除链表中的一个数据
student *delete_node_link(student *phead,int val)
{
student *pstudent;//当前节点
student *ptail;//尾节点
if(phead==NULL)//头节点
{
printf("delete_node_link函数执行，链表为空\n");
exit(0);
}
pstudent=phead;//当前节点指向头节点
while(val!=pstudent->id && pstudent->next!=NULL)//若pstudent -> next == NULL 则为空链表
{
ptail=pstudent;
pstudent=pstudent->next;
}
//pstudent指向的不是所要找的结点，后面还有结点，
//使ptail , pstudent向后移动一个结点 ，并继续寻找
if(val==pstudent->id)
{
if(phead==pstudent)
{
//找到在第一个结点处 ，删除就是使phead 指向 pstudent所指向的结点
phead=pstudent->next;
}
else if(pstudent -> next == NULL)
{
ptail -> next = NULL; //找到在尾结点
}
else
{
//找到在中间结点pstudent，用ptail结点代替pstudent的位置
ptail->next=pstudent->next;
}
printf("delete_node_link函数执行：%d\n",val);
free(pstudent); //释放当前节点
}
else
{
printf("delete_node_link函数执行,失败：%d\n",val);
}
return phead;
}
//链表冒泡排序
student *pop_sort_link(student *pstudent)
{
student *pfront;//前一节点
student *pback;//后一节点
int tmp;
for(pfront = pstudent; pfront!=NULL; pfront = pfront->next)
{
for(pback = pstudent; pback->next!=NULL; pback=pback->next)
{
if(pfront == pback)continue;
if(pfront->id > pback->id)
{
tmp = pfront->id;
pfront->id = pback->id;
pback->id = tmp;
}
}
}
return pstudent;
}
//链表反转
student* reverse_link(student* phead)
{
if(phead==NULL)
{
printf("reverse_link函数执行，链表为空\n");
return NULL;
}
student* prever;//反转链表变量
prever=NULL;
while(phead!=NULL)
{
/* ptmp临时保存phead后面的链（指针），因为马上就会被写掉 */
student* ptmp=phead->next;
/* 下面两行实际上将phead插入链表prever的头部中 */
phead->next=prever;//操作链指向 即prever的存放内存地址
prever=phead;//操作结点 将 phead结点写入 prever
/* 恢复phead的值，使phead指向下一结点 */
phead=ptmp;
}
/* 这时phead应该为NULL */
return prever;
}
//链表是否存在环
int is_exits_loop(student* phead)
{
//定义两个临时链表变量
student* slow;
student* fast;
//将链表同时赋给两个链表变量
slow=phead;
fast=phead;
while(fast&&fast->next!=NULL)
{
slow=slow->next;// 慢链表一次下移一个节点
fast=fast->next->next;// 快链表一次下移两个节点
if(fast==slow) return 1;//存在环 ，退出返回1
}
return 0;
}
/*********************单链表***************************/
int main(int argc, char *argv[])
{
int i;
char s[128];
int ret;
char bookname[20];
int bookid;
int bookcount;
char bookcatory[20];
char bookdes[50];
countrytype countryer;
bookcontent bcontent;
char* subtitle;
char* bserial;
int* bcode;
student *pstudent=NULL;
//init_link(&pstudent); //链表初始化
ret=bookinfo_init();//初始化book信息
//clrscr();
printf("********************MENU*******************\n\n");
printf("| 0: bookinfo_get_id |\n");
printf("| 1: bookinfo_get_name |\n");
printf("| 2: bookinfo_get_count |\n");
printf("| 3: bookinfo_get_count |\n");
printf("| 4: bookinfo_get_nametype |\n");
printf("| 5: bookinfo_get_nametype |\n");
printf("| 6: bookinfo_get_descript |\n");
printf("| 7: bookinfo_get_country |\n");
printf("| 8: bookinfo_get_bookcontent |\n");
printf("| 9: bookinfo_get_subtitle |\n");
printf("| 10: bookinfo_get_bookcode |\n");
printf("| 11: bookinfo_get_bookserial |\n");
printf("| 12: foreachArray |\n");
printf("| 13: quit |\n\n");
printf("*******************************************\n");
while(1)
{
//clrscr();
printf("\n 请输入操作选项:"); /*提示输入选项*/
scanf("%s",s);
i=atoi(s); /*将输入的字符串转化为整型数*/ //itoa()整型数转化为字符串
switch(i)
{
case 0:
ret = bookinfo_get_id(&bookid);
printf("bookid=%d\n",bookid);
break;
case 1:
ret = bookinfo_get_name(bookname);
printf("bookname=%s\n",bookname);
break;
case 2:
ret = bookinfo_get_count(&bookcount,0);
printf("bookcount=%d\n",bookcount);
break;
case 3:
ret = bookinfo_get_count(&bookcount,1);
printf("bookcount=%d\n",bookcount);
break;
case 4:
ret = bookinfo_get_nametype(bookcatory,STORY);
printf("tname=%s\n",bookcatory);
break;
case 5:
ret = bookinfo_get_nametype(bookcatory,MISC);
printf("tname=%s\n",bookcatory);
break;
case 6:
strcpy(bookdes,"方欣上的第一节课就是听张老师讲<<蛋蛋狼的故事>>，她很开心。");
ret = bookinfo_set_descript(bookdes);//设置 set
ret = bookinfo_get_descript(bookdes);//获取 get
sprintf(bookdes,"%s_%d_%d\n",bookdes,22,19);//格式化拼接字符串
//strcat(bookdes,"_上海"); //拼接字符串
printf("bookdes=%s\n",bookdes);
break;
case 7:
ret =bookinfo_set_country(OUTER);//设置 set
ret =bookinfo_get_country(&countryer);//获取 get
printf("countryer=%d\n",countryer);
break;
case 8:
ret =bookinfo_get_bookcontent(&bcontent);//获取 get
printf("sectionid=%d\nsectionname=%s\nparagraphname=%s\n",bcontent.sectionid,bcontent.sectionname,bcontent.paragraphname);
break;
case 9:
ret =bookinfo_get_subtitle(subtitle);
printf("subtitle=%s\n",subtitle);
free(subtitle);
break;
case 10:
ret =bookinfo_get_bookcode(&bcode);
printf("bcode=%d\n",*bcode);
break;
case 11:
ret =bookinfo_get_bookserial(&bserial);
printf("bserial=%s\n",bserial);
break;
case 12:
ret =foreachArray();//打印二维数组
//printf("bserial=%d%%\n",35);打印出35%
break;
case 13:
pstudent=creat_single_tail_link(pstudent); //尾插法创建单链表
print_link(pstudent); //打印单链表
break;
case 14:
pstudent=creat_single_head_link(pstudent);//头插法创建单链表
print_link(pstudent); //打印单链表
break;
case 15:
exit(0);
break;
default:
break;
}
}
return 0;
}
备注：数组名是指针常量。