学习笔记：数据结构（一）

学习数据结构有几天了，简单回顾总结一下。目前有学到单链表， 双链表， 栈， 队列， 哈希表。单链表和双链表的区别在于指针域，双链表的指针域有两个指针，分别为prev， next ， prev指向它的上一个节点，next指向它的下一个节点。链表分为有头（头节点），无头（只有头指针）； 循环，非循环（最后一个节点的指针是否指向头，形成环），它们只是在访问和插入上很小的差异，实际上都差不多。单链表一般定义为

typedef int elem_t;
struct slist {
    elem_t data;
    struct slist *next;
};

双链表就是在单链表的基础上加上了一个指向前一个节点的指针，方便了同时向前向后遍历，相对单链表只能从头开始访问，提高了访问效率。双链表的定义一般为

typedef int elem_t;
struct dlist {
    elem_t data;
    struct dlist *prev;
    struct dlist *next;
};

链表的操作一般也就增删改查。

抽象数据类型（ADT）理解的不是很深，感觉就是一种封装， 里面有对象和方法，有点c++面类的感觉。下面是对双链表的一种封装。几个基本的方法。

struct node {
	struct node *prev;
	struct node *next;
	char data[1];   
/*gcc环境下有零长数组的概念，但其他编译器一般不支持，所以data给了1，给节点申请空间的时候加上你需要的数据域大小即可*/
};
struct dlist {
	struct node *head;
	void (*add)(struct dlist *, void *, size_t);
	void (*add_tail)(struct dlist *, void *, size_t);
	void (*for_each)(struct dlist *, void (*todo)(struct node *));
           /* 这里用到了回调函数，只是传了一个函数指针过来，定义则在你调用的地方即可。下面的cmp也是一样*/
	void (*for_each_rev)(struct dlist *, void (*todo)(struct node *));
	struct node *(*find)(struct dlist *, const void *, int (*cmp)(const struct node *, const void *));
	void (*del)(struct node *); 
};
void init(struct dlist *);
void destroy(struct dlist *);

方法的实现

/*头插*/
static void add(struct dlist *dlist, const void *data, size_t size)
{
	assert(dlist != NULL);
	assert(data != NULL);

	struct node *pa = (struct node *)malloc(sizeof(*pa)+size);
	assert(pa != NULL);

	memcpy(pa->data, data, size); /* 将数据拷贝到节点中 */

	pa->next = dlist->head->next;
	pa->prev = dlist->head;

	dlist->head->next = pa;
	pa->next->prev = pa;
}

static int is_empty(struct dlist *dlist)
{
	return (dlist->head->next == dlist->head) && (dlist->head->prev == dlist->head);
}


/* 尾插  */
static void add_tail(struct dlist *dlist, const void *data, size_t size)
{
	assert(dlist != NULL);
	assert(data != NULL);

	struct node *pa = (struct node *)malloc(sizeof(*pa) + size);
	assert(pa != NULL);
	
	memcpy(pa->data, data, size);

	pa->next = dlist->head;
	pa->prev = dlist->head->prev;

	dlist->head->prev = pa;
	pa->prev->next = pa;
}

/*  顺向遍历  */
static void for_each(struct dlist *dlist, void (*todo)(struct node *node))
{
	assert(dlist != NULL);
	struct node *cur = dlist->head->next;
	for(; cur != dlist->head; cur = cur->next)
		todo(cur);
}


/* 反向遍历  */
static void for_each_rev(struct dlist *dlist, void (*todo)(struct node *node))
{
	assert(dlist != NULL);
	struct node *cur = dlist->head->prev;
	for(; cur != dlist->head; cur = cur->prev)
		todo(cur);
}

/* 查找 */
static struct node *find(struct dlist *dlist, const void *key, int (*cmp)(const struct node *node, const void *key))
{
	static struct node *cur = NULL;
	if (cur == NULL) {
		cur = dlist->head;
	}
	for (cur = cur->next; cur != dlist->head; cur = cur->next) {
		if (cmp(cur, key)) {
			return cur;
		}
	}
	
	return NULL;
}

/* 删除 */
static void del(struct node *node)
{
	assert(node != NULL);
	
	node->prev->next = node->next;
	node->next->prev = node->prev;

	node->next = node;
	node->prev = node;
	free(node);

}


/*初始化函数 */
void dlist_init(struct dlist *dlist)
{
	assert(dlist != NULL);
	dlist->head = (struct node *)malloc(sizeof(*dlist->head));  /* 申请头节点空间 */
	assert(dlist->head != NULL);

	dlist->head->next = dlist->head;   /* 初始化头节点 */
	dlist->head->prev = dlist->head;
	dlist->head->data[0] = 0;

	dlist->add = add;      /* 挂载函数 */
	dlist->add_tail = add_tail;
	dlist->for_each = for_each;
	dlist->for_each_rev = for_each_rev;
	dlist->find = find;
	dlist->is_empty = is_empty;
	dlist->del = del;
}

void dlist_destroy(struct dlist *dlist)
{
	while(dlist->head->next != dlist->head)
		del(dlist->head->next);
	free(dlist->head);
}

栈（区别与内存中的栈）的特点是先进后出，队列则刚好相反，先进先出， 同现实中的排队一样。所以栈实际实现来说就是一种双链表，只是数据插入的方式只能是头插，访问的话也只能访问头节点的next节点。队列则是尾插。