数据结构一：链表(linux链表）

一：实现机制

linux链表实现思想就是：结点里面只创建一个next指针，用指针将各个结点相连接 打印和查找的时候，再进行类型的转换

二：代码

1 LinkList.h

/*
LinkList.h 
linux链表实现思想就是：结点里面只创建一个next指针，用指针将各个结点相连接
打印和查找的时候，在进行类型的转换 
*/ 
#ifndef _LINKLIST_H_
#define _LINKLIST_H_
#include<stdlib.h>
#include<stdio.h>

//链表小结点 和普通链表相比较 没有数据域 只有next指针 
typedef struct LINNODE{
	struct LINNODE *next;
}Link_Node; 

//链表，有头结点和长度
typedef struct LINKLIST{
	Link_Node head;// Link_Node的结构体，而不是结构体指针 
	int size;//结点个数 
}Link_List; 

//查找回调函数
typedef int (*FIND)(Link_Node *data1,Link_Node *data2); 

//打印回调函数
typedef void (*PRINT)(Link_Node *data);

//初始化
Link_List *_Init_();
//插入
void _Insert(Link_List *list,int pos,Link_Node *data);//插入的是Link_Node的指针 
//删除
void _Delete(Link_List *list,int pos);
//查找
int _Find(Link_List *list,Link_Node *data,FIND my_Find);
//打印
void _Print(Link_List *list,PRINT my_Print);
//结点个数size
int _Size(Link_List *list);
//释放内存 
void _Free(Link_List *list);




#endif

2 LinkList.c

/*
LinkList.c 
*/ 
#include "LinkList.h"

//初始化
Link_List *_Init_(){
	Link_List *list=(Link_List*)malloc(sizeof(Link_List));
	list->head.next=NULL;
	list->size=0;
	return list;
}
//插入
void _Insert(Link_List *list,int pos,Link_Node *data){//插入的是Link_Node的指针
	Link_Node *Current_Node=&(list->head);
	for(int i=0;i<pos;i++){//查找插入位置的前一个结点 
		Current_Node=Current_Node->next; 
	}
	//插入
	data->next=Current_Node->next;
	Current_Node->next=data;
	
	list->size++;
} 

//删除
void _Delete(Link_List *list,int pos){
	Link_Node *Current_Node=&(list->head);
	for(int i=0;i<pos;i++){//查找插入位置的前一个结点 
		Current_Node=Current_Node->next; 
	}
	Current_Node->next=Current_Node->next->next; 
	list->size--;
}

//查找
int _Find(Link_List *list,Link_Node *data,FIND my_Find){
	Link_Node *Current_Node=&(list->head);
	int pos=-1;
	int flag=-1;
	while(Current_Node!=NULL){
		if(my_Find(Current_Node,data)==0){//查找到了 
			//pos=flag;
			return flag;
			break;
		}
		flag++;
		Current_Node=Current_Node->next;
		
	}
	return flag;
}
//打印
void _Print(Link_List *list,PRINT my_Print){
	//打印头结点不需要考虑
	for(Link_Node *Current_Node=list->head.next;Current_Node!=NULL;Current_Node=Current_Node->next){
		my_Print(Current_Node);
	} 
}
//结点个数size
int _Size(Link_List *list){
	return list->size;
}
//释放内存 
void _Free(Link_List *list){
	if(list!=NULL){
		free(list);
		list=NULL;
	}
}

3 main.c

/*
main.c 
linux链表实现思想就是：结点里面只创建一个next指针，用指针将各个结点相连接
打印和查找的时候，在进行类型的转换 
*/ 
#include "LinkList.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

typedef struct PERSON{
	Link_Node node;
	char name[64];
	int age;
}Person;

//打印回调
void my_Print(Link_Node *data){
	Person *p=(Person *)data;//数据类型的转换
	printf("name:%s age:%d\n",p->name,p->age); 
}

//回调查找
int my_Find(Link_Node *data1,Link_Node *data2){
	//数据类型转换
	Person *p1=(Person *)data1;
	Person *p2=(Person *)data2;
	if(strcmp(p1->name,p2->name)==0&&p1->age==p2->age){
		return 0;
	}
	else{
		return -1;
	}
	
}
int main(void){
	
	//初始化
	Link_List *list=_Init_();
	//实例产生数据
	 Person p1,p2,p3,p4;
	 strcpy(p1.name,"AAA");
	 strcpy(p2.name,"BBB");
	 strcpy(p3.name,"CCC");
	 strcpy(p4.name,"DDD");
	 p1.age=10;
	 p2.age=20;
	 p3.age=30;
	 p4.age=40;
	 
	 //插入
	 printf("********insert**********\n");
	_Insert(list,0,(Link_Node*)&p1);
	_Insert(list,1,(Link_Node*)&p2);
	_Insert(list,2,(Link_Node*)&p3);
	_Insert(list,3,(Link_Node*)&p4);
	//打印
	_Print(list,my_Print);
	
	//查找
	printf("********my_Find**********\n");
	int pos=_Find(list,(Link_Node*)&p2,my_Find);
	//int pos=_Find(list,&p2,my_Find);
	if(pos==-1){
		printf("p2 not found\n");
	}
	else{
		printf("p2 found pos=%d\n",pos);
	}
	
	//删除
	printf("********delete**********\n");
	_Delete(list,2);
	_Print(list,my_Print);
	
	printf("Linked list size:%d\n",_Size(list));	
	 
	//释放内存 
	_Free(list);
	return 0;
}

三：结果显示

1.编译环境

centos 3.10.0-862.el7.x86_64 
gcc version 4.8.5 20150623 (Red Hat 4.8.5-39) (GCC)

2.编译命令

gcc main.c LinkList.c -o a.out -std=c99
./a.out

3.结果显示