数据结构与算法学习笔记——链表部分实现（数组形式）

/******************************************************************************************************
* Copyright(C);
* Filename    :
* Author      :
* Version     :
* Date        :
* Description :
******************************************************************************************************/
#include <stdio.h>

/****************************************************************/
#define ElementType   unsigned int
#define MAX_ELEMENT    10

#define NIL  -1

int _L, _F;
ElementType  _key[ MAX_ELEMENT+1 ];
ElementType _next[ MAX_ELEMENT+1 ];
ElementType _prev[ MAX_ELEMENT+1 ];

/****************************************************************/
int  AllocateObject	(void);
void CreateList		(void);
int  Delete         (int pos);
int  Find           (ElementType e );
void FreeObject     (int pos);
int  GetLength      (void);
int  Insert         (ElementType e, int pos);
int  IsEmpty		(void);
int  IsFull			(void);
int  IsLast			(int pos);

void ListIndex      (void);
void PrintList      (void);

/****************************************************************/


int main(void){
	int i;

	CreateList();
	
	for ( i=0; i<MAX_ELEMENT; i++ ){
		Insert(i,i);
	}
	printf("length:%d\n",GetLength());
	Delete(Find(9));
	printf("length after delete: %d\n",GetLength());
	Insert(0,-1);
	PrintList();
    printf("length:%d\n",GetLength());

	PrintList();
	
	Delete(Find(1));
	Delete(Find(3));
	Delete(Find(5));
	ListIndex();
	return 0;
}




int IsEmpty(void ){
	return  _next[_L] == NIL;
}

int IsFull(void){
	return _F == NIL;
}

int IsLast(int pos){
	return _next[pos] == NIL;
}

int AllocateObject(void){
	int address = NIL;

	if (!IsFull() ){
		address = _F;
		_F = _next[ _F ];
		_prev[ _F ] = NIL;
	}

	return address;
}

void CreateList(void){
	int i;
	_L = 0;
	_next[ _L ] =NIL;
	_F = 1;
	for ( i=_F; i<MAX_ELEMENT; i++ ){
		_next[ i ] = i+1;
		_prev[ i ] = i-1;
	}
	_prev[ _F ] = NIL;
	_next[ i ] = NIL;
}


int GetLength(void){
	int len = 0;
	int node = _next[_L];
	while( node != NIL ){
		len++;
		node = _next[node];
	}

	return len;
}


int Insert(ElementType e, int pos){
	int i = 0;
	int address_cur;
	int address_pre;
	int address_new;
	if ( -1 == pos ){
		pos = GetLength();
	}

	if ( pos > GetLength() || pos < 0 || IsFull() ){
		return -1;
	}

	address_cur = _next[_L];
	address_pre = _L;
	while ( i<pos && address_cur!=NIL ){
		i++;
		address_cur = _next[ address_cur ];
		address_pre = _next[ address_pre ];
	}

	address_new = AllocateObject();
	_key[ address_new ] = e;
	_next[ address_new ] = address_cur;
    _prev[ address_new ] = address_pre;
	_next[ address_pre ] = address_new;
	if ( address_cur != NIL ){
		_prev[ address_cur ] = address_new;
	}

	return 0;
}

int Find(ElementType e){
	int i = 0;
	int node = _next[ _L ];
	if ( IsEmpty() ){
		return -1;
	}

	while ( node!=NIL && _key[node]!=e ){
		node = _next[ node ];
		i++;
	}

	if ( node!=NIL ){
		return i;
	}
	else{
		return -1;
	}
}

void FreeObject(int pos){
	if ( IsEmpty() ){
		return;
	}
	_next[ pos ] = _F;
	_prev[ _F ] = pos;
	_prev[ pos ] = NIL;
	_F = pos;
}

int Delete(int pos){
	int a = _next[ _L ];
	int i = 0;
	int len = GetLength();
	if ( pos<0 || pos>=len ){
		return -1;
	}

	while( i<pos ){
		a = _next[ a ];
		i++;
	}
	_next[ _prev[a] ] = _next[ a ];
	if ( _next[ a ] != NIL ){
		_prev[ _next[a] ] = _prev[ a ];
	}
	FreeObject(a);
	return 0;
} 

void PrintList(void){
	int i = _next[ _L ];
	while( i != NIL ){
		printf("%d,",_key[i]);
		i = _next[ i ];
	}
	printf("\n");
}

void ListIndex(void){
	int i;
	printf("L = %d\n", _L);
	printf("F = %d\n", _F);
	
	printf("      ");
	for ( i=0; i<=MAX_ELEMENT; i++ ){
		printf("%5d", i);
	}
	printf("\n");

	printf("_next:  ");
	for (i=0; i<=MAX_ELEMENT; i++){
		printf("%3d, ",_next[i]);
	}
	printf("\n");

	printf("_key:   ");
	for (i=0; i<=MAX_ELEMENT; i++){
		printf("%3d, ",_key[i]);
	}
	printf("\n");

	printf("_prev:  ");
	for (i=0; i<=MAX_ELEMENT; i++){
		printf("%3d, ",_prev[i]);
	}
	printf("\n");
}