感觉上块链的代码实现比数组的代码实现要难一些，估计因为数组的实现书上有伪代码，而块链连伪代码都木有，不过归根到底还是水平不行……哭瞎……╥﹏╥...

/*

数据结构C语言版 串的块链存储表示和实现

*/

# include 

# include 

# include 

/* 链表元素结构体 */

typedef struct List

{

//数据域

char data;

//指针域

struct List * pNext;

}List, * PLIST;

/* 串结构体 */

typedef struct String

{

PLIST pHead, pTail;

int length;

}STRING, * PSTRING;

/* 函数前置声明 */

/* 初始化一个串 */

void InitString( PSTRING );

/* 为一个串赋值 */

bool StrAssign( PSTRING, char * );

/* 遍历这个块链串 */

void TravelerString( PSTRING );

/* 返回串的长度 */

int StrLength( PSTRING );

/* 拷贝一个串 */

bool StrCopy( PSTRING, PSTRING );

/* 拼接两个串常量编程一个块链 */

bool Concat( PSTRING, char *, char * );

/* 初始化这个串 */

void InitString( PSTRING str )

{

str -> pHead  = NULL;

str -> pTail  = NULL;

str -> length = 0;

}

/*

复制一个串常量

*/

bool StrAssign( PSTRING str, char * arr )

{

int i, j;

PLIST p, q;

//串常量的长度

for( i = 0; arr[i] != '\0'; ++i);

str -> length = i;

for( j = 0; j 

{

//如果j 等于 0，说明是首节点

if( 0 == j )

{

p = ( PLIST )malloc( sizeof( List ) );

if( NULL == p )

{

printf("动态内存分配失败\n");

return false;

}

p -> data = arr[j];

p -> pNext = NULL;

str -> pHead = p;

}

else

{

q = ( PLIST )malloc( sizeof( List ) );

if( NULL == q )

{

printf("动态内存分配失败\n");

return false;

}

q -> data = arr[j];

q -> pNext = NULL;

p -> pNext = q;

p = q;

}

}

str -> pTail = p;

return true;

}

/* 打印出这个串 */

void TravelerString( PSTRING str )

{

PLIST p = str -> pHead;

while( NULL != p )

{

printf( "%c ", p -> data );

p = p -> pNext;

}

printf("\n");

}

/* 返回串的长度 */

int StrLength( PSTRING str )

{

return str -> length;

}

/* 拷贝一个串的长度 */

bool StrCopy( PSTRING str, PSTRING str1 )

{

PLIST p, q, r;

r = str1 -> pHead;

str -> length = str1 -> length;

while( NULL != r )

{

if( r == str1 -> pHead )

{

p = str -> pHead = ( PLIST )malloc( sizeof( List ) );

p -> data = r -> data;

p -> pNext = NULL;

r = r -> pNext;

}

else

{

q =  ( PLIST )malloc( sizeof( List ) );

q -> data = r -> data;

q -> pNext = NULL;

p -> pNext = q;

p = q;

r = r -> pNext;

}

}

str -> pTail = p;

return true;

}

/* 拼接两个字符串常量 */

bool Concat( PSTRING str, char * s1, char * s2 )

{

STRING a1, a2;

InitString( &a1 );

InitString( &a2 );

StrAssign( &a1, s1 );

StrAssign( &a2, s2 );

str -> pHead = a1.pHead;

str -> pTail = a2.pTail;

a1.pTail -> pNext = a2.pHead;

return true;

}

int main( void )

{

//创建一个串

STRING str, str1, str2;

InitString( &str );//初始化这个串

InitString( &str1 );

InitString( &str2 );

printf("将字符串常量“abcde”赋值给str\n");

StrAssign( &str, "abcde" );

printf("打印出str的值：");

TravelerString( &str );

printf( "打印出串str的长度：%d\n", StrLength( &str ) );

//拷贝str 到 str1

printf("复制串str到str1，遍历str1：\n");

StrCopy( &str1, &str );

TravelerString( &str1 );

//将两个串常量，拼接成一个串块链

Concat( &str2, "hello", "world" );

printf("将“hello”“world”拼接成一个新的块链串：\n");

TravelerString( &str2 );

return 0;

}

/*

在VC++6.0中输出的结果是：

=============================

将字符串常量“abcde”赋值给str

打印出str的值：a b c d e

打印出串str的长度：5

复制串str到str1，遍历str1：

a b c d e

将“hello”“world”拼接成一个新的块链串：

h e l l o w o r l d

=============================

总结：

无非都是线性表，跟操作线性表的感觉一样一样的。

有时间多把线性结构、栈、队列那里再练练，考试的重点。

*/

扛不住了，我要吐了，不谢了，就这吧，估计考试也不会考这里的大题……