day-21 内核链表以及栈

1.昨日作业

1.删除指定节点

找到删除就完事了，双向可以停在删除处。

1. /****************************
2. * 功能：删除指定结点（通过姓名）
3. * 参数：phead；oldname;
4. * 返回：成功0，失-1；
5. * *************************/
7. int delete_specified_node(dou_node *phead,char *oldname)
8. {
9.     if(NULL == phead)
10.     {
11.         printf("phea is NULL");
12.             return -1;
13.     }
14.     dou_node *p = phead->pnext;
15.     while(NULL != p)
16.     {
17.         if(strcmp(p->data.name,oldname)==0)
18.         {
19.             dou_node *q = p->pnext;
20.             p->ppre->pnext = q;
21.             q->ppre = p->ppre;
22.             free(p);
23.             return 0;
24.         }
25.         p = p->pnext;
26.     }
27.     return -1;
28. }

复制代码

2.内核链表

内核链表将节点以及要储存的数据分脱离来，节点的使用函数不因数据范例的改变而必要重写。
1.klist.h

声明节点的范例，以及节点使用的函数

1. #ifndef __KLIST_H__
2. #define __KLIST_H__
4. typedef struct knode
5. {
6.     struct knode *ppre;
7.     struct knode *pnext;
8. }Knode;
10. extern Knode * creat_klist();
11. extern int insert_head_klist(Knode *phead ,Knode *pinsert);
12. extern void list_for_each(Knode *phead,void (*pfun)(Knode *));
14. extern int delete_tail_klist(Knode*phead);
15. extern int delete_head_klist(Knode*phead);
16. extern void destroy_klist(Knode * phead);
17. extern int insert_tail_klist(Knode *phead,Knode *pinsert);
18. #endif

复制代码

2.flight.h

声明数据结构体范例，

1. ##ifndef __FLIGHT_H__
2. #define __FLIGHT_H__
4. #include "klist.h"
6. struct passager
7. {
8.     Knode node;
9.     char name[32];
10.     int flt_num;
11.     int sit_num;
12.     char hea_card;
13. };
15. extern struct passager* creat_passager(char *name,int flt_num, int sit_num,char hea_card);
16. extern void print_passager(Knode *p);
17. #endif

复制代码

2 .klist.c

1.创建节点

1. Knode *creat_klist()
2. {
3.     Knode *phead = NULL;
4.     phead = malloc(sizeof(Knode));
5.     if(NULL == phead)
6.     {
7.         printf("malloc fail\n");
8.         return NULL;
9.     }
11.     phead->ppre = NULL;
12.     phead->pnext = NULL;
13.     return phead;
14. }

复制代码

2.前插

逻辑同双向链表的前插，但是呢插得是数据中的节点，故在main函数中应先定义数据结构体变量，定义的时候不用管节点成员。传参传结构体成员如下所示

1.         struct passager *p1 = creat_passager("zhangsan",2024,1,'r');   
2.     struct passager *p2 = creat_passager("lisi",2024,2,'g');
3.     struct passager *p3 = creat_passager("wanger",2024,3,'y');
4.    
5.     insert_tail_klist(phead,&(p1->node));
6.     insert_tail_klist(phead,&(p2->node));
7.     insert_tail_klist(phead,&(p3->node));

复制代码

插入分两种情况，空的和非空

2. int insert_head_klist(Knode *phead , Knode *pinsert)
3. {
4.     pinsert->pnext = phead->pnext;
5.     if(phead->pnext != NULL)
6.     {
7.         phead->pnext->ppre = pinsert;
8.     }
9.     pinsert->ppre = phead;
10.     phead->pnext = pinsert;
11.     return 0;
12. }

复制代码

3.后插

后插特别部分和前插一样，但是有个细节是查完之后pinsert->pnext = NULL;

1. int insert_klist_tail(KNode *phead, KNode *pnode)
2. {
3.         if (NULL == phead || NULL == pnode)
4.                 return -1;
5.        
7.         KNode *p = phead;
8.         while (p->pnext != NULL)
9.         {
10.                 p = p->pnext;
11.         }
12.        
13.         p->pnext = pnode;
14.         pnode->ppre = p;
15.         pnode->pnext = NULL;
16.        
17.         return 0;
18. }

复制代码

4.遍历（重重重点）

到达低耦合的效果
第一种

通过函数指针形成回调函数 。到达差别的数据范例也可以通过一个遍历函数完成便利，只必要传递差别的函数指针就行。

1. void list_for_each(Knode *phead, void (*pfun)(Knode *))
2. {
3.     if(phead ==NULL || NULL == pfun)
4.         return;
5.     Knode *p = phead->pnext;
7.     while(NULL  !=p)
8.     {
9.         pfun(p);
10.         p = p->pnext;
11.     }
12.     printf("\n");
14. }

复制代码

回调函数
先强转在访问

1. void print_passager(Knode *pnode)
2. {
3.     struct passager *p = (struct passager *)pnode;
4.     printf("%s %d %d %c\n",p->name,p->flt_num,p->sit_num,p->hea_card);
6. }

复制代码

main函数调用

1. list_for_each(phead,print_passager);

复制代码

第二种

通过带参宏的形式，去访问结构体成员
.h中声明

1. #define klist_for_each(pos, head)                                        \
2.         for (pos = (head)->pnext; pos != NULL; pos = pos->pnext)

复制代码

main’函数中直接使用，先强转随便访问结构体；

1. klist_for_each(ptmp, phead)
2. {
3.         struct passager *p = (struct passager *)ptmp;
4.        
5. }

复制代码

5.删除销毁等同双向，本质是双向链表，把节点放在结构体首个成员。结构体地点等于节点地点。

3.栈

1.体系栈和数据结构中的栈的区别

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。