单链表

单向链表的实现

---

创建3个文件：listSingleLinked.h、listSingleLinked.c、listSingleLinkedTest.c

---

listSingleLinked.h

#ifndef SINGLE_LINKED_H_
#define SINGLE_LINKED_H_

#ifdef __GNUC__
	#define DEPRECATED __attribute__( (deprecated) )
#elif defined(_MSC_VER)
	#define DEPRECATED __declspec( deprecated )
#else
	#define DEPRECATED
#endif

#ifndef PTOI
	#define PTOI( p ) ((int32_t)(int64_t)(p))
#endif
#ifndef ITOP
	#define ITOP( i ) ((void *)(int64_t)(i))
#endif

#define ADT SingleLinked

#define addFirstSingleLinked    addHeadSingleLinked
#define addLastSingleLinked     addTailSingleLinked
#define setFirstSingleLinked    setHeadSingleLinked
#define setLastSingleLinked     setTailSingleLinked
#define removeFirstSingleLinked removeHeadSingleLinked
#define removeLastSingleLinked  removeTailSingleLinked
#define getFirstSingleLinked    getHeadSingleLinked
#define getLastSingleLinked     getTailSingleLinked


// 功能: a与b的比较过程.
// 参数: a, b.
// 返回: a>b返回正数, a<b返回负数, 否则返回0.
// 注意: a!=NULL且b=NULL时返回正数, a=NULL且b!=NULL时返回负数, a=b=NULL时返回0.
typedef int ( CompareFunc )( const void *a, const void *b );

typedef struct SingleLinked SingleLinked;

// 功能: 创建新的链表.
// 参数: 无.
// 返回: 新的链表.
// 注意: 当 内存分配失败 时将错误退出程序.
extern ADT *newSingleLinked( void );

// 功能: 将用户数据加入到链表的指定索引位置.
// 参数: list(链表对象的指针), index(索引位置), data(用户数据).
// 返回: 被加入到链表的用户数据.
// 注意: 索引位置从0开始计算.
//       当 list=NULL 或 index<0 或 index>=表尾索引 时将错误退出程序.
extern void *addSingleLinked( ADT *list, int32_t index, void *data );

// 功能: 将用户数据加入到链表的表头.
// 参数: list(链表对象的指针), data(用户数据).
// 返回: 被加入到链表表头的用户数据.
// 注意: 当 list=NULL 时将错误退出程序.
extern void *addHeadSingleLinked( ADT *list, void *data );

// 功能: 将用户数据加入到链表的表尾.
// 参数: list(链表对象的指针), data(用户数据).
// 返回: 被加入到链表表尾的用户数据.
// 注意: 当 list=NULL 时将错误退出程序.
extern void *addTailSingleLinked( ADT *list, void *data );

// 功能: 设置链表的指定索引位置的用户数据.
// 参数: list(链表对象的指针), index(索引位置), data(新用户数据).
// 返回: 被加入到链表的用户数据.
// 注意: 索引位置从0开始计算.
//       当 list=NULL 时将错误退出程序.
//       当 index<0 或 index>表尾索引 时分别新建链表表头或表尾用来放置 data.
extern void *setSingleLinked( ADT *list, int32_t index, void *data );

// 功能: 设置链表表头的用户数据.
// 参数: list(链表对象的指针), data(新用户数据).
// 返回: 被加入到链表表头的用户数据.
// 注意: 当 list=NULL 时将错误退出程序.
//       是 空链表状态 时新建链表表头用来放置 data.
extern void *setHeadSingleLinked( ADT *list, void *data );

// 功能: 设置链表表尾的用户数据.
// 参数: list(链表对象的指针), data(新用户数据).
// 返回: 被加入到链表表尾的用户数据.
// 注意: 当 list=NULL 时将错误退出程序.
//       是 空链表状态 时新建链表表尾用来放置 data.
extern void *setTailSingleLinked( ADT *list, void *data );

// 功能: 移除链表指定索引位置的用户数据.
// 参数: list(链表对象的指针), index(索引位置).
// 返回: 被移除的用户数据.
// 注意: 索引位置从0开始计算.
//       当 list=NULL 或 index<0 或 index>表尾索引 或 是空链表状态 时将错误退出程序.
extern void *removeSingleLinked( ADT *list, int32_t index );

// 功能: 移除链表表头的用户数据.
// 参数: list(链表对象的指针).
// 返回: 被移除的链表表头的用户数据.
// 注意: 当 list=NULL 或 是空链表状态 时将错误退出程序.
extern void *removeHeadSingleLinked( ADT *list );

// 功能: 移除链表表尾的用户数据.
// 参数: list(链表对象的指针).
// 返回: 被移除的链表表头的用户数据.
// 注意: 当 list=NULL 或 是空链表状态 时将错误退出程序.
extern void *removeTailSingleLinked( ADT *list );

// 功能: 偷看链表指定索引位置的用户数据.
// 参数: list(链表对象的指针), index(索引位置).
// 返回: 链表指定索引位置的用户数据.
// 注意: 索引位置从0开始计算.
//       当 list=NULL 或 index<0 或 index>表尾索引 或 是空链表状态 时将错误退出程序.
extern void *getSingleLinked( ADT *list, int32_t index );

// 功能: 偷看链表表头的用户数据.
// 参数: list(链表对象的指针).
// 返回: 链表表头的用户数据.
// 注意: 当 list=NULL 或 是空链表状态 时将错误退出程序.
extern void *getHeadSingleLinked( ADT *list );

// 功能: 偷看链表表尾的用户数据.
// 参数: list(链表对象的指针).
// 返回: 链表表尾的用户数据.
// 注意: 当 list=NULL 或 是空链表状态 时将错误退出程序.
extern void *getTailSingleLinked( ADT *list );

// 功能: 链表中所有用户数据中是否包含了data.
// 参数: list(链表对象的指针), data(需查找的用户数据), cmp(比较函数的指针).
// 返回: 包含data返回1, 否则返回0.
// 注意: 当 list=NULL 或 cmp=NULL 时将错误退出程序.
extern int existSingleLinked( ADT *list, void *data, CompareFunc *cmp );

// 功能: 从链表表头至链表表尾方向查找data.
// 参数: list(链表对象的指针), data(需查找的用户数据), cmp(比较函数的指针).
// 返回: 包含data, 返回data所在位置, 否则返回-1.
// 注意: 当 list=NULL 或 cmpNULL 时将错误退出程序.
extern int32_t findSingleLinked( ADT *list, void *data, CompareFunc *cmp );

// 功能: 从链表表尾至链表表头方向查找data.
// 参数: list(链表对象的指针), data(需查找的用户数据), cmp(比较函数的指针).
// 返回: 包含data, 返回data所在位置, 否则返回-1.
// 注意: 当 list=NULL 或 cmp=NULL 时将错误退出程序.
extern int32_t findTailSingleLinked( ADT *list, void *data, CompareFunc *cmp );

// 功能: 链表实际已使用大小.
// 参数: list(链表对象的指针).
// 返回: 链表实际已使用大小.
// 注意: 当 list=NULL 时将错误退出程序.
extern int32_t sizeSingleLinked( ADT *list );

// 功能: 空链表状态.
// 参数: list(链表对象的指针).
// 返回: 是空链表返回1, 否则返回0.
// 注意: 当 list=NULL 时将错误退出程序.
extern int emptySingleLinked( ADT *list );

// 功能: 反转链表.
// 参数: list(链表对象的指针).
// 返回: 无.
// 注意: 当 list=NULL 时将错误退出程序.
extern void reversalSingleLinked( ADT *list );

// 功能: 满链表状态.
// 参数: list(链表对象的指针).
// 返回: 是满链表返回1, 否则返回0.
// 注意: 当 list=NULL 时将错误退出程序.
// 被弃用的函数.
extern DEPRECATED int fullSingleLinked( ADT *list );

// 功能: 链表最大容量.
// 参数: list(链表对象的指针).
// 返回: 链表最大容量.
// 注意: 当 list=NULL 时将错误退出程序.
// 被弃用的函数.
extern DEPRECATED int32_t capacitySingleLinked( ADT *list );

// 功能: 清空链表.
// 参数: list(链表对象的指针).
// 返回: 无.
// 注意: 当 list=NULL 时将错误退出程序.
extern void clearSingleLinked( ADT *list );

// 功能: 销毁链表.
// 参数: list(存放链表对象的指针的指针).
// 返回: 无.
// 注意: 当 list=NULL 时将错误退出程序.
extern void delSingleLinked( ADT **list );

#undef ADT

#endif

listSingleLinked.c

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include "listSingleLinked.h"


// 功能: 打印错误信息后就错误退出程序.
// 参数: expression(错误判断表达式), message(需打印的错误信息).
// 返回: 无.
// 注意: 当表达式 expression 为真时, 才触发.
#define ERROR_EXIT( expression, message )                                    
if( (expression) ) {                                                         
	fprintf( stderr, "
error location: file = %s, func = %s, line = %u.
", 
	                 __FILE__, __func__, __LINE__ );                         
	fprintf( stderr, "error  message: %s%s.
a",                            
	                 (message) != NULL ? (message) : __func__,               
	                 (message) != NULL ? "" : " function error" );           
	exit( EXIT_FAILURE );                                                    
}

// 功能: 分配内存, 与 malloc 功能一样.
// 参数: p(传入传出参数), size(字节).
// 返回: 无, 实际通过参数p进行传出.
// 注意: 当 内存分配失败 时将错误退出程序.
#define NEW( p, size ) ({                              
	ERROR_EXIT( (p) == NULL, "NullPointerException" ); 
	*(p) = malloc( (size) );                           
	ERROR_EXIT( *(p) == NULL, "OutOfMemoryError" );    
})

// 功能: 分配内存并把每个字节置0, 与 calloc 功能一样.
// 参数: p(传入传出参数), size(字节), n(数量).
// 返回: 无, 实际通过参数p进行传出.
// 注意: 当 内存分配失败 时将错误退出程序.
#define NEW0( p, nE, sizeofE ) ({                             
	ERROR_EXIT( (p) == NULL, "NullPointerException" );        
	ERROR_EXIT( (nE) < 0, "Parameter 'nE' Error" );           
	ERROR_EXIT( (sizeofE) < 0, "Parameter 'sizeofE' Error" ); 
	*(p) = calloc( nE, sizeofE );                             
	ERROR_EXIT( *(p) == NULL, "OutOfMemoryError" );           
})

#define DEL( p ) ({                     
	if( (p) != NULL && *(p) != NULL ) { 
		free( *(p) );                   
		*(p) = NULL;                    
	}                                   
})

#define ADT SingleLinked


typedef struct NodeSingleLinked {
	void *data;
	struct NodeSingleLinked *next;
} Node;

struct SingleLinked {
	struct NodeSingleLinked *prev;
	int32_t size;
	struct NodeSingleLinked *next;
};


ADT *newSingleLinked( void ) {
	ADT *list = NULL;

	NEW( &list, sizeof(*list) );
	list->size = 0;
	list->prev = NULL;
	list->next = NULL;

	return list;
}

void *addSingleLinked( ADT *list, int32_t index, void *data ) {
	Node *node = NULL, *pre = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	ERROR_EXIT( index < 0 || index > list->size, "IndexOutOfBoundsException" );
	NEW( &node, sizeof(*node) );
	node->data = data;
	for( pre = list->next; --index > 0; pre = pre->next ) {}
	if( index < 0 ) { // 插入首结点.
		node->next = list->next;
		list->next = node;
	} else {
		node->next = pre->next;
		pre->next = node;
	}
	list->prev = !list->prev || !node->next ? node : list->prev;
	++list->size;

	return data;
}

void *addHeadSingleLinked( ADT *list, void *data ) {
	Node *node = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	NEW( &node, sizeof(*node) );
	node->data = data;
	node->next = list->next;
	list->next = node;
	list->prev = !list->prev ? node : list->prev;
	++list->size;

	return data;
}

void *addTailSingleLinked( ADT *list, void *data ) {
	Node *node = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	NEW( &node, sizeof(*node) );
	node->data = data;
	node->next = NULL;
	if( list->prev != NULL ) {
		list->prev->next = node;
	}
	list->next = !list->next ? node : list->next;
	list->prev = node;
	++list->size;

	return data;
}

void *setSingleLinked( ADT *list, int32_t index, void *data ) {
	ERROR_EXIT( list == NULL, "NullPointerException" );

	return data;
}

void *setHeadSingleLinked( ADT *list, void *data ) {
	ERROR_EXIT( list == NULL, "NullPointerException" );

	return data;
}

void *setTailSingleLinked( ADT *list, void *data ) {
	ERROR_EXIT( list == NULL, "NullPointerException" );

	return data;
}

void *removeSingleLinked( ADT *list, int32_t index ) {
	void *data = NULL;
	Node *node = NULL, *pre = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	ERROR_EXIT( index < 0 || index >= list->size, "IndexOutOfBoundsException" );
	for( pre = list->next; --index > 0; pre = pre->next ) {}
	node = index < 0 ? pre : pre->next; // index小于0, 说明移除第一个(即索引0)元素.
	pre->next = node->next;
	list->prev = list->prev != node ? list->prev : pre;
	list->prev = list->size > 1 ? list->prev : NULL;
	list->next = list->next != node ? list->next : node->next;
	--list->size;
	data = node->data;
	DEL( &node );

	return data;
}

void *removeHeadSingleLinked( ADT *list ) {
	void *data = NULL;
	Node *node = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	ERROR_EXIT( list->size < 1, "EmptyContainerError" );
	node = list->next;
	list->prev = list->size > 1 ? list->prev : NULL; // 只有一个节点时.
	list->next = node->next;
	--list->size;
	data = node->data;
	DEL( &node );

	return data;
}

void *removeTailSingleLinked( ADT *list ) {
	void *data = NULL;
	Node *node = NULL, *pre = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	ERROR_EXIT( list->size < 1, "EmptyContainerError" );
	node = list->prev;
	for( pre = list->next; pre != node && pre->next != node; pre = pre->next ) {}
	pre->next = node->next;
	list->prev = node != list->next ? pre : NULL;
	list->next = node != list->next ? list->next : NULL; // 头结点即尾节点.
	--list->size;
	data = node->data;
	DEL( &node );

	return data;
}

void *getSingleLinked( ADT *list, int32_t index ) {
	Node *node = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	ERROR_EXIT( index < 0 || index >= list->size, "IndexOutOfBoundsException" );
	for( node = list->next; --index >= 0; node = node->next ) {}

	return node->data;
}

void *getHeadSingleLinked( ADT *list ) {
	ERROR_EXIT( list == NULL, "NullPointerException" );
	ERROR_EXIT( list->size < 1, "EmptyContainerError" );

	return list->next->data;
}

void *getTailSingleLinked( ADT *list ) {
	ERROR_EXIT( list == NULL, "NullPointerException" );
	ERROR_EXIT( list->size < 1, "EmptyContainerError" );

	return list->prev->data;
}

int existSingleLinked( ADT *list, void *data, CompareFunc *cmp ) {
	Node *node = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	ERROR_EXIT( !cmp, "NullPointerException" );
	for( node = list->next; node; node = node->next ) {
		if( !cmp( node->data, data ) ) {
			return 1;
		}
	}

	return -1;
}

int32_t findSingleLinked( ADT *list, void *data, CompareFunc *cmp ) {
	int32_t i = 0;
	Node *node = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	ERROR_EXIT( !cmp, "NullPointerException" );
	for( node = list->next; node; node = node->next ) {
		if( !cmp( node->data, data ) ) {
			return i;
		}
		++i;
	}

	return -1;
}

int32_t findTailSingleLinked( ADT *list, void *data, CompareFunc *cmp ) {
	int32_t i = 0;
	Node *p1 = NULL, *p2 = NULL, *p3 = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	ERROR_EXIT( !cmp, "NullPointerException" );
	for( p2 = list->next; p2; p2 = p3 ) { // 反转链表.
		p3 = p2->next;
		p2->next = p1;
		p1 = p2;
	}
	for( p2 = p1; p2; p2 = p2->next ) {
		if( cmp( p2->data, data ) ) {
			break;
		}
		++i;
	}
	for( p2 = p1, p1 = NULL; p2; p2 = p3 ) { // 再次反转链表进行还原.
		p3 = p2->next;
		p2->next = p1;
		p1 = p2;
	}

	return list->size - 1 - i;
}

int32_t sizeSingleLinked( ADT *list ) {
	ERROR_EXIT( list == NULL, "NullPointerException" );

	return list->size;
}

int emptySingleLinked( ADT *list ) {
	ERROR_EXIT( list == NULL, "NullPointerException" );

	return list->size < 1;
}

void reversalSingleLinked( ADT *list ) {
	Node *p1 = NULL, *p2 = NULL, *p3 = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	list->prev = list->next;
	for( p2 = list->next; p2; p2 = p3 ) { // 反转链表.
		p3 = p2->next;
		p2->next = p1;
		p1 = p2;
	}
	list->next = p1;
}

void clearSingleLinked( ADT *list ) {
	Node *c = NULL, *t = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	for( c = list->next; c != NULL; c = t ) {
		t = c->next;
		DEL( &c );
	}
	list->size = 0;
	list->prev = NULL;
	list->next = NULL;
}

void delSingleLinked( ADT **list ) {
	Node *c = NULL, *t = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	for( c = (*list)->next; c != NULL; c = t ) {
		t = c->next;
		DEL( &c );
	}
	DEL( list );
}

void addressSingleLinked( ADT *list ) {
	Node *node = NULL;

	ERROR_EXIT( list == NULL, "NullPointerException" );
	printf( "[" );
	for( node = list->next; node; node = node->next ) {
		printf( "%5d%s", *(int32_t *) node->data, !node->next ? "" : "->" );
	}
	printf( "]
" );
	printf( "list->next = %d, ", !list->next ? INT_MIN : *(int32_t *) list->next->data );
	printf( "list->prev = %d
", !list->prev ? INT_MIN : *(int32_t *) list->prev->data );
}

listSingleLinkedTest.c

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>
#include "listSingleLinked.h"


// 功能: 对数组的某一区间内的元素值进行随机化.
// 参数: a(数组首地址), left(左闭区间), right(右闭区间), v(最大随机值).
// 返回: 无.
// 注意: 当v是正数/负数/零时,随机值的区间分别为[-v, v]/[]/[].
static void randomArray( int32_t a[], int32_t left, int32_t right, int32_t v ) {
	v -= v != INT32_MAX ? 0 : 1;
	while( left <= right ) {
		a[left++] = rand() % (v + 1) - rand() % (v + 1);
	}
}

// 功能: 将数组的某一区间内的元素值送入到文件流中.
// 参数: a(数组首地址), left(左闭区间), right(右闭区间), fp(文件流指针).
// 返回: 无.
// 注意: 无.
static void printArray( const int32_t a[], int32_t left, int32_t right, FILE *fp ) {
	fprintf( fp, "[" );
	while( left <= right ) {
		fprintf( fp, "%5d%s", a[left], left != right ? ", " : "" );
		++left;
	}
	fprintf( fp, "]
" );
}

int cmp( const void *a, const void *b ) {
	return *(int32_t *) a == *(int32_t *) b;
}

int main( int argc, char *argv[] ) {
	int32_t n = 0, i = 0, *a = NULL;
	SingleLinked *list = NULL;

	printf( "please input array length: n = " );
	scanf( "%d%*c", &n );
	printf( "
" );

	NEW( &a, sizeof(*a) * n );
	randomArray( a, 0, n - 1, 321 );
	printArray( a, 0, n - 1, stdout );

	list = newSingleLinked();

	printf( "emptySingleLinked( list ) = %s
", emptySingleLinked( list ) ? "true" : "false" );
	printf( "sizeSingleLinked( list ) = %d
", sizeSingleLinked( list ) );
	printf( "getFirstSingleLinked( list ) = %d
", !emptySingleLinked( list ) ? *(int32_t *) getFirstSingleLinked( list ) : INT32_MIN );
	printf( "getLastSingleLinked( list ) = %d
", !emptySingleLinked( list ) ? *(int32_t *) getLastSingleLinked( list ) : INT32_MIN );
	printf( "

" );

	for( i = 0; i < n; ++i ) {
		printf( "addSingleLinked( list, %d, &a[%d]=%d ) = %d
", i, i, a[i], *(int32_t *) addSingleLinked( list, i, &a[i] ) );
	}
	printf( "emptySingleLinked( list ) = %s
", emptySingleLinked( list ) ? "true" : "false" );
	printf( "sizeSingleLinked( list ) = %d
", sizeSingleLinked( list ) );
	printf( "getFirstSingleLinked( list ) = %d
", !emptySingleLinked( list ) ? *(int32_t *) getFirstSingleLinked( list ) : INT32_MIN );
	printf( "getLastSingleLinked( list ) = %d
", !emptySingleLinked( list ) ? *(int32_t *) getLastSingleLinked( list ) : INT32_MIN );
	printf( "

" );

	for( i = 0; i < sizeSingleLinked( list ); ++i ) {
		printf( "getSingleLinked( list, %d ) = %d
", i, *(int32_t *) getSingleLinked( list, i ) );
	}
	printf( "emptySingleLinked( list ) = %s
", emptySingleLinked( list ) ? "true" : "false" );
	printf( "sizeSingleLinked( list ) = %d
", sizeSingleLinked( list ) );
	printf( "getFirstSingleLinked( list ) = %d
", !emptySingleLinked( list ) ? *(int32_t *) getFirstSingleLinked( list ) : INT32_MIN );
	printf( "getLastSingleLinked( list ) = %d
", !emptySingleLinked( list ) ? *(int32_t *) getLastSingleLinked( list ) : INT32_MIN );
	printf( "

" );

	int32_t k = rand();
	#if 1
	switch( 3 ) {
		case 0:
			i = 0; break;
		case 1:
			i = 1; break;
		case 2:
			i = sizeSingleLinked( list ) - 1; break;
		case 3:
			i = sizeSingleLinked( list ); break;
		default: break;
	}
	printf( "addSingleLinked( list, %d, &k=%d ) = %d
", i, k, *(int32_t *) addSingleLinked( list , i, &k ) );
	#else
	printf( "addFirstSingleLinked( list, &k=%d ) = %d
",k, *(int32_t *) addFirstSingleLinked( list, &k ) );
	//printf( "addLastSingleLinked( list, &k=%d ) = %d
", k, *(int32_t *) addLastSingleLinked( list, &k ) );
	#endif
	printf( "emptySingleLinked( list ) = %s
", emptySingleLinked( list ) ? "true" : "false" );
	printf( "sizeSingleLinked( list ) = %d
", sizeSingleLinked( list ) );
	printf( "getFirstSingleLinked( list ) = %d
", *(int32_t *) getFirstSingleLinked( list ) );
	printf( "getLastSingleLinked( list ) = %d
", *(int32_t *) getLastSingleLinked( list ) );
	printf( "

" );

	#if 1
	switch( 2 ) {
		case 0:
			i = 0; break;
		case 1:
			i = 1; break;
		case 2:
			i = sizeSingleLinked( list ) - 1; break;
	}
	printf( "removeSingleLinked( list, %d ) = %d
", i, *(int32_t *) removeSingleLinked( list , i ) );
	#else
	//printf( "removeFirstSingleLinked( list ) = %d
", *(int32_t *) removeFirstSingleLinked( list ) );
	printf( "removeLastSingleLinked( list ) = %d
", *(int32_t *) removeLastSingleLinked( list ) );
	#endif
	printf( "emptySingleLinked( list ) = %s
", emptySingleLinked( list ) ? "true" : "false" );
	printf( "sizeSingleLinked( list ) = %d
", sizeSingleLinked( list ) );
	printf( "getFirstSingleLinked( list ) = %d
", !emptySingleLinked( list ) ? *(int32_t *) getFirstSingleLinked( list ) : INT32_MIN );
	printf( "getLastSingleLinked( list ) = %d
", !emptySingleLinked( list ) ? *(int32_t *) getLastSingleLinked( list ) : INT32_MIN );
	printf( "

" );

	#if 0
	printf( "findSingleLinked( list, &k ) = %d
", findSingleLinked( list, &k, cmp ) );
	#else
	printf( "findTailToFrontSingleLinked( list &k ) = %d
", findTailSingleLinked( list, &k, cmp ) );
	#endif
	printf( "emptySingleLinked( list ) = %s
", emptySingleLinked( list ) ? "true" : "false" );
	printf( "sizeSingleLinked( list ) = %d
", sizeSingleLinked( list ) );
	printf( "getFirstSingleLinked( list ) = %d
", !emptySingleLinked( list ) ? *(int32_t *) getFirstSingleLinked( list ) : INT32_MIN );
	printf( "getLastSingleLinked( list ) = %d
", !emptySingleLinked( list ) ? *(int32_t *) getLastSingleLinked( list ) : INT32_MIN );
	printf( "

" );

	addressSingleLinked( list );
	printf( "reversal: " );
	reversalSingleLinked( list );
	addressSingleLinked( list );
	printf( "emptySingleLinked( list ) = %s
", emptySingleLinked( list ) ? "true" : "false" );
	printf( "sizeSingleLinked( list ) = %d
", sizeSingleLinked( list ) );
	printf( "getFirstSingleLinked( list ) = %d
", !emptySingleLinked( list ) ? *(int32_t *) getFirstSingleLinked( list ) : INT32_MIN );
	printf( "getLastSingleLinked( list ) = %d
", !emptySingleLinked( list ) ? *(int32_t *) getLastSingleLinked( list ) : INT32_MIN );
	printf( "

" );

	delSingleLinked( &list );
	DEL( &a );

	return EXIT_SUCCESS;
}