第六周day1

双向循环链表封装

        节点：

            前驱指针

            数据

            后继指针

        链表结构：

            头指针(带头节点)

            节点数量

            注意：双链表不需要尾指针

        优点：

            1、从任意节点开始都可以遍历整个链表

            2、当已知节点位置可以根据情况选择从前到后或者从后到前进行遍历，以此可以提高链表的访问效率

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

//双链表的节点
typedef struct Node
{
	struct Node* prev;
	TYPE data;
	struct Node* next;
}Node;

//创建节点
Node* creat_node(TYPE data)
{
	Node* node=malloc(sizeof(Node));
	node->prev=node;
	node->next=node;
	node->data=data;
	return node;
}

//带头节点的双链表结构
typedef struct DoubleList
{
	Node* head;
	size_t size;
}DoubleList;

//创建链表结构
DoubleList* creat_list(void)
{
	DoubleList* list=malloc(sizeof(DoubleList));
	list->head=creat_node(0);
	list->size=0;
	return list;
}

//在两个节点之间添加一个节点
void _add_list(Node* p,Node* n,TYPE data)
{
	Node* node=creat_node(data);
	node->prev=p;
	node->next=n;
	p->next=node;
	n->prev=node;
}

//删除当前节点
void _del_list(Node* node)
{
	node->prev->next=node->next;
	node->next->prev=node->prev;
	free(node);
}

//访问链表中指定位置的节点
Node* _index_node(DoubleList* list,size_t index)
{
	if(index>=list->size) return NULL;
	
	if(index<=list->size/2)
	{
		Node* node=list->head->next;
		for(int i=0;i<index;i++)
		{
			node=node->next;
		}
		return node;
	}
	else
	{
		Node* node=list->head->prev;
		for(int i=0;i<list->size-(index+1);i++)
		{
			node=node->prev;
		}
		return node;
	}
	/*
	if(index<list->size/2)
	{
		Node* n=list->head->next;
		while(index-->0)
		{
			n=n->next;
		}
		return n;
	}
	else
	{
		Node* n=list->head->prev;
		while(++index<list->size)
		{
			n=n->prev;
		}
		return n;
	}*/
}

//访问链表中指定数值的节点
Node* _val_node(DoubleList* list,size_t val)
{
	for(Node* node=list->head->next;node!=list->head;node=node->next)
	{
		if(node->data==val)
		{
			return node;
		}
	}
	return NULL;
}

//头添加
void  add_head_list(DoubleList* list,TYPE data)
{
	_add_list(list->head,list->head->next,data);
	list->size++;
}

//尾添加
void  add_tail_list(DoubleList* list,TYPE data)
{
	_add_list(list->head->prev,list->head,data);
	list->size++;
}

//按位置插入
bool  insert_list(DoubleList* list,size_t size,TYPE data)
{
	Node* n=_index_node(list,size);
	if(n==NULL)	return false;
	_add_list(n->prev,n,data);
	list->size++;
	return true;
}

//按位置删除
bool  del_index_list(DoubleList* list,size_t index)
{
	Node* n=_index_node(list,index);
	if(n==NULL) return false;
	_del_list(n);
	list->size--;
	return true;
}

//按值删除
bool  del_val_list(DoubleList* list,TYPE data)
{
	Node* n=_val_node(list,data);
	if(n==NULL) return false;
	_del_list(n);
	list->size--;
	return true;
}

//按位置修改
bool  modify_index_list(DoubleList* list,size_t index,TYPE val)
{
	Node* n=_index_node(list,index);
	if(n==NULL) return false;
	n->data=val;
	return true;
}

//按值修改 全部改
int  modify_val_list(DoubleList* list,TYPE old,TYPE val)
{
	int cnt=0;
	for(Node* n=list->head->next;n!=list->head;n=n->next)
	{
		if(n->data == old)
		{
			n->data=val;
			cnt++;
		}
	}
	return cnt;
}

//访问
bool  access_list(DoubleList* list,size_t index,TYPE* val)
{
	Node* node=_index_node(list,index);
	if(node == NULL) return false;
	*val=node->data;
	return true;
}

//查询
int  query_list(DoubleList* list,TYPE val)
{
	Node* n=list->head->next;
	for(int i=0;n!=list->head;i++,n=n->next)
	{
		if(n->data==val) return i;
	}
	return -1;
}

//遍历
void  show_list(DoubleList* list)
{
	for(Node* n=list->head->next;n!=list->head;n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");
}

//清空
void  clean_list(DoubleList* list)
{
	Node* n=list->head->next;
	while(n!=list->head)
	{
		Node* temp=n;
		n=n->next;
		free(temp);

	}
	list->head->next=list->head;
	list->head->prev=list->head;
	list->size=0;
}

//销毁
void  destroy_list(DoubleList* list)
{
	clean_list(list);
	free(list->head);
	free(list);
}

int main(int argc,const char* argv[])
{
	DoubleList* list=creat_list();
	for(int i=0;i<10;i++)
	{
		add_tail_list(list,i+1);
	}
	show_list(list);
	//insert_list(list,10,88);
	//show_list(list);
	//del_index_list(list,1);
	//del_val_list(list,1);
	modify_index_list(list,9,99);
	modify_val_list(list,9,45);
	show_list(list);
	destroy_list(list);
	list=NULL;
}

Linux内核通用链表

    既然链表的节点不能包含万物，那么就让万物来包含节点

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

//Linux内核链表

//遍历节点
#define list_for_each(n,head)\
	for(n=head->next;n!=head;n=n->next)


//计算某个结构成员与结构首地址相差多少字节
#define offset(type,member) ((int)&(((type*)0)->member))

//计算出某个结构成员所处的结构变量的首地址
#define mem_to_obj(ptr,type,member) ((type*)((char*)ptr-offset(type,member)))

//第二种遍历结构方法
//obj结构体指针 head链表头节点 member节点在结构体中的成员名
#define list_for_each_entry(obj,head,member) \
	for(obj=mem_to_obj(head->next,typeof(*obj),member);\
		&obj->member!=head;\
		obj=mem_to_obj(obj->member.next,typeof(*obj),member))

typedef struct Node
{
	struct Node* prev;
	struct Node* next;
}Node;

//创建链表
Node* creat_list(void)
{
	Node* head=malloc(sizeof(Node));
	head->prev=head;
	head->next=head;
	return head;
}

void _add_list(Node* prev,Node* next,Node* node)
{
	node->next=next;
	node->prev=prev;
	prev->next=node;
	next->prev=node;
}

//头添加
void add_head_list(Node* head,Node*node)
{
	_add_list(head,head->next,node);
}

/* ****以下是调用者要写的代码**** */

typedef struct Student
{
	char name[20];
	char sex;
	char age;
	Node node;
	float score;
	int id;

}Student;



int main(int argc,const char* argv[])
{
	/*
	Student* stu=malloc(sizeof(Student));
	printf("---%p----%p----\n",stu,&stu->node);
	printf(" %d ",offset(Student,node));
	*/
	
	Node* head=creat_list();
	for(int i=0;i<10;i++)
	{
		Student* stu=malloc(sizeof(Student));
		sprintf(stu->name,"hehe%d",i);
		stu->sex=i%2?'w':'m';
		stu->age=18+i%2;
		stu->score=rand()%100;
		stu->id=10001+i;
		add_head_list(head,&stu->node);
	}
	Node* n=NULL;	
	/*
	list_for_each(n,head)
	{

		Student* stu = mem_to_obj(n,Student,node);
		printf("%s %c %hhd %f %d\n",stu->name,stu->sex,stu->age,stu->score,stu->id);
	}
	*/
	Student* stu=NULL;
	list_for_each_entry(stu,head,node)
	{
		
		printf("%s %c %hhd %f %d\n",stu->name,stu->sex,stu->age,stu->score,stu->id);
	}
}