====
引言
在前面，我们已经对数据结构中的双向链表进行了阐述，在这一节，我们将会对双向链表进行更深层次的封装。
在C++的STL中。或者在java中，都会有一个概念叫做迭代器。迭代器提供对一个容器中的有范围的对象的访问。迭代器就如同一个指针。这一节我们可以迭代器封装链表使用户接触不到底层数据结构，保证安全访问。
以及将我们常用到的函数封装在tools.h当中，使程序模块化，碎片化，冗余性低，便于提升和增加新功能。
一、双向链表定义
与上一节基本相同：
双向链表定义
#ifndef _DLIST_H_
#define _DLIST_H_
#include "iterator.h" // 这里我们增加了一个iterator迭代器的头文件
#define TRUE (1)
#define FALSE (0)
#define ZERO (0)
#define ONLY_ONE (1)
typedef unsigned char Boolean ; // 布尔类型
typedef void (*Print_func)(void *value); // 打印的函数指针
void print_int(void *data);
typedef struct Dlist_node{
struct Dlist_node *prev;
struct Dlist_node *next; // 指向后一个节点
void *data;
}Dlist_node;
typedef struct Dlist Dlist;
//通用链表控制信息
typedef struct Dlist
{
struct Dlist_node *head; //指向头结点
struct Dlist_node *tail; //指向尾节点
int count;
//这是一个指向某个需要被释放的数据域的函数指针
void (*free)(void *ptr);
//比较节点数据域 函数指针
Boolean (*match)(void *value1, void *value2);
//拷贝节点数据域 函数指针
void *(*copy_node)(void *value);
// 迭代器接口：
//指向链表头部
void *(*iter_head)(Iterator *iter, Dlist *dlist);
//指向链表尾部
void *(*iter_tail)(Iterator *iter, Dlist *dlist);
//指向前一个元素位置
void *(*iter_prev)(Iterator *iter, Dlist *dlist);
//指向后一个元素位置
void *(*iter_next)(Iterator *iter, Dlist *dlist);
}Dlist;
//1.双端链表的初始化
Dlist *init_dlist(void);
//2.双端链表的销毁
void destroy_dlist(Dlist **dlist);//二重指针
//3.头部插入
Boolean push_front(Dlist *dlist, void *data);
//4.尾部插入
Boolean push_back(Dlist *dlist, void *data);
//5.头部删除
Boolean pop_front(Dlist *dlist);
//6.尾部删除
Boolean pop_back(Dlist *dlist);
//7.插入到当前节点前
Boolean insert_prev(Dlist *dlist, Dlist_node *node, void *value);
//8.插入到当前节点后
Boolean insert_next(Dlist *dlist, Dlist_node *node, void *value);
//9.删除某个节点
Boolean remove_dlist_node(Dlist *dlist, Dlist_node *node);
//10.显示双端链表信息
void show_dlist(Dlist *dlist, Print_func print);
//11.得到第一个节点数据域
Boolean get_front(Dlist *dlist, void **value);
//12.得到最后一个节点数据域
Boolean get_tail(Dlist *dlist, void **value);
//13.得到链表节点数量
int get_dlist_count(Dlist *dlist);
//14.得到第几个节点
Dlist_node *find_node(Dlist *dlist, int index);
#endif* 工具类接口定义 *
#ifndef _TOOLS_H_
#define _TOOLS_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//工具类接口
void *Malloc(size_t size);
void swap(void *a, void *b, int length);
#endif* 工具类接口实现 *
#include "tools.h"
//工具类接口
void *Malloc(size_t size)
{
void *result = malloc(size);
if(result == NULL)
{
fprintf(stderr, "the memory is full !\n");
exit(1);
}
return result;
}
void swap(void *a, void *b, int length)
{
void *temp = Malloc(length);
memcpy(temp, a, length);
memcpy(a, b, length);
memcpy(b, temp, length);
free(temp);
}
二、迭代器的定义
* 迭代器的定义 *
#ifndef _ITERATOR_H_
#define _ITERATOR_H_
typedef struct Iterator
{
void *ptr; //指针 void* 通用指针
int index; //整型 index 指标 索引
int size; //整型 size 大小
}Iterator; //三个成员的一个结构体
/*
* 正向迭代器
* container(list、array、stack)容器
*/
//宏定义
#define FOREACH(iter, container) \
for(container->iter_head(&(iter), container); \
(iter).ptr; \
container->iter_next(&(iter), container))
#define foreach FOREACH
#define FOREACH_REVERSE(iter, container) \
for(container->iter_tail(&(iter), container); \
(iter).ptr; \
container->iter_prev(&(iter), container))
#define foreach_reverse FOREACH_REVERSE
#endif由于迭代器是在链表中使用，所以我们把迭代器操作实现一起放在了链表的实现文件里。
我们可以从定义中看到，我们定义的foreach是一个正向、在container中通过ptr指针指向下一个迭代的正向迭代方法。
foreach_reverse正好是从tail尾开始向前iter_prev反向的反向迭代。
三、双向链表的接口实现
#include "dlist.h"
#include "tools.h"
// 整型的打印函数
void print_int(void *data)
{
printf("%d ",*(int *)data);
}
// 迭代器的接口函数指针定义
static void *dlist_iter_head(Iterator *iter, Dlist *dlist);
static void *dlist_iter_tail(Iterator *iter, Dlist *dlist);
static void *dlist_iter_prev(Iterator *iter, Dlist *dlist);
static void *dlist_iter_next(Iterator *iter, Dlist *dlist);
//迭代器的接口函数指针实现
//1.dlist的头迭代指针
static void *dlist_iter_head(Iterator *iter, Dlist *dlist)
{
if(iter == NULL || dlist == NULL)
{
return NULL;
}
iter->index = 0;
iter->size = dlist->count;
//dlist的头节点
if(dlist->head->data == NULL || dlist->count == ZERO)
{
iter->ptr = NULL;
}
else
{
iter->ptr = dlist->head->data;
}
return iter->ptr;
}
//2.dlist的尾节点迭代
static void *dlist_iter_tail(Iterator *iter, Dlist *dlist)
{
if(iter == NULL || dlist == NULL)
{
return NULL;
}
iter->index = dlist->count - 1;
iter->size = dlist->count;
//dlist的尾节点
if(dlist->tail->data == NULL || dlist->count == ZERO)
{
iter->ptr = NULL;
}
else
{
iter->ptr = dlist->tail->data;
}
return iter->ptr;
}
//3.dlist迭代前一个(函数指针)
static void *dlist_iter_prev(Iterator *iter, Dlist *dlist)
{
if(iter == NULL || dlist == NULL)
{
return NULL;
}
iter->index --;
iter->size = dlist->count;
if(iter->index <= ZERO)
{
iter->ptr = NULL;
}
else
{
iter->ptr = find_node(dlist, iter->index)->data;
}
return iter->ptr;
}
//4.dlist迭代后一个(函数指针)
static void *dlist_iter_next(Iterator *iter, Dlist *dlist)
{
if(iter == NULL || dlist == NULL)
{
return NULL;
}
iter->index ++;
iter->size = dlist->count;
if(iter->index >= iter->size)
{
iter->ptr = NULL;
}
else
{
iter->ptr = find_node(dlist, iter->index)->data;
}
return iter->ptr;
}
//创建一个节点
Dlist_node *create_node(void);
Dlist_node *create_node(void)
{
Dlist_node *node = (Dlist_node *)Malloc(sizeof(Dlist_node));
bzero(node, sizeof(Dlist_node));
return node;
}
//1.双端链表的初始化
Dlist *init_dlist(void)
{
Dlist *dlist = (Dlist *)Malloc(sizeof(Dlist));
bzero(dlist, sizeof(Dlist));
//置函数指针
dlist->iter_head = dlist_iter_head;
dlist->iter_tail = dlist_iter_tail;
dlist->iter_prev = dlist_iter_prev;
dlist->iter_next = dlist_iter_next;
return dlist;
}
//2.双端链表的销毁
void destroy_dlist(Dlist **dlist)//二重指针
{
if(dlist == NULL || *dlist == NULL)
{
return;
}
/*
while((*dlist)->head) //(*)->
{
pop_back(*dlist); //只要有头节点就尾删
}
*/
Dlist_node *p_node = (*dlist)->head;
while((*dlist)->head != NULL)
{
(*dlist)->head = p_node->next;
if((*dlist)->free != NULL)
{
(*dlist)->free(p_node->data); //若我们有自己编写free函数，就用我们定义的free函数指针释放资源
}
free(p_node);
p_node = (*dlist)->head;
}
free(*dlist);
dlist = NULL;
}
//3.头部插入
// case 1:
// node
// |
// head tail
//
// case 2:
// node
// //
// node1==node2==node3
// \ /
// head|tail
Boolean push_front(Dlist *dlist, void *data)
{
//创建新节点
Dlist_node *node = create_node();
node->data = data ;
if(dlist == NULL || data == NULL)
{
return FALSE;
}
if(dlist->count == ZERO)
{
dlist->tail = node; //若dlist中没有元素则将dlist->tail也给这个节点
}
else
{
node->next = dlist->head; //置node的next为头节点
dlist->head->prev = node; //head的前一个置是node
}
dlist->head = node;
dlist->count ++;
return TRUE;
}
//4.尾部插入
Boolean push_back(Dlist *dlist, void *data)
{
if(dlist == NULL || data == NULL)
{
return FALSE;
}
Dlist_node *node = create_node();
node->data = data ;
if(dlist->count == ZERO)
{
dlist->head = node;
}
else
{
node->prev = dlist->tail;
dlist->tail->next = node;
}
dlist->tail = node;
dlist->count ++;
return TRUE;
}
//5.头部删除
Boolean pop_front(Dlist *dlist)
{
if(dlist == NULL || dlist->count == ZERO)
{
return FALSE;
}
Dlist_node *node = dlist->head;
if(dlist->count == ONLY_ONE)
{
dlist->head = dlist->tail = NULL;
}
else
{
dlist->head = node->next;
dlist->head->prev = NULL;
}
/*
dlist->free(node);
node = NULL;
*/
if(dlist->free != NULL) //如果我们有相应的free函数
{
dlist->free(node->data); //调用自己的free函数
}
free(node);
dlist->count -- ;
return TRUE;
}
//6.尾部删除
Boolean pop_back(Dlist *dlist)
{
if(dlist == NULL || dlist->count == ZERO)
{
return FALSE;
}
Dlist_node *node = dlist->tail;
if(dlist->count == ONLY_ONE)
{
dlist->head = dlist->tail = NULL;
}
else
{
dlist->tail = node->prev;
dlist->tail->next = NULL;
}
if(dlist->free != NULL) //free函数指针
{
dlist->free(node->data);
}
free(node);
dlist->count -- ;
return TRUE;
}
//7.插入到当前节点前
Boolean insert_prev(Dlist *dlist, Dlist_node *node, void *value)
{
Dlist_node *p_node = create_node();
p_node->data = value;
if(dlist == NULL || node == NULL )
{
return FALSE;
}
if(dlist->count == ONLY_ONE)
{
push_front(dlist, value);
return TRUE;
}
else //普通情况下
{
p_node->next = node;
p_node->prev = node->prev;
node->prev->next = p_node;
node->prev = p_node;
dlist->count++;
}
return TRUE;
}
//8.插入到当前节点后
Boolean insert_next(Dlist *dlist, Dlist_node *node, void *value)
{
Dlist_node *p_node = create_node();
p_node->data = value;
if(dlist == NULL || node == NULL )
{
return FALSE;
}
if(dlist->count == ONLY_ONE)
{
push_back(dlist, value);
return TRUE;
}
else
{
p_node->next = node->next;
p_node->prev = node;
node->next->prev = p_node;
node->next = p_node;
dlist->count++;
}
return TRUE;
}
//9.删除某个节点
Boolean remove_dlist_node(Dlist *dlist, Dlist_node *node)
{
if(dlist == NULL || node == NULL)
{
return FALSE;
}
if(node->next == NULL)
{
return pop_back(dlist);
}
else
{
Dlist_node *p_node = node->next;
node->data = p_node->data;
node->next = p_node->next;
p_node->next->prev = node;
if(dlist->free != NULL)
{
dlist->free(p_node->data);
}
free(p_node);
dlist->count -- ;
}
return TRUE;
}
//10.显示双端链表信息
void show_dlist(Dlist *dlist, Print_func print)
{
Dlist_node *p_node = NULL;
if(dlist != NULL && dlist->count >0)
{
for(p_node = dlist->head; p_node; p_node = p_node->next)
{
print(p_node->data); //这里是传入的参数指针
}
printf("\n");
}
}
//11.得到第一个节点数据域
Boolean get_front(Dlist *dlist, void **value) //函数返回值为布尔类型，则可以通过参数保存需要得到的值。二重指针。
{
if(dlist == NULL || dlist->count == ZERO)
{
return FALSE;
}
if(value != NULL)
{
*value = dlist->head->data; //一级指针
}
return TRUE;
}
//12.得到最后一个节点数据域
Boolean get_tail(Dlist *dlist, void **value)
{
if(dlist == NULL || dlist->count == ZERO)
{
return FALSE;
}
if(value != NULL)
{
*value = dlist->tail->data;
}
return TRUE;
}
//13.得到链表节点数量
int get_dlist_count(Dlist *dlist)
{
if(dlist == NULL)
{
return -1; //返回值一般用-1表示出错;
}
else
{
return dlist->count;
}
}
//14.得到第几个节点
Dlist_node *find_node(Dlist *dlist, int index)
{
int i = 0;
Dlist_node *p_node = NULL;
if(dlist == NULL || index > dlist->count || index < 0) //判断条件
{
return NULL;
}
p_node = dlist->head;
while(i++ < index)
{
p_node = p_node->next;
}
return p_node;
}四、程序功能验证
main.c
#include <stdio.h>
#include "dlist.h"
/*
void print_int(void *value);
void print_int(void *value)
{
printf("%d ",*(int *)value);
}
*/
int main(int argc, char **argv)
{
int i = 0;
int a[]={1,2,3,4,5};
void *value;
Iterator iter = {0};
Dlist *dlist = NULL;
dlist = init_dlist();
for(i=0; i< sizeof(a)/sizeof(a[0]);++i)
{
push_front(dlist, &a[i]);
}
show_dlist(dlist, print_int);
pop_front(dlist);
printf("---------foreach：\n");
//这里，我们就用到了迭代的方法，用我们定义的foreach对dlist这个容器进行迭代的输出。
foreach(iter, dlist)
{
print_int(iter.ptr);
}
printf("\n");
show_dlist(dlist, print_int);
for(i=0; i< sizeof(a)/sizeof(a[0]);++i)
{
push_back(dlist, &a[i]);
}
show_dlist(dlist, print_int);
pop_back(dlist);
show_dlist(dlist, print_int);
insert_prev(dlist, dlist->head->next->next, &a[4]);
show_dlist(dlist, print_int);
insert_next(dlist, dlist->head->next->next, &a[4]);
show_dlist(dlist, print_int);
remove_dlist_node(dlist, dlist->head->next->next->next);
show_dlist(dlist, print_int);
get_front(dlist, &value);
printf("\nfront:\n");
print_int(value);
get_tail(dlist, &value);
printf("\ntail:\n");
print_int(value);
printf("\n the length:\n");
printf("%d \n",get_dlist_count(dlist));
foreach(iter, dlist)
{
print_int(iter.ptr);
}
printf("\n");
destroy_dlist(&dlist);
return 0;
}编译运行结果
root@aemonair:i_dlist# cc.sh *.c
Compiling ...
-e CC dlist.c main.c tools.c -g -lpthread
-e Completed .
-e Thu Jun 16 00:21:05 CST 2016
程序运行结果
root@aemonair:i_dlist# ./dlist
5 4 3 2 1
---------foreach：
4 3 2 1
4 3 2 1
4 3 2 1 1 2 3 4 5
4 3 2 1 1 2 3 4
4 3 5 2 1 1 2 3 4
4 3 5 5 2 1 1 2 3 4
4 3 5 2 1 1 2 3 4
front:
4
tail:
4
the length:
9
4 3 5 2 1 1 2 3 4 总结
这次，我们只是简单的对迭代器有了初步认识，并且进一步封装了双向链表。对于链表的基本操作并没有多大改进，只是着重强调了，对迭代器思想的认识。
同时，对双向链表的封装到了一定程度。我们可以实现通用的链表和接口，并用其实现其他的数据结构。
218
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
