2019年8月1日星期四（数据结构）

2019年8月1日星期四

一. 双向链表与双向循环链表区别？

1. 双向循环链表最后一个节点的后继指向头节点，头节点的前驱指针指向最后一个节点。

2. 节点模型？

struct list_node{

       int a;

       struct list_node*prev;

       struct list_node*next;

}

二. 双向循环链表的增删改查？

1.初始化链表头

struct list_node *init_list_head(struct list_node *head)

{

       head = (struct list_node *)malloc(sizeof(struct list_node));

      

       head->prev = head;

       head->next = head;

 

       return head;

}

2.尾插节点

int tail_add_list(struct list_node *head,int num)

{

       struct list_node *Node = NULL;

       struct list_node *p = NULL;

       Node = (struct list_node *)malloc(sizeof(struct list_node));

      

       Node->a = num;

      

       p = head->prev; //p指向最后一个节点

      

       Node->prev = p;

       Node->next = head;

       p->next = Node;

       head->prev = Node;

      

       return 0;

}

3.头插节点

int head_add_list(struct list_node *head,int num)

{

       struct list_node *Node = NULL;

       Node = (struct list_node *)malloc(sizeof(struct list_node));

      

       Node->a = num;

       Node->next = head->next;

       Node->prev = head;

       head->next->prev = Node;

       head->next = Node;

      

       return 0;

}

4.往前遍历链表

int backward_show_list(struct list_node *head)

{

       struct list_node *p = NULL;

       for(p=head->prev;p!=head;p=p->prev)

       {

              printf("p->a = %d\n",p->a);

       }

      

       return 0;

}

5.往后遍历链表

int forward_show_list(struct list_node *head)

{

       struct list_node *p = NULL;

       for(p=head->next;p!=head;p=p->next)

       {

              printf("p->a = %d\n",p->a);

       }

      

       return 0;

}

6.根据特征值搜索节点

void show_node(struct list_node *p)

{

       printf("p->a = %d\n",p->a); 

       return;

}

 

int search_list_node(struct list_node *head,int num)

{

       struct list_node *p = NULL;

       /*

       for(p=head->next;p!=head;p=p->next)

       {

              if(p->a == num)

              {

                     show_node(p);

                     return 0;

              }

       }

       */

      

       for(p=head->prev;p!=head;p=p->prev)

       {

              if(p->a == num)

              {

                     show_node(p);

                     return 0;

              }

       }

      

       return -1;

}

7.根据特征值删除节点

int delete_list_node(struct list_node *head,int num)

{

       struct list_node *p = NULL;

       struct list_node *q = NULL;

      

       for(q=head,p=head->next;p!=head;q=p,p=p->next)

       {

              if(p->a == num)

              {

                     q->next = p->next;

                     p->next->prev = q;

                     free(p);

                    

                     return 0;

              }

       }

      

       return -1;

}

8.删除链表

int delete_list(struct list_node *head)

{

       struct list_node *p = NULL;

       struct list_node *q = NULL;

      

       head->prev->next = NULL;

      

       for(p=q=head;p!=NULL;p=q)

       {

              q = p->next;

              free(p);

       }

      

       return 0;

}

三. 双向链表实例。  -> 触摸屏点击切换图片，第一张切换到最后一张，最后一张切换到第一张。

#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <linux/input.h>
#include <strings.h>
 
struct list_node{
       char picname[20];
       struct list_node *next;
       struct list_node *prev;
};
 
struct list_node *init_list_head(struct list_node *head)
{
       head = (struct list_node *)malloc(sizeof(struct list_node));
       
       head->prev = head;
       head->next = head;
       
       return head;
}
 
int tail_add_list(struct list_node *head,char *picname)
{
       struct list_node *Node = NULL;
       struct list_node *p = NULL;
       Node = (struct list_node *)malloc(sizeof(struct list_node));
       
       strcpy(Node->picname,picname);
       
       p = head->prev; //p指向最后一个节点
       
       Node->prev = p;
       Node->next = head;
       p->next = Node;
       head->prev = Node;
       
       return 0;
}
 
 
void show_bmp(char *name)
{
       char bmp_buf[800*480*3];//BMP格式图片缓冲区
       char lcd_buf[800*480*4];//LCD液晶缓冲区
       char show_buf[800*480*4];
       
       int ret,lcd;
       int i,j,x,y;
       
       //1. 访问BMP图片
       FILE *fp = fopen(name,"r");
       if(fp == NULL)
              printf("fopen error!\n");
       
       //2. 跳过BMP图片的54个头数据
       ret = fseek(fp,54,SEEK_SET);
       if(ret != 0)
              printf("fseek error!\n");
       
       //3. 读取BMP图片的数据
       ret = fread(bmp_buf,sizeof(bmp_buf),1,fp);
       if(ret != 1)
              printf("fread error!\n");
       
       //4. 访问LCD液晶
       lcd = open("/dev/fb0",O_WRONLY);
       if(lcd < 0)
              printf("open error!\n");
       
       //5. 像素点赋值
       for(i=0,j=0;i<800*480*4;i+=4,j+=3)
       {
              lcd_buf[i] = bmp_buf[j];
              lcd_buf[i+1] = bmp_buf[j+1];
              lcd_buf[i+2] = bmp_buf[j+2];
              lcd_buf[i+3] = 0;
       }
       
       //6. 上下翻转
       for(y=0;y<480;y++)
       {
              for(x=0;x<800*4;x++)
              {
                     show_buf[(479-y)*800*4+x] = lcd_buf[y*800*4+x];
              }
       }
       
       //7. 将图片数据写入到LCD液晶屏幕上
       ret = write(lcd,show_buf,sizeof(show_buf));
       if(ret != sizeof(show_buf))
              printf("write error!\n");
       
       //8. 关闭设备与文件
       close(lcd);
       fclose(fp);
}
 
int main(int argc,char *argv[])
{
       //0. 初始化链表
       struct list_node *head = NULL;
       head = init_list_head(head);
       
       //1. 打开目录
       DIR *dp = opendir("./pic/");
       if(dp == NULL)
              printf("opendir error!\n");
       
       //2. 切换目录
       chdir("./pic/");
       
       //3. 读取目录中内容
       struct dirent *ep = NULL;
       while(1)
       {
              ep = readdir(dp);
              if(ep == NULL)
                     break;
              
              if(ep->d_name[0] == '.')
                     continue;
              
              tail_add_list(head,ep->d_name);
       }
       
       //4. 显示第一张图片
       struct list_node *p = head->next;
       show_bmp(p->picname);
       
       //5. 访问触摸屏设备
       int fd = open("/dev/input/event0",O_RDONLY);
       if(fd < 0)
              printf("open event0 error!\n");
       
       //6. 不断读取触摸屏数据
       struct input_event buf;
       int x;
       while(1)
       {
              bzero(&buf,sizeof(buf));
              read(fd,&buf,sizeof(buf));
              if(buf.type == EV_ABS && buf.code == ABS_X)
                     x = buf.value;
              
              if(buf.type == EV_KEY && buf.code == BTN_TOUCH && buf.value == 0)
              {
                     if(x < 400) //点击了左边
                     {
                            if(p == head->next)
                            {
                                   p = head->prev;
                            }
                            else{
                                   p = p->prev;
                            }
                            
                            show_bmp(p->picname);
                     }
                     
                     if(x > 400)  //点击了右边
                     {
                            if(p == head->prev)
                            {
                                   p = head->next;
                            }
                            else{
                                   p = p->next;
                            }
                            show_bmp(p->picname);
                     }
              }
       }
       
       close(fd);
       closedir(dp);
       return 0;
}

四. linux内核链表。

1. 什么是内核链表？

内核链表与传统链表不一样，传统链表的数据域与指针域都是用户自定义，但是内核链表数据域是用户自定义，但指针域是在内核链表的头文件中已经定义好了。

内核链表是一种双向循环，头节点无效的链表。

2. 内核链表模型与传统链表差异？

内核链表头文件： kernel_list.h

既然内核链表指针域已经定义好，那么究竟这个指针域是长什么样子？

该指针域是一个结构体来的：

struct list_head{

      

       struct list_head *next;  -> 后继指针

       struct list_head *prev;  -> 前驱指针         

};

3. 设计内核链表模型？

struct list_node{

       /* 自定义数据域 */

       int a;

       /* 头文件中已经定义好的指针域 */

       struct list_head list;

}

五. 内核链表的增删改查？

0. 设计节点

struct list_node{

       int a;

       struct list_head list; //指针域，里面已经包含了两个指针

};  

1. 初始化链表？

1）为头节点申请堆空间。

   head = (struct list_node *)malloc(sizeof(struct list_node));

2）为头节点成员赋值

   INIT_LIST_HEAD(&(head->list));

解析： kernel_list.h 49行：

#define INIT_LIST_HEAD(ptr)

do{

       (ptr)->next = (ptr);    -> ptr应该是"struct list_head *"这种指针类型变量

       (ptr)->prev = (ptr);

}while(0)

2. 尾插数据

1）为新节点申请空间

   Node = (struct list_node *)malloc(sizeof(struct list_node));

2）为新节点数据域赋值

   Node->a = num;

3）调用尾插函数

   list_add_tail(&(Node->list),&(head->list));

解析：

static inline void list_add_tail(struct list_head *new, struct list_head *head)

 

{

       __list_add(new, head->prev, head);

 

}

new:  新节点的指针域的地址

head:  头节点的指针与的地址

__list_add函数例程：

static inline void __list_add(struct list_head *new,

struct list_head *prev,

struct list_head *next)

 

{

      

       next->prev = new;

      

       new->next = next;

      

       new->prev = prev;

      

       prev->next = new;

 

}

3. 头插数据

1）为新节点申请空间

   Node = (struct list_node *)malloc(sizeof(struct list_node));

2）为新节点数据域赋值

   Node->a = num;

3）调用头插函数

   list_add(&(Node->list),&(head->list));

解析：

static inline void list_add(struct list_head *new, struct list_head *head)

 

{

      

       __list_add(new, head, head->next);

 

}

4. 往后遍历链表

===========================================================

功能：list_for_each    -    iterate over a list

解析：

#define list_for_each(pos, head)  -> 这个宏定义就是一个循环来的！

for(pos=(head)->next;pos != (head);pos=pos->next)

  pos： 指向每一个指针域结构体的地址

  head： 头节点指针的地址

功能：list_entry – get the struct for this entry  -> 根据小结构体(指针)地址得到大结构体(数据+指针)的地址

解析：

#define list_entry(ptr, type, member)

((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))

  ptr： 指向小结构体的地址的指针变量

  type： 大的结构体的数据类型

  member：在大的结构体中，小的结构体叫什么名字

例子1:20%

int forward_show_list(struct list_node *head)

{

       struct list_head *p = NULL;

       struct list_node *tmp = NULL;

      

       list_for_each(p,&(head->list))

       {

              tmp = list_entry(p,struct list_node,list);

              printf("tmp->a:%d\n",tmp->a);

       }

      

       return 0;

}

 

===========================================================

功能： list_for_each_entry - iterate over list of given type 

       其实就是list_entry和list_for_each的相结合。

解析：

#define list_for_each_entry(pos, head, member)

 

for (pos = list_entry((head)->next, typeof(*pos), member);

&pos->member!=(head);pos=list_entry(pos->member.next, typeof(*pos), member))

  pos： 指向大的结构体的地址指针变量

  head: 头节点的指针域的地址

  member: 在大的结构体中，小的结构体叫什么名字

例子2： 80%

int forward_show_list(struct list_node *head)

{

       struct list_node *p = NULL;

      

       list_for_each_entry(p,&(head->list),list)

       {

              printf("p->a:%d\n",p->a);

       }

      

       return 0;

}

===========================================================

5. 往前遍历链表

功能：list_for_each_prev - iterate over a list backwards

解析：

#define list_for_each_prev(pos, head)

for (pos = (head)->prev; pos != (head);

pos = pos->prev)

  pos： 指向每一个指针域结构体的地址

  head： 头节点指针的地址

例子：

int backward_show_list(struct list_node *head)

{

       struct list_head *p = NULL;

       struct list_node *tmp = NULL;

       list_for_each_prev(p,&(head->list))

       {

              tmp = list_entry(p,struct list_node,list);

              printf("tmp->a:%d\n",tmp->a);

       }

       return 0;

}

===========================================================

   练习2：使用内核链表做通讯录

   要求1： 每一个节点代表一个用户

   要求2： 每一个用户包含姓名，电话号码，学校，序号，关系：  同学classmate  朋友friend  亲人 family

   要求3： 根据序号查找，根据关系来查找。

   要求4： 根据输入序号/姓名删除电话号码

6. 根据特征值来删除链表节点

===========================================================

功能： list_for_each_safe - iterate over a list safe against removal of list entry  -> p和q一起遍历。

解析：

#define list_for_each_safe(pos, n, head)

for (pos = (head)->next, n = pos->next; pos != (head);

pos = n, n = pos->next)

功能： 从链表总删除节点  -> 这个函数仅仅是把节点脱离开链表，并且保证链表不断开，但是内存没有释放。

解析：

static inline void list_del(struct list_head *entry)

{

      

       __list_del(entry->prev, entry->next);

      

       entry->next = (void *) 0;

      

       entry->prev = (void *) 0;

 

}

__list_del函数例程：

static inline void __list_del(struct list_head *prev, struct list_head *next)

 

{

      

       next->prev = prev;

      

       prev->next = next;

 

}

例子1：

int delete_list_node(struct list_node *head,int num)

{

       struct list_head *p = NULL;

       struct list_head *q = NULL;

       struct list_node *tmp = NULL;

      

       list_for_each_safe(p,q,&(head->list))

       {

              tmp = list_entry(p,struct list_node,list);

              if(tmp->a == num)

              {

                     list_del(p);  -> p指向需要删除的节点的小结构体

                     free(tmp);     -> tmp指向需要删除的节点的大结构体

              }

       }

       return 0;

}

 

===========================================================

功能：list_for_each_entry_safe – iterate over list of given type safe against removal of list entry

解析：

#define list_for_each_entry_safe(pos, n, head, member)

for (pos = list_entry((head)->next, typeof(*pos), member),

n = list_entry(pos->member.next, typeof(*pos), member);   

     &pos->member != (head);                 

pos = n, n = list_entry(n->member.next, typeof(*n), member))

例子2：

int delete_list_node(struct list_node *head,int num)

{

       struct list_node *p = NULL;

       struct list_node *q = NULL;

      

       list_for_each_entry_safe(p,q,&(head->list),list)

       {

              if(p->a == num)

              {

                     list_del(&(p->list));

                     free(p);

              }

       }

      

       return 0;

}

7. 删除整条链表

int delete_list(struct list_node *head)

{

       struct list_node *p = NULL;

       struct list_node *q = NULL;

      

       list_for_each_entry_safe(p,q,&(head->list),list)

       {

              list_del(&(p->list));

              free(p);

       }

       list_del(&(head->list));

       free(head);

      

       return 0;

}