[代码分享]静态链表，接口仿照STL设计，操作未做封装

很久没有来CSDN，也很久没有写东西了。去年12月在OSCHINA注册了号，发了两段code。这次转过来，以便日后查阅。

连接：http://www.oschina.net/code/snippet_737017_16964

这是一段静态链表的实现，其间用到了一种简单的内存管理策略——空闲链表。

这段代码里的“静态”是一个预先分配好的 node array，实际情况下可能会是一个一次性申请的较大的memory block。

其实是在这段 node array上维护两个链表，一个used list，一个free list，即代码中的idata，和ifree。

// 静态链表 的实现
#include <stdio.h>

#define MAXN 16 // capacity of list.
typedef int element; // element type.

// define boolean type:
typedef int bool;
#define true -1
#define false 0

#define NPTR -1 // null pointer definition. can not between 0 to MAXN-1.
typedef int pointer;

#define DEBUGVAL(x) printf("%s: %d\n", #x, (x)); // a macro for debug.

struct __node
{
	element data;
	pointer next;
}SLList[MAXN];
pointer ifree, idata;

#define nextof(p) SLList[p].next
#define dataof(p) SLList[p].data

#define _alloc(d) ifree; dataof(ifree)=(d); ifree != NPTR ? ifree=nextof(ifree) : NPTR
#define _free(p)  nextof(p)=ifree; ifree = p

void init()
{
	int i;
	ifree = 0;
	idata = NPTR;
	for( i=0; i < MAXN-1; i++) 
		nextof(i) = i+1;
	nextof(i) = NPTR;
}

// clear all nodes.
void clear() { init(); }

// push val to front.
bool push_front(element val)
{
	pointer tmp, np;
	if( ifree != NPTR ) {
		np = _alloc(val);
		nextof(np) = idata;
		idata = np;
		return true;
	}
	return false;
}

// push val to end of list.
bool push_back(element val)
{
	if( idata == NPTR ) { // 空表，直接写入
		idata = _alloc(val);
		nextof(idata) = NPTR;
		return true;
	}
	if( ifree != NPTR ) { // 非空，先找到最后一个节点
		pointer last = idata, np;
		while( nextof(last) != NPTR ) last = nextof(last);		
		np = _alloc(val);
		nextof(np) = NPTR;
		nextof(last) = np;
		return true;
	}
	return false;
}

// insert val to after p pointed node.
bool insert_after(pointer p, element val)
{
	if( ifree != NPTR && p != NPTR ) {
		pointer pn = _alloc(val);
		nextof(pn) = nextof(p);
		nextof(p)  = pn;		
		return true;
	}
	return false;
}

// insert to the position in front of p.
bool insert(pointer ptr, element val)
{
	if( ifree == NPTR ) return false;  // 没有结点，直接返回
	if( ptr == idata ) { // 有一个节点
		pointer np = _alloc(val);
		nextof(np) = idata;
		idata = np;	
		return true;
	}
	else { // 其他情况，先找 ptr 的前驱，再插入
		pointer p = idata;
		while(  p != NPTR ) {
			if( nextof(p) == ptr ) { // find p -- the prev node of ptr.
				return insert_after(p, val); // insert val after p.			
			}
		   p = nextof(p);
		}
	}
	return false;
}

// find element, return the prev node pointer.
pointer find_prev(element val)
{
	pointer p = idata;
	while(  p != NPTR ) {
		if( dataof( nextof(p) ) == val )
			return p;
		p = nextof(p);
	}
	return NPTR;
}

// find element, return the node  pointer.
pointer find(element val)
{
	pointer p = idata;
	while(  p != NPTR ) {
		if( dataof(p) == val ) return p;
		p = nextof(p);
	}
	return NPTR;
}

// pop front element.
void pop_front()
{
	if( idata != NPTR ) { // 将 data list 最前面的节点 移到 free list 上
#if 0
		pointer p = idata;		
		idata = nextof(idata); // idata = nextof(idata);
		nextof(p) = ifree;  // SLList[p].next = ifree;
		ifree = p; 
#else
		pointer p = idata;
		idata = nextof(idata);
		_free(p);
#endif
	}
}

// pop back element.
void pop_back()
{
	if( idata == NPTR ) return;
	if( nextof(idata) == NPTR ) { // only 1 node.
		nextof(idata) = ifree;
		ifree = idata;
		idata = NPTR;
	}
	else { // 找到最后一个节点 p，以及它的前驱 q.
		// TODO: find the lase nod p, and it's perv node q. 
		pointer p = idata, q; 
		while( nextof(p) != NPTR ) {
			q = p;
			p = nextof( p );
		}
		// remove *p to free list, update nextof(q) to NPTR.
		nextof(p) = ifree;
		ifree = p;
		nextof(q) = NPTR;
	}
}

完整代码及测试见：http://www.oschina.net/code/snippet_737017_16964

记得曾经在反《算法导论》的时候好像看到书中提到静态链表的实现问题，当时没有在意，直到去年写下这段代码的时候任然没有详细去看；今天翻出电子版一看，有近两页篇幅描述。

《算法导论》中的描述还是较为精炼的，文字不多，条理清晰，这里有一副原书中的插图，书中先讲了在没有指针的语言中如何表示指针和对象；

然后，话锋一转，在这样的情况下“Thus, it is useful to manage the storage of objects not currently used in the linked-list representation so that one can be allocated.”

然后书中也给出了伪代码：（要是早知道，我也那个夜晚也不用搞到两点了☺）

ALLOCATE-OBJECT()
 if free = NIL
   then error "out of space"
 else x ← free
   free ← next[x]
   return x

FREE-OBJECT(x)
1 next[x] ← free
2 free ← x