前些天在看《算法精解-C语言描述》一书时,发现书里面的用于实现各种数据结构的源代码写的很精练,但是有苦于找不到该书的书本源代码,所以就干脆敲出来,发布到博客里,希望以后用到的时候直接拿来用。本博客只用于学习用途。若有侵权,请及时联系我,我马上删除。在此我就不再赘述各种数据结构的概念了,直接贴上源代码
1、单链表实现源代码
/*dlist.h*/
#ifndef DLIST_H
#define DLIST_H
#include <stdlib.h>
/*Define a structure for double-linked list elements 链表元素结构*/
typedef struct DListElmt_
{
void *data; //数据域
struct DListElmt_ *prev; //前驱指针
struct DListElmt_ *next; //后继指针
} DListElmt;
/*Define a struture for double-linked lists 双向链表结构*/
typedef struct DList_
{
int size;
int (*match)(const void *key1,const void *key2);
void (*destroy)(void *data);
DListElmt *head;
DListElmt *tail;
} DList;
/*public interface*/
void dlist_init(DList *list,void (*destroy)(void *data));
void dlist_destroy(DList *list);
int dlist_ins_prev(DList *list,DListElmt *element,const void *data);
int dlist_ins_next(DList *list,DListElmt *element,const void *data);
int dlist_remove(DList *list,DListElmt *element,void **data);
#define dlist_size(list) ((list)->size)
#define dlist_head(list) ((list)->head)
#define dlist_tail(list) ((list)->tail)
#define dlist_is_head(list,element) ((element)==(list)->head ? 1:0)
#define dlist_is_tail(element) ((element)==(list)->tail ? 1:0)
#define dlist_data(element) ((element)->data)
#define dlist_prev(element) ((element)->prev)
#define dlist_next(element) ((element)->next)
#endif
/*list.c*/
/***********************************************************************************
** File name:list.c
** Functions Descriptions:
void list_init():initialize the list
void list_destroy():destroy the list
int list_ins_next():insert the *data to the list behind the *element
list_rem_next():remove the element behind the *element
************************************************************************************/
#include<stdlib.h>
#include<stdio.h>
#include<memory.h>
#include "list.h"
void list_init(List *list,void (*destroy)(void *data))
{
/*initialize the list*/
list->size=0;
list->destroy=destroy;
list->head=NULL;
list->tail=NULL;
return ;
}
void list_destroy(List *list)
{
void *data;
while(list_size(list)>0)
{
if(list_rem_next(list,NULL,(void **)&data)==0 && list->destroy!=NULL)
{ list->destroy(data); }
}
memset(list,0,sizeof(List));
return ;
}
int list_ins_next(List *list,ListElmt *element,const void *data)
{
ListElmt *new_element;
if((new_element=(ListElmt *)malloc(sizeof(ListElmt)))==NULL)
return -1;
/*insert the element into the list*/
new_element->data=(void *)data;
if(element==NULL)
{ /*Handle insertion at the head of the list*/
if(list_size(list)==0)
list->tail=new_element;
new_element->next=list->head;
list->head=new_element;
}
else
{ /*handle insertion somewhere*/
if(element->next==NULL)
list->tail=new_element;
new_element->next=element->next;
element->next=new_element;
}
list->size++;
return 0;
}
int list_rem_next(List *list,ListElmt *element,void **data)
{
ListElmt *old_element;
if(list_size(list)==0)
return -1;
/*remove element for list*/
if(element==NULL)
{
/*handle removal from the head*/
*data=list->head->data;
old_element=list->head;
list->head=list->head->next;
if(list_size(list)==1)
list->tail=NULL;
}
else
{
/*handle removal from somewhere*/
if(element->next==NULL)
return -1;
*data=element->next->data;
old_element=element->next;
element->next=element->next->next;
if(element->next==NULL)
list->tail=NULL;
}
free(old_element);
list->size--;
return 0;
}
应用实例:
<pre class="cpp" name="code">/*main.c*/
#include<stdio.h>
#include"list.h"
#include"dlist.h"
#include"clist.h"
#include<memory.h>
#include<string.h>
typedef struct Student_
{
char name;
char sex;
int age;
}Student;
int List_printf(List *list)
{
int flag=1;
char name,sex;
int age;
ListElmt *listelmt=list->head;
while(flag==1)
{
Student *stu=listelmt->data;
name=stu->name;
sex=stu->sex;
age=stu->age;
printf("name is %c,sex is %c,age is %d\n",name,sex,age);
if(listelmt==list->tail)
flag=0;
listelmt=listelmt->next;
}
return 1;
}
int stu_init(Student *student,char names,char sexs,int ages)
{
student->name=names;
student->sex=sexs;
student->age=ages;
return 1;
}
int main()
{ /*init three student*/
int count;
List *plstu=(List *)malloc(sizeof(List));
Student *stu1=(Student *)malloc(sizeof(Student));
Student *stu2=(Student *)malloc(sizeof(Student));
Student *stu3=(Student *)malloc(sizeof(Student));
stu_init(stu1,'A','M',23);
stu_init(stu2,'B','F',22);
stu_init(stu3,'C','M',24);
list_init(plstu,(void *)list_destroy);
list_ins_next(plstu,NULL,stu1);
list_ins_next(plstu,list_tail(plstu),stu2);
list_ins_next(plstu,list_tail(plstu),stu3);
count=list_size(plstu);
printf("the size of the list is %d\n",count);
List_printf(plstu);
return 1;
}
2、双向链表实现源代码
/*dlist.h*/
#ifndef DLIST_H
#define DLIST_H
#include <stdlib.h>
/*Define a structure for double-linked list elements 链表元素结构*/
typedef struct DListElmt_
{
void *data; //数据域
struct DListElmt_ *prev; //前驱指针
struct DListElmt_ *next; //后继指针
} DListElmt;
/*Define a struture for double-linked lists 双向链表结构*/
typedef struct DList_
{
int size;
int (*match)(const void *key1,const void *key2);
void (*destroy)(void *data);
DListElmt *head;
DListElmt *tail;
} DList;
/*public interface*/
void dlist_init(DList *list,void (*destroy)(void *data));
void dlist_destroy(DList *list);
int dlist_ins_prev(DList *list,DListElmt *element,const void *data);
int dlist_ins_next(DList *list,DListElmt *element,const void *data);
int dlist_remove(DList *list,DListElmt *element,void **data);
#define dlist_size(list) ((list)->size)
#define dlist_head(list) ((list)->head)
#define dlist_tail(list) ((list)->tail)
#define dlist_is_head(list,element) ((element)==(list)->head ? 1:0)
#define dlist_is_tail(element) ((element)==(list)->tail ? 1:0)
#define dlist_data(element) ((element)->data)
#define dlist_prev(element) ((element)->prev)
#define dlist_next(element) ((element)->next)
#endif
/*dlist.c*/
#include<stdlib.h>
#include<stdio.h>
#include<memory.h>
#include "dlist.h"
/*dlist_init*/
void dlist_init(DList *list,void (*destroy)(void *data))
{ /*initialize the dlist*/
list->size=0;
list->destroy=destroy;
list->head=NULL;
list->tail=NULL;
return ;
}
/*dlist_destroy*/
void dlist_destroy(DList *list)
{
void *data;
/*remove each element*/
while(dlist_size(list)>0)
{
if(dlist_remove(list,dlist_tail(list),(void **)&data)==0 && list->destroy!=NULL)
{ list->destroy(data); }
}
memset(list,0,sizeof(DList));
return ;
}
/*dlist_ins_prev*/
int dlist_ins_prev(DList *list,DListElmt *element,const void *data)
{
DListElmt *new_element;
/*Do not allow a NULL element unless the list is empty*/
if(element==NULL && dlist_size(list)!=0)
return -1;
/*Allocate storage for the element*/
if((new_element=(DListElmt *)malloc(sizeof(DListElmt)))==NULL)
return -1;
/*insert the element into the list*/
new_element->data=(void *)data;
if(dlist_size(list)==0)
{
/* handle insertion when the list is empty*/
list->head=new_element;
list->head->prev=NULL;
list->head->next=NULL;
list->tail=new_element;
}
else
{
/*handle insertion when the list is not empty*/
new_element->next=element;
new_element->prev=element->prev;
if(element->prev==NULL)
list->head=new_element;
else
element->prev->next=new_element;
element->prev=new_element;
}
list->size++;
return 0;
}
/*dlist_ins_next*/
int dlist_ins_next(DList *list,DListElmt *element,const void *data)
{
DListElmt *new_element;
/*Do not allow a NULL element unless the list is empty*/
if(element==NULL && dlist_size(list)!=0)
return -1;
/*Allocate storage for the element*/
if((new_element=(DListElmt *)malloc(sizeof(DListElmt)))==NULL)
return -1;
/*insert the element into the list*/
new_element->data=(void *)data;
if(dlist_size(list)==0)
{
/* handle insertion when the list is empty*/
list->head=new_element;
list->head->prev=NULL;
list->head->next=NULL;
list->tail=new_element;
}
else
{
/*handle insertion when the list is not empty*/
new_element->next=element->next;
new_element->prev=element;
if(element->next==NULL)
list->tail=new_element;
else
element->next->prev=new_element;
element->next=new_element;
}
list->size++;
return 0;
}
/*dlist_remove*/
int dlist_remove(DList *list,DListElmt *element,void **data)
{
if(element==NULL ||dlist_size(list)==0)
return -1;
/*remove element for list*/
*data=element->data;
if(element==list->head)
{
/*handle removal from the head*/
list->head=element->next;
if(list->head==NULL)
list->tail=NULL;
else
element->next->prev=NULL;
}
else
{
/*handle removal from somewhere*/
element->prev->next=element->next;
if(element->next==NULL)
list->tail=element->prev;
else
element->next->prev=element->prev;
}
free(element);
list->size--;
return 0;
}
3、循环链表实现源代码
/*clist.h*/
#ifndef CLIST_H
#define CLIST_H
#include <stdlib.h>
/*Define a structure for circular list elements 链表元素结构*/
typedef struct CListElmt_
{
void *data; //数据域
struct CListElmt_ *next; //指针域
} CListElmt;
/*Define a struture for circular lists 单向循环链表结构*/
typedef struct CList_
{
int size;
int (*match)(const void *key1,const void *key2);
void (*destroy)(void *data);
CListElmt *head;
} CList;
/*public interface*/
void clist_init(CList *list,void (*destroy)(void *data));
void clist_destroy(CList *list);
int clist_ins_next(CList *list,CListElmt *element,const void *data);
int clist_rem_next(CList *list,CListElmt *element,void **data);
#define clist_size(list) ((list)->size)
#define clist_head(list) ((list)->head)
#define clist_is_head(list,element) ((element)==(list)->head ? 1:0)
#define clist_data(element) ((element)->data)
#define clist_next(element) ((element)->next)
#endif
<pre class="cpp" name="code">/*clist.c*/
#include<stdlib.h>
#include<stdio.h>
#include<memory.h>
#include "clist.h"
/*clist_init*/
void clist_init(CList *list,void (*destroy)(void *data))
{ /*initialize the list*/
list->size=0;
list->destroy=destroy;
list->head=NULL;
return ;
}
/*clist_destroy*/
void clist_destroy(CList *list)
{
void *data;
/*remove each element*/
while(clist_size(list)>0)
{
if(clist_rem_next(list,list->head,(void **)&data)==0 && list->destroy!=NULL)
{ list->destroy(data); }
}
memset(list,0,sizeof(CList));
return ;
}
/*clist_ins_next*/
int clist_ins_next(CList *list,CListElmt *element,const void *data)
{
CListElmt *new_element;
/*Allocate storage for the element*/
if((new_element=(CListElmt *)malloc(sizeof(CListElmt)))==NULL)
return -1;
/*insert the element into the list*/
new_element->data=(void *)data;
if(clist_size(list)==0)
{ /*Handle insertion when the list is emtpy*/
new_element->next=new_element;
element->next=new_element;
}
else
{ /*handle insertion when the list is no emtpy*/
new_element->next=element->next;
element->next=new_element;
}
list->size++;
return 0;
}
/*clist_rem_next*/
int clist_rem_next(CList *list,CListElmt *element,void **data)
{
CListElmt *old_element;
/*do not allow removal from an empty list*/
if(clist_size(list)==0)
return -1;
*data=element->next->data;
if(element->next==element)
{
/*handle only one element*/
old_element=element->next;
list->head=NULL;
}
else
{
/*handle removing other than one element*/
old_element=element->next;
element->next=element->next->next;
if(old_element==clist_head(list)) //last element
list->head=old_element->next;
}
free(old_element);
list->size--;
return 0;
}