循环链表

原创 2015年11月18日 23:38:19

以下是循环单向链表的接口定义:

#ifndef _CLIST_H
#define _CLIST_H

#include <stdlib.h>

typedef struct CListElmt_
{
	void *data;
	struct CListElmt_ *next;
}CListElmt;

typedef struct CList_
{
	int size;
	void (*destroy)(void *data);
	void (*match)(const void *key1,const void *key2);
	CListElmt *head;
}CList;

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_next(element) ((element)->next)
#define clist_data(element) ((element)->data)

#endif  /* _CLIST_H */

下面是对接口内容的实现:

#include "list.h"
#include  <stdio.h>
#include <string.h>


void clist_init(CList *list,void (*destroy)(void *data))
{
	list->size = 0;
	list->destroy = destroy;
	list->head = NULL;

	return;
}

void clist_destroy(CList *list)
{
	void *data;
	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;
}

int clist_ins_next(CList *list,CListElmt *element,const void *data)
{
	CListElmt *new_element;
	new_element = (CListElmt *)malloc(sizeof(CListElmt ));
	if(new_element == NULL)
		return -1;
	new_element->data = (void *)data;

	if(clist_size(list) == 0)
	{
		new_element->next = new_element;
		list->head = new_element;
	}
	else  //不存在最后一个元素,所有不需要考虑最后的元素
	{
		new_element->next = element->next;
		element->next = new_element;
	}
	list->size++;
	return 0;
}

int clist_rem_next(CList *list,CListElmt *element,void **data)
{
	CListElmt *old_element;
	if(clist_size(list) == 0)
		return -1;

	*data = element->next->data;
	if(element->next == element)
	{
		old_element = element->next;
		list->head = NULL;
	}
	else
	{
		old_element = element->next;
		element->next = element->next->next;
		if(old_element == clist_head(list))
			list->head = old_element->next;
	}
	free(old_element);	
	list->size--;

	return 0;
}
最后内容是利用这些API来实现一些小应用:

#include "list.h"
#include <stdio.h>
#include <string.h>
#include <assert.h>
#define SIZE 30
CList list;

typedef struct hello_
{
	int a;
	int b;
	int c;
}hello;

void destroy(void *data)
{
	printf("in destroy.\n");
	//free(data); 
	return;
}

hello *init(const int a,const int b,const int c)
{
	hello *ptr;
	ptr = (hello *)malloc(sizeof(hello));
	if(ptr == NULL)
		return NULL;
	ptr->a = a;
	ptr->b = b;
	ptr->c = c;

	return ptr;
}

//查找前驱指针
CListElmt *find_prev(int n)
{
	int i;
	CListElmt *elem;
	elem = clist_head(&list);
	for(i = 1;i < n;i++)
		elem = clist_next(elem);
	return elem;
}

//查找要删除的数据域指针
hello *find_data(int n)
{
	int i;
	hello *hel;
	CListElmt *elem;
	elem = clist_head(&list);
	for(i = 0;i < n;i++)
	{
		elem = clist_next(elem);
		hel = clist_data(elem);
	}
	return hel;
}

/* 遍历函数 */
void loop_print(void )
{
	int i;
	CListElmt *elem;
	hello *p;
	elem = clist_head(&list);
	for(i = 0;i < clist_size(&list);i++)
	{
		p = clist_data(elem);
		printf("a=%d b=%d c=%d\n",p->a,p->b,p->c);
		elem = clist_next(elem);
	}
}

/* 准备插入的元素 */
static const hello hello_zhm = {7,8,9};

int main(void)
{
	hello *hel;
	CListElmt *elem;
	clist_init(&list,destroy);
	printf("Init OK!\n");
	
	hello *ptr_1,*ptr_2,*ptr_3,*ptr_4,*ptr_5;
	ptr_1 = init(1,1,1);
	ptr_2 = init(2,2,2);
	ptr_3 = init(3,3,3);
	ptr_4 = init(4,4,4);
	ptr_5 = init(5,5,5);

	clist_ins_next(&list,NULL,(void *)ptr_1);
	elem = clist_head(&list);
	clist_ins_next(&list,elem,(void *)ptr_2);
	elem = clist_next(elem);
	clist_ins_next(&list,elem,(void *)ptr_3);
	elem = clist_next(elem);
	clist_ins_next(&list,elem,(void *)ptr_4);
	elem = clist_next(elem);
	clist_ins_next(&list,elem,(void *)ptr_5);
	loop_print();

	
	printf("remove the third .now it is ...\n");
	elem = find_prev(2);
	hel = find_data(2);
	clist_rem_next(&list,elem,(void **)&hel);
	loop_print();

	printf("after insert into a fouth node .now ..\n");
	elem = find_prev(3);
	clist_ins_next(&list,elem,(void *)&hello_zhm);
	loop_print();
	
	printf("free the list !\n");
	clist_destroy(&list);
	loop_print();
	printf("free success.\n");
	return 0;
}

下面是运行结果:


    (完毕)

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

双向循环链表

  • 2017年10月13日 14:10
  • 473KB
  • 下载

c语言简单循环链表

  • 2016年04月22日 09:42
  • 2KB
  • 下载

单向循环链表的创建/插入/删除/输出算法

单向循环链表

单项循环链表

  • 2013年11月03日 00:07
  • 5KB
  • 下载

基于链表、数组实现队列、循环队列

队列是一种先进先出的数据结构,它和栈的性质正好相反,但是两者却经常结合在一起实现一些特殊的操作。 1.队列的接口 public interface QueueADT { //入队 public...

循环链表的实现

  • 2014年07月11日 14:00
  • 16KB
  • 下载

c++编的双线循环链表

  • 2013年07月05日 18:48
  • 929KB
  • 下载

双向循环链表(插入,删除,就地逆置)

package design; import java.util.Scanner; //循环双链表 public class LinkedList { private int theSi...

排序树 双向 循环链表

  • 2014年08月31日 22:25
  • 3KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:循环链表
举报原因:
原因补充:

(最多只允许输入30个字)