Generic double circular linked list - 通用双向循环链表C语言实现
cheungmine
双向循环链表是计算机数据结构里面最基础的一种。我采用C语言实现，可以存储任何数据类型。这个双向链表（dlist）用来替换单向链表（list），可以获得更好的效率。
本文内容不提供任何保障，任何人在不声明版权所有的前提下本文内容可以被用于任何目的。
双向链表文件：
unitype.h
dlist.h
dlist.c
测试项目文件：
main.c
下面是全部的源代码：
/****************************************************************************************
* unitype.h *
* 2008-03-15 Last created by cheungmine. *
* All rights reserved by cheungmine. *
****************************************************************************************/
#ifndef UNITYPE_H__
#define UNITYPE_H__
/* Standard C header files included */
#include <stdio.h>
#include <string.h>
#include <assert.h>
/*============================================================================*/
typedef signed char int8_t;
typedef unsigned char uint8_t, uchar_t, byte_t;
typedef short int16_t;
typedef unsigned short uint16_t, word_t, ushort_t; /* sizeof (uint16) must == 2 */
typedef int int32_t;
typedef unsigned int uint32_t, dword_t; /* sizeof (uint32) must == 4 */
#if defined(_WIN32) || defined(_WINCE)
typedef __int64 int64_t;
typedef unsigned __int64 uint64, qword_t;
#else /* linux */
typedef long long int64_t;
typedef unsigned long long uint64_t, qword_t;
#endif
typedef float float32_t;
typedef double float64_t;
typedef int bool_t, lresult_t;
#define bool_true 1
#define bool_false 0
#define res_success 0
#define res_error -1
#define res_false 1
#ifndef IN
#define IN
#endif
#ifndef OUT
#define OUT
#endif
#ifndef INOUT
#define INOUT
#endif
#ifndef OPTIONAL
#define OPTIONAL
#endif
#ifdef _DEBUG
#include <stdarg.h>
static void DBG_TRACE(const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
vprintf(fmt, ap);
va_end(ap);
}
#else
static void DBG_TRACE(const char *fmt, ...){}
#endif
/*============================================================================*/
#endif /* UNITYPE_H__ */
/*******************************************************************************
* dlist.h *
* Generic double circular linked list - can hold any type data. *
* cheungmine *
* Mar. 22, 2008. All Rights Reserved. *
* *
* ........................................... *
* dlist | ______ ______ ______ ______ | *
* _________ +->| node | | node | | node | | node | | *
* |size/head|---->| next+->| next+->| next+->| next+---- *
* --------- --+prev |<-+prev |<-+prev |<-+prev |<-- *
* | ------ ------ ------ ------ | *
* | front/head back/tail | *
* | begin end | *
* |...........................................| *
* *
******************************************************************************/
#ifndef DLIST_H_INCLUDED__
#define DLIST_H_INCLUDED__
#ifdef __cplusplus
extern "C" {
#endif
#include "unitype.h"
#include <malloc.h>
/**
* dlist node type
*/
typedef struct _dlistnode_t
{
struct _dlistnode_t *_next;
struct _dlistnode_t *_prev;
union{
void *data;
struct _dlist_t *list;
const char *str;
int32_t val;
};
}dlistnode_t;
/**
* dlist type
*/
typedef struct _dlist_t
{
size_t _size; /* count of all nodes */
dlistnode_t *_head; /* point to the front node of list */
}dlist_t, *dlist_p;
/**
* A prototype of callbacke function called by:
* - dlist_destroy()
* - dlist_traverse()
* - dlist_nodes_free()
* 0 for no use
*/
typedef void(*pfunc_dlist_callback)(dlistnode_t* node, void *param);
/**
* A prototype of callback function called by:
* - dlist_sort()
* Returns:
* 0: a = b
* 1: a > b
* -1: a < b
*/
typedef int(*pfunc_dlist_compare_callback)(dlistnode_t* a, dlistnode_t* b, void *param);
/**
* A prototype example of free node data function implemented by caller:
*/
static void my_dlistnode_data_free(dlistnode_t *node, void *param)
{
printf(" free node: %d/n", node->val);
/* free(node->data); */
}
/**
* A prototype example of traverse implemented by caller:
*/
static void my_traverse_dlistnode_printf(dlistnode_t *node, void *param)
{
printf(" node: %ld/n", node->val);
}
/**
* An example of compare list node used by bubble sort ascend
*/
static int my_dlist_sort_nodes_ascend(dlistnode_t* a, dlistnode_t* b, void *param)
{
if (a->val > b->val)
return 1;
else if (a->val < b->val)
return -1;
else
return 0;
}
/**
* An example of compare list node used by bubble sort descend
*/
static int my_dlist_sort_nodes_descend(dlistnode_t* a, dlistnode_t* b, void *param)
{
if (a->val < b->val)
return 1;
else if (a->val > b->val)
return -1;
else
return 0;
}
/*===============================================================================
* *
* dlist public functions *
* *
*==============================================================================*/
/**
* Allocates a empty list from heap, this creates a new list
*/
dlist_t* dlist_create();
/**
* Clears a list and free all memory, the list cannot be used later
* Since the nodes data are allocated by caller, so caller MUST provide a callback
* function to free the node.
*/
void dlist_destroy(dlist_t *lst, pfunc_dlist_callback pfcbFreeNodeData, void *param);
/**
* Removes all nodes except for list itself
*/
void dlist_clear(dlist_t *lst, pfunc_dlist_callback pfcb, void *param);
/**
* Traverses a list, applied callback functionn for each node. So pfcbTraverseNode MUST be valid.
* If tail_to_head is bool_true, traverse is make from tail to head otherwise is from head to tail
*/
void dlist_traverse(dlist_t *lst, pfunc_dlist_callback pfcbTraverseNode, void *param, bool_t tail_to_head);
/**
* Creates a new node assigned with data, not allocates for data
*/
dlistnode_t* dlist_node_create(void* data);
/**
* Free the nodes from begin to end. If end node is 0, only free the begin node
*/
void dlist_nodes_free(dlistnode_t* begin_node, dlistnode_t* end_node, pfunc_dlist_callback pfcbFreeNodeData, void *param);
/**
* Calculate size of nodes from begin to end
*/
size_t dlist_nodes_size(dlistnode_t* begin_node, dlistnode_t* end_node);
/**
* Get head node of a list
*/
dlistnode_t* dlist_head_node(dlist_t *lst);
/**
* Get tail node of a list
*/
dlistnode_t* dlist_tail_node(dlist_t *lst);
/**
* Gets node by index: 0-based. 0 is head, -1 is tail.
* If index isnot a valid index (==-1 || >=0 && <size), return 0
*/
dlistnode_t* dlist_node_at(const dlist_t* lst, size_t index);
/**
* Appends a node to the back of list
*/
void dlist_push_back(dlist_t *lst, dlistnode_t *back_node);
/**
* Inserts a node as head of list
*/
void dlist_push_front(dlist_t *lst, dlistnode_t *front_node);
/**
* Removes the front node from a list and returns the node removed
*/
dlistnode_t* dlist_pop_front(dlist_t *lst);
/**
* Removes the back node from a list and returns the node removed
*/
dlistnode_t* dlist_pop_back(dlist_t *lst);
/**
* Inserts a node after the node into a list
*/
bool_t dlist_insert_after(dlist_t *lst, dlistnode_t *prev_node, dlistnode_t *ins_node);
/**
* Inserts a node before the node into a list
*/
bool_t dlist_insert_before(dlist_t *lst, dlistnode_t *back_node, dlistnode_t *ins_node);
/**
* Cut nodes from begin node to end node off the list, returns the node prior to
* the begin node cut off.
* Caller should free the nodes lead by begin node.
* When the begin and end nodes are the same one, it will only cut off that.
* When return 0 indicates list is empty (size==0)
* It can be explained that why not providing the way to cut off a single node here.
* NOTE: begin node must be prior to end node in sequence.
*
* dlistnode_t *begin = dlist_node_at(lst, 2);
* dlistnode_t *end = dlist_node_at(lst, 5);
* dlistnode_t *node = dlist_slice(lst, begin, end);
* dlist_nodes_free(begin, end, 0, 0);
*
* YOU CAN NOT APPLY dlist_nodes_free TO NODE WHICH IS NOT SLICED FROM LIST
* The following snippet is ILLEGITIMATE:
*
* dlistnode_t *begin = dlist_node_at(lst, 2);
* dlist_nodes_free(begin, begin, 0, 0);
*
* While the following snippet is correct:
* dlistnode_t *begin = dlist_node_at(lst, 2);
* dlist_slice(lst, begin, 0);
* dlist_nodes_free(begin, begin, 0, 0);
*/
dlistnode_t* dlist_slice(dlist_t* lst, dlistnode_t* begin, dlistnode_t* end);
/**
* Gets count of nodes in the list
*/
size_t dlist_size(const dlist_t* lst);
/**
* Appends the second list to the first list
*/
void dlist_concat(dlist_t *first, dlist_t *second);
/**
* Reverse list. For example the initial nodes are:0,1,2,3,
* after dlist_reverse will be: 3,2,1,0
*/
void dlist_reverse(dlist_t* lst);
/**
* Swap two nodes in list: front node must preceding the back node, only the situations below can be accepted:
* 1) a==b
* 2) a->b
* 3) a->...->b
* NOTE:
* b->a or b->...->a is unaccepted, that will cause an exception
*/
void dlist_swap_nodes(dlist_t* lst, dlistnode_t *ahead, dlistnode_t *back);
/**
* Bubble sort list nodes by ascend: 0,1,2,3,...,9
*/
void dlist_bubble_sort(dlist_t* lst, pfunc_dlist_compare_callback pfcbCompareNodes, void *param);
/**
* Merge sort src list to dst list. Caller can free src after merging.
* dst and src lists MUST be sorted by the same dlist_compare_callback as dlist_merge_sort
*/
void dlist_merge_sort(dlist_t* dst, dlist_t* src, pfunc_dlist_compare_callback pfcbCompareNodes, void *param);
#ifdef __cplusplus
}
#endif
#endif /* DLIST_H_INCLUDED__ */
/****************************************************************************************
* dlist.c *
* Generic sequential linked list node structure -- can hold any type data. *
* cheungmine *
* May. 22, 2008. All rights reserved. *
****************************************************************************************/
#include "dlist.h"
#include <assert.h>
#define DLIST_USE_TAIL_NODE(lst) (lst->_head->_prev)
#define DLIST_IS_HEAD_NODE(lst, node) (node==lst->_head)
#define DLIST_IS_TAIL_NODE(lst, node) (node->_next==lst->_head)
/*===============================================================================
* *
* dlist public functions *
* *
*==============================================================================*/
dlist_t* dlist_create()
{
dlist_t *dl = (dlist_t*) malloc (sizeof(dlist_t));
assert(dl);
dl->_size = 0;
dl->_head = 0;
return dl;
}
void dlist_destroy(dlist_t *lst, pfunc_dlist_callback pfcbFreeNodeData, void *param)
{
dlist_clear(lst, pfcbFreeNodeData, param);
free(lst);
}
void dlist_clear(dlist_t *lst, pfunc_dlist_callback pfcb, void *param)
{
dlistnode_t *node;
if (pfcb) {
while((node = dlist_pop_front(lst)) != 0){
(*pfcb)(node, param);
free(node);
}
}
else {
while((node = dlist_pop_front(lst)) != 0){
free(node);
}
}
assert (lst->_head==0 && lst->_size==0);
}
void dlist_traverse(dlist_t *lst, pfunc_dlist_callback pfcbTraverseNode, void *param, bool_t tail_to_head)
{
dlistnode_t* node;
assert(pfcbTraverseNode);
if (tail_to_head) {
node = DLIST_USE_TAIL_NODE(lst);
while (node) {
(*pfcbTraverseNode)(node, param);
if (DLIST_IS_HEAD_NODE(lst, node))
break;
node = node->_prev;
}
}
else {
node = lst->_head;
while (node) {
(*pfcbTraverseNode)(node, param);
if (DLIST_IS_TAIL_NODE(lst, node))
break;
node = node->_next;
}
}
}
dlistnode_t* dlist_pop_front(dlist_t *lst)
{
dlistnode_t *pop_node = 0;
if (lst->_head)
{
if (lst->_size==1){
pop_node = lst->_head;
pop_node->_next = pop_node->_prev = 0;
lst->_size = 0;
lst->_head = 0;
}
else{
assert(lst->_size>1);
pop_node = lst->_head;
lst->_head = pop_node->_next;
DLIST_USE_TAIL_NODE(lst) = pop_node->_prev;
DLIST_USE_TAIL_NODE(lst)->_next = lst->_head;
pop_node->_next = pop_node->_prev = 0;
lst->_size--;
}
}
assert(lst->_size >= 0);
return pop_node;
}
dlistnode_t* dlist_pop_back(dlist_t *lst)
{
dlistnode_t *pop_node = 0;
if (lst->_head)
{
if (lst->_size==1){
pop_node = lst->_head;
pop_node->_next = pop_node->_prev = 0;
lst->_size = 0;
lst->_head = 0;
}
else{
assert(lst->_size>1);
pop_node = DLIST_USE_TAIL_NODE(lst);
DLIST_USE_TAIL_NODE(lst) = pop_node->_prev;
assert(pop_node->_next==lst->_head);
pop_node->_prev->_next = pop_node->_next;
pop_node->_next = pop_node->_prev = 0;
lst->_size--;
}
}
assert(lst->_size >= 0);
return pop_node;
}
dlistnode_t* dlist_node_create(void* data)
{
dlistnode_t *node = (dlistnode_t*) malloc (sizeof(dlistnode_t));
assert(node);
node->_next = node->_prev = 0;
node->data = data;
return node;
}
void dlist_push_back(dlist_t *lst, dlistnode_t *back_node)
{
dlistnode_t *tail;
if (lst->_head) {
assert(lst->_size>0);
tail = DLIST_USE_TAIL_NODE(lst);
back_node->_prev = tail;
back_node->_next = tail->_next;
tail->_next = back_node;
lst->_head->_prev = back_node;
lst->_size++;
}
else {
assert(lst->_size==0);
lst->_head = back_node->_next = back_node->_prev = back_node;
lst->_size = 1;
}
}
void dlist_push_front(dlist_t *lst, dlistnode_t *front_node)
{
if (lst->_head) {
assert(lst->_size>0);
front_node->_next = lst->_head;
DLIST_USE_TAIL_NODE(lst)->_next = front_node;
front_node->_prev = DLIST_USE_TAIL_NODE(lst);
lst->_head->_prev = front_node;
lst->_head = front_node;
lst->_size++;
}
else {
assert(lst->_size==0);
lst->_head = front_node->_next = front_node->_prev = front_node;
lst->_size = 1;
}
}
void dlist_nodes_free(dlistnode_t* node, dlistnode_t* end_node, pfunc_dlist_callback pfcbFreeNodeData, void *param)
{
dlistnode_t* free_node;
while (node) {
free_node = node;
node = node->_next;
if (pfcbFreeNodeData)
(*pfcbFreeNodeData) (free_node, param);
free(free_node);
if (!end_node) /* only free node */
break;
if (node==end_node) {
if (pfcbFreeNodeData)
(*pfcbFreeNodeData) (node, param);
free(node);
break;
}
}
}
size_t dlist_size(const dlist_t* lst)
{
return lst->_size;
}
dlistnode_t* dlist_node_at(const dlist_t* lst, size_t index)
{
size_t i;
dlistnode_t *node;
assert(index==-1 || index==0 || index < lst->_size);
if (!lst->_head || index==0)
return lst->_head;
assert(lst->_head);
if (index==-1)
return lst->_head->_prev;
/* bad index */
if (index >= lst->_size)
return 0;
i = 0;
if (index <= lst->_size/2) {
/* To search from the head on */
node = lst->_head;
while (i < index) {
node = node->_next;
i++;
}
}
else {
/* It would be much quickly to search from the end on than the head */
node = DLIST_USE_TAIL_NODE(lst); /* tail node */
index = lst->_size - index - 1;
while (i < index) {
node = node->_prev;
i++;
}
}
return node;
}
void dlist_reverse(dlist_t* lst)
{
dlistnode_t *node;
dlistnode_t *next;
dlistnode_t *prev;
node = lst->_head;
while (node) {
next = node->_next;
prev = node->_prev;
node->_next = prev;
node->_prev = next;
prev = node;
node = next;
if (node==lst->_head) {
lst->_head = prev;
break;
}
}
}
size_t dlist_nodes_size(dlistnode_t* node, dlistnode_t* end_node)
{
size_t n = 0;
if (node==end_node || !end_node)
return 1;
while (node) {
n++;
node = node->_next;
if (node && node==end_node){
n++;
break;
}
}
return n;
}
dlistnode_t* dlist_slice(dlist_t* lst, dlistnode_t* begin, dlistnode_t* end)
{
dlistnode_t *n1, *n2; /* ...n1->begin->...->end->n2...*/
size_t c = dlist_nodes_size(begin, end);
if (c==0)
return lst->_head;
assert(lst->_head);
n1 = begin->_prev;
n2 = end->_next;
assert(n1 && n2);
n1->_next = n2;
n2->_prev = n1;
/* cut nodes off list */
begin->_prev = 0;
end->_next = 0;
if (lst->_head != begin) {
lst->_size -= c;
return n1;
}
else {
assert(lst->_head==begin);
if (DLIST_USE_TAIL_NODE(lst)==end) {
lst->_head = 0;
lst->_size = 0;
return 0;
}
else {
lst->_size -= c;
lst->_head = n1;
return n1;
}
}
return n1;
}
dlistnode_t* dlist_head_node(dlist_t *lst)
{
return lst->_head;
}
dlistnode_t* dlist_tail_node(dlist_t *lst)
{
return DLIST_USE_TAIL_NODE(lst);
}
bool_t dlist_insert_after(dlist_t *lst, dlistnode_t *prev_node, dlistnode_t *ins_node)
{
assert(lst);
if (!lst->_head) {
if (prev_node)
return bool_false;
dlist_push_front(lst, ins_node);
return bool_true;
}
else {
assert(lst->_head);
if (!prev_node)
return bool_false;
lst->_size++;
ins_node->_prev = prev_node;
ins_node->_next = prev_node->_next;
prev_node->_next->_prev = ins_node;
prev_node->_next = ins_node;
return bool_true;
}
}
bool_t dlist_insert_before(dlist_t *lst, dlistnode_t *back_node, dlistnode_t *ins_node)
{
assert(lst);
if (!lst->_head) {
if (back_node)
return bool_false;
dlist_push_back(lst, ins_node);
return bool_true;
}
else {
assert(lst->_head);
if (!back_node)
return bool_false;
if (lst->_head==back_node) {
dlist_push_front(lst, ins_node);
}
else {
lst->_size++;
ins_node->_next = back_node;
ins_node->_prev = back_node->_prev;
back_node->_prev->_next = ins_node;
back_node->_prev = ins_node;
}
return bool_true;
}
}
void dlist_concat(dlist_t *first, dlist_t *second)
{
assert(first && second);
if (first->_head) {
if (second->_head) {
dlistnode_t *second_tail = DLIST_USE_TAIL_NODE(second);
DLIST_USE_TAIL_NODE(first)->_next = second->_head;
DLIST_USE_TAIL_NODE(second)->_next = first->_head;
DLIST_USE_TAIL_NODE(second) = DLIST_USE_TAIL_NODE(first);
DLIST_USE_TAIL_NODE(first) = second_tail;
first->_size += second->_size;
second->_head = 0;
second->_size = 0;
}
}
else {
assert(!first->_head);
if (second->_head) {
first->_head = second->_head;
first->_size = second->_size;
second->_head = 0;
second->_size = 0;
}
}
}
void dlist_swap_nodes(dlist_t* lst, dlistnode_t *a, dlistnode_t *b)
{
dlistnode_t *p, *n;
assert(a && b);
if (a==b) {
/* [p]->[a|b]->[n] */
return;
}
else if (a->_next==b && b->_next==a) {
if (lst->_head==a)
lst->_head = b;
else
lst->_head = a;
}
else if (a->_next==b) {
/* [p]->[a]->[b]->[n] */
p = a->_prev;
n = b->_next;
p->_next = b;
b->_next = a;
a->_next = n;
n->_prev = a;
a->_prev = b;
b->_prev = p;
if (lst->_head==a) {
lst->_head = b;
}
}
else if (b->_next==a) {
/* [head:a]->...->[tail:b] */
p = b->_prev;
n = a->_next;
p->_next = a;
a->_next = b;
b->_next = n;
n->_prev = b;
b->_prev = a;
a->_prev = p;
if (lst->_head==a) {
lst->_head = b;
}
}
else {
/* [p]->[a]->[a1...b1]->[b]->[n] */
dlistnode_t *a1, *b1;
p = a->_prev;
n = b->_next;
a1 = a->_next;
b1 = b->_prev;
p->_next = b;
b->_next = a1;
b1->_next = a;
a->_next = n;
a1->_prev = b;
b->_prev = p;
n->_prev = a;
a->_prev = b1;
}
}
void dlist_sort_ascend(dlist_t* lst, pfunc_dlist_compare_callback pfcbCompareNodes, void *param)
{
int flag = 1;
dlistnode_t *first = 0;
dlistnode_t *second = 0;
dlistnode_t *last_sink = 0;
first = lst->_head;
while (flag==1) {
flag = 0;
while(first) {
second = first->_next;
assert(second);
if (second==lst->_head)
break;
if (second==last_sink)
break;
if (pfcbCompareNodes) {
if ((*pfcbCompareNodes)(first, second, param) > 0) {
flag = 1;
dlist_swap_nodes(lst, first, second);
last_sink = first;
}
}
else if (first->val > second->val) {
flag = 1;
dlist_swap_nodes(lst, first, second);
last_sink = first;
}
first = second;
}
}
}
void dlist_bubble_sort(dlist_t* lst, pfunc_dlist_compare_callback pfcbCompareNodes, void *param)
{
int flag = 1;
dlistnode_t *first = 0;
dlistnode_t *second = 0;
dlistnode_t *last_sink = 0;
while (flag==1) {
flag = 0;
first = lst->_head;
while(first) {
second = first->_next;
assert(second);
if (second==lst->_head)
break;
if (second==last_sink)
break;
if (pfcbCompareNodes) {
if ((*pfcbCompareNodes)(first, second, param) > 0) {
flag = 1;
dlist_swap_nodes(lst, first, second);
last_sink = first;
}
else
first = second;
}
else {
if (first->val > second->val) {
flag = 1;
dlist_swap_nodes(lst, first, second);
last_sink = first;
}
else
first = second;
}
}
}
}
void dlist_merge_sort(dlist_t* dst, dlist_t* src, pfunc_dlist_compare_callback pfcbCompareNodes, void *param)
{
dlistnode_t *dst_node;
dlistnode_t *src_node;
assert(dst && src);
if (!dst->_head) {
dlist_concat(dst, src);
return;
}
dst_node = dst->_head;
src_node = src->_head;
while (src_node) {
if (pfcbCompareNodes) {
if ((*pfcbCompareNodes)(dst_node, src_node, 0) > 0) {
dlist_insert_before(dst, dst_node, dlist_pop_front(src));
src_node = src->_head;
}
else {
dst_node = dst_node->_next;
if (dst_node==dst->_head) {
dlist_concat(dst, src);
return;
}
}
}
else {
if (dst_node->val > src_node->val) {
dlist_insert_before(dst, dst_node, dlist_pop_front(src));
src_node = src->_head;
}
else {
dst_node = dst_node->_next;
if (dst_node==dst->_head) {
dlist_concat(dst, src);
return;
}
}
}
}
}
测试文件：
// Test for dlist
// main.c
// by cheungmine
//
/* Detecting memory leaks only for windows .
* Place the following snippet where leak to be tested:
#if defined(_CRTDBG_MAP_ALLOC)
_CrtDumpMemoryLeaks();
#endif
*/
#if defined(WIN32) && defined(_DEBUG)
#ifndef _CRTDBG_MAP_ALLOC
#pragma message( __FILE__": _CRTDBG_MAP_ALLOC defined only for DEBUG on Win32." )
#define _CRTDBG_MAP_ALLOC
#include<stdlib.h>
#include<crtdbg.h>
#endif
#endif
#include "../dlist.h"
void test_reverse();
void test_concat();
void test_slice();
void test_insert();
void test_swap();
void test_more_swap();
void test_sort_ascend();
void test_sort_descend();
void test_merge_sort();
///
int main()
{
// test_reverse();
// test_concat();
// test_slice();
// test_insert();
// test_swap();
// test_more_swap();
// test_sort_ascend();
// test_sort_descend();
test_merge_sort();
return 0;
}
///
void test_reverse()
{
//
// dlist_create
// dlist_traverse
// dlist_reverse
// dlist_destroy
//
int i;
dlistnode_t *nod;
dlist_p A;
printf("dlist_create A ok/n");
A = dlist_create();
for (i=0; i<10; i++){
nod = dlist_node_create(i);
dlist_push_back(A, nod);
}
printf("dlist_traverse A (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_reverse(A);
printf("dlist_traverse A (%d nodes) after dlist_reverse called:/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_destroy(A, 0, 0);
printf("dlist_destroy/n");
#if defined(_CRTDBG_MAP_ALLOC)
_CrtDumpMemoryLeaks();
#endif
}
void test_concat()
{
//
// dlist_create
// dlist_traverse
// dlist_concat
// dlist_destroy
//
int i;
dlistnode_t *nod;
dlist_p A, B;
A = dlist_create();
for (i=0; i<5; i++){
nod = dlist_node_create(i);
dlist_push_back(A, nod);
}
printf("dlist_traverse A (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
B = dlist_create();
for (i=0; i<4; i++){
nod = dlist_node_create(i+10);
dlist_push_back(B, nod);
}
printf("dlist_traverse B (%d nodes):/n", dlist_size(B));
dlist_traverse(B, my_traverse_dlistnode_printf, 0, 0);
dlist_concat(A, B);
printf("dlist_traverse B after concat to A (%d nodes):/n", dlist_size(B));
dlist_traverse(B, my_traverse_dlistnode_printf, 0, 0);
dlist_destroy(B, 0, 0);
printf("dlist_traverse A after dlist_concat with B (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_destroy(A, 0, 0);
#if defined(_CRTDBG_MAP_ALLOC)
_CrtDumpMemoryLeaks();
#endif
}
void test_slice()
{
//
// dlist_node_at
// dlist_slice
//
int i;
dlistnode_t *nod;
dlist_p A;
A = dlist_create();
for (i=0; i<10; i++){
nod = dlist_node_create(i);
dlist_push_back(A, nod);
}
printf("dlist_traverse A (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
nod = dlist_node_create(11);
dlist_push_front(A, nod);
nod = dlist_node_create(10);
dlist_push_front(A, nod);
nod = dlist_node_create(12);
dlist_push_back(A, nod);
nod = dlist_node_at(A, 0);
printf("dlist_node_at 0: %d/n", nod->val);
nod = dlist_node_at(A, 1);
printf("dlist_node_at 1: %d/n", nod->val);
nod = dlist_node_at(A, -1);
printf("dlist_node_at -1: %d/n", nod->val);
printf("dlist_traverse A after push nodes(%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
nod = dlist_node_at(A, 1);
dlist_slice(A, nod, nod);
dlist_nodes_free(nod, 0, 0, 0);
printf("dlist_traverse A after dlist_slice(%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_destroy(A, 0, 0);
#if defined(_CRTDBG_MAP_ALLOC)
_CrtDumpMemoryLeaks();
#endif
}
void test_insert()
{
//
// dlist_head_node
// dlist_tail_node
// dlist_insert_after
// dlist_insert_before
//
int i;
dlistnode_t *nod;
dlist_p A;
A = dlist_create();
for (i=0; i<10; i++){
nod = dlist_node_create(i);
dlist_push_back(A, nod);
}
printf("dlist_traverse A (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
nod = dlist_node_create(100);
dlist_insert_after(A, dlist_head_node(A), nod);
nod = dlist_node_create(200);
dlist_insert_after(A, dlist_tail_node(A), nod);
nod = dlist_node_create(300);
dlist_insert_before(A, dlist_head_node(A), nod);
nod = dlist_node_create(400);
dlist_insert_after(A, dlist_tail_node(A), nod);
nod = dlist_node_create(350);
dlist_insert_before(A, dlist_tail_node(A), nod);
nod = dlist_node_create(99);
dlist_insert_after(A, dlist_node_at(A, 5), nod);
nod = dlist_node_create(60);
dlist_insert_before(A, dlist_node_at(A, 6), nod);
nod = dlist_pop_back(A);
dlist_nodes_free(nod, nod, 0, 0);
nod = dlist_pop_front(A);
dlist_nodes_free(nod, 0, 0, 0);
printf("dlist_traverse A after insertion (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_destroy(A, 0, 0);
#if defined(_CRTDBG_MAP_ALLOC)
_CrtDumpMemoryLeaks();
#endif
}
void test_swap()
{
//
// dlist_swap_nodes
//
int i;
dlistnode_t *nod;
dlist_p A;
A = dlist_create();
for (i=0; i<10; i++){
nod = dlist_node_create(i);
dlist_push_back(A, nod);
}
printf("dlist_traverse A (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_swap_nodes(A, dlist_node_at(A, 3), dlist_node_at(A, 4));
printf("dlist_traverse A after swap 3 with 4 (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_swap_nodes(A, dlist_node_at(A, 3), dlist_node_at(A, 4));
printf("dlist_traverse A after swap 3 with 4 (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_swap_nodes(A, dlist_node_at(A, 3), dlist_node_at(A, 7));
printf("dlist_traverse A after swap 3 with 7 (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_swap_nodes(A, dlist_node_at(A, 3), dlist_node_at(A, 7));
printf("dlist_traverse A after swap 3 with 7 (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_swap_nodes(A, dlist_node_at(A, 7), dlist_node_at(A, 9));
printf("dlist_traverse A after swap 7 with 9 (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_swap_nodes(A, dlist_node_at(A, 7), dlist_node_at(A, 9));
printf("dlist_traverse A after swap 7 with 9 (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_swap_nodes(A, dlist_node_at(A, 0), dlist_node_at(A, -1));
printf("dlist_traverse A after swap head with tail (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_swap_nodes(A, dlist_node_at(A, 0), dlist_node_at(A, -1));
printf("dlist_traverse A after swap head with tail (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_swap_nodes(A, dlist_node_at(A, -1)->_prev, dlist_node_at(A, -1));
printf("dlist_traverse A after swap pre-tail with tail (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_swap_nodes(A, dlist_node_at(A, 0), dlist_node_at(A, 0)->_next);
printf("dlist_traverse A after swap head with post-head (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_destroy(A, 0, 0);
#if defined(_CRTDBG_MAP_ALLOC)
_CrtDumpMemoryLeaks();
#endif
}
void test_more_swap()
{
//
// dlist_clear
// dlist_swap_nodes
//
int i;
dlistnode_t *nod;
dlist_p A;
A = dlist_create();
for (i=0; i<2; i++){
nod = dlist_node_create(i);
dlist_push_back(A, nod);
}
printf("dlist_traverse A (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_swap_nodes(A, dlist_head_node(A), dlist_tail_node(A));
printf("dlist_traverse A after dlist_swap_nodes (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
/* Below is a bad call for we suppose that dlist_swap_nodes requires the swapped nodes: ahead precedes back */
dlist_swap_nodes(A, dlist_tail_node(A), dlist_head_node(A));
printf("dlist_traverse A after dlist_swap_nodes (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_clear(A, 0, 0);
for (i=0; i<3; i++){
nod = dlist_node_create(i);
dlist_push_back(A, nod);
}
// 0,1,2
printf("dlist_traverse A (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
// 1,0,2
dlist_swap_nodes(A, dlist_node_at(A, 0), dlist_node_at(A, 1));
printf("dlist_traverse A after dlist_swap_nodes (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
// 1,2,0
dlist_swap_nodes(A, dlist_node_at(A, 1), dlist_node_at(A, 2));
printf("dlist_traverse A after dlist_swap_nodes (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
// 1,0,2
dlist_swap_nodes(A, dlist_node_at(A, 1), dlist_node_at(A, 2));
printf("dlist_traverse A after dlist_swap_nodes (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
// 0,1,2
dlist_swap_nodes(A, dlist_node_at(A, 0), dlist_node_at(A, 1));
printf("dlist_traverse A after dlist_swap_nodes (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_destroy(A, 0, 0);
#if defined(_CRTDBG_MAP_ALLOC)
_CrtDumpMemoryLeaks();
#endif
}
void test_sort_ascend()
{
//
// dlist_bubble_sort
//
int i;
dlistnode_t *nod;
dlist_p A;
int v[] = {2,46,5,17,1,2,3,99,12,56,66,21};
A = dlist_create();
for (i=0; i<sizeof(v)/sizeof(v[0]); i++){
nod = dlist_node_create(v[i]);
dlist_push_back(A, nod);
}
printf("dlist_traverse A (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_bubble_sort(A, 0, 0);
printf("dlist_traverse A after dlist_bubble_sort (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_destroy(A, 0, 0);
#if defined(_CRTDBG_MAP_ALLOC)
_CrtDumpMemoryLeaks();
#endif
}
void test_sort_descend()
{
//
// dlist_bubble_sort
//
int i;
dlistnode_t *nod;
dlist_p A;
int v[] = {2,46,5,17,1,2,3,99,12,56,66,21};
A = dlist_create();
for (i=0; i<sizeof(v)/sizeof(v[0]); i++){
nod = dlist_node_create(v[i]);
dlist_push_back(A, nod);
}
printf("dlist_traverse A (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_bubble_sort(A, my_dlist_sort_nodes_descend, 0);
printf("dlist_traverse A after dlist_bubble_sort (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
dlist_destroy(A, 0, 0);
#if defined(_CRTDBG_MAP_ALLOC)
_CrtDumpMemoryLeaks();
#endif
}
void test_merge_sort()
{
//
// dlist_bubble_sort
// dlist_merge_sort
//
int i;
dlistnode_t *nod;
dlist_p A, B;
int vA[] = {2,46,5,17,1,2,3,99,12,56,66,21};
int vB[] = {67,54,32,97,11,12,23,9,112,46,37,22};
// create list A
A = dlist_create();
for (i=0; i<sizeof(vA)/sizeof(vA[0]); i++){
nod = dlist_node_create(vA[i]);
dlist_push_back(A, nod);
}
printf("dlist_traverse A (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
// create list B
B = dlist_create();
for (i=0; i<sizeof(vB)/sizeof(vB[0]); i++){
nod = dlist_node_create(vB[i]);
dlist_push_back(B, nod);
}
printf("dlist_traverse B (%d nodes):/n", dlist_size(B));
dlist_traverse(B, my_traverse_dlistnode_printf, 0, 0);
// sort A and B with same compare function
dlist_bubble_sort(A, my_dlist_sort_nodes_ascend, 0);
dlist_bubble_sort(B, my_dlist_sort_nodes_ascend, 0);
printf("dlist_traverse A after dlist_bubble_sort (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
printf("dlist_traverse B after dlist_bubble_sort (%d nodes):/n", dlist_size(B));
dlist_traverse(B, my_traverse_dlistnode_printf, 0, 0);
// merge sort A with B
dlist_merge_sort(A, B, my_dlist_sort_nodes_ascend, 0);
printf("dlist_traverse A after dlist_merge_sort (%d nodes):/n", dlist_size(A));
dlist_traverse(A, my_traverse_dlistnode_printf, 0, 0);
printf("dlist_traverse B after dlist_merge_sort (%d nodes):/n", dlist_size(B));
dlist_traverse(B, my_traverse_dlistnode_printf, 0, 0);
dlist_destroy(B, 0, 0);
dlist_destroy(A, 0, 0);
#if defined(_CRTDBG_MAP_ALLOC)
_CrtDumpMemoryLeaks();
#endif
}
