分享：通用栈（如果你有任何疑问或建议，请提出）
栈、队列、链表的通用，到此刻算是彻底完成了。三种ADT，三种不同的实现思路。
还是老样子，如果你有任何问题或建议，情提出。
21:02 5/18
修正了void *进行数学计算的问题，现在应该不会再报错了。
22:32 5/19
删除了实现文件中多余的宏。
DestroyStack()函数增加了几行代码，当最后一个栈被销毁，则释放掉全局变量STACK指向的空间。
但似乎这样做并不是很有必要，先就这样。
程序代码：
//测试：
#include "Stack.h"
#include <stdio.h>
int
main( void )
{
Stack_T a, c;
int *b;
int ix;
char ch;
char *k;
a = CreateStack( sizeof( int ) );
c = CreateStack( sizeof( char ) );
for( ix = 0; 200 > ix; ++ix )
{
PoshStack( a, &ix );
ch = 'a' + ( ix % 26);
PoshStack( c, &ch );
}
while( !IsEmptyStack( a ) )
{
b = TopStack( a );
printf( "%d ", *b );
PopStack( a );
}
DestroyStack( a );
printf( "\n" );
while( !IsEmptyStack( c ) )
{
k = TopStack( c );
printf( "%c ", *k );
PopStack( c );
}
DestroyStack( c );
return 0;
}
程序代码：//接口： #ifndef __STACK_H__ #define __STACK_H__ #include <stdio.h> #define T Stack_T typedef int T; T CreateStack( size_t DataSize );//创建一个栈，参数为数据的大小，成功返回栈。 int DestroyStack( T Stack );//销毁一个栈，参数为需要销毁的栈，成功返回0，失败返回1 void PoshStack( T Stack, void *Value );//将一个值压入栈，参数为栈和需要入栈的元素。 void * TopStack( T Stack );//将一个值从栈顶弹出，参数为需要弹出值的栈，成功返回指向该元素的指针。 void PopStack( T Stack );//从一个栈中删除栈顶元素，参数为需要删除值的栈 int IsEmptyStack( T Stack );//检测栈是否为空，参数为需要检测的栈，如果为空，返回1，否则返回0 int IsFullStack( T Stack );//检测栈是否已满，参数为需要检测的栈，如果已满返回1，否则返回0 #undef T #endif
程序代码：
//实现
#include "Stack.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define T Stack_T
#define L list
#define INITSIZE 128
#define INITUP 10
typedef struct L *L;
struct L{
void *Element;
void *Top;
int Step;
int CurrentSize;
};
static L *STACK;
static int ThisSize;
T
CreateStack( size_t DataSize )
{
int ix;
L *Temp;
if( NULL == STACK )
{
ThisSize = INITUP;
STACK = ( L * )malloc( ThisSize * sizeof( L ) );
if( NULL == STACK )
exit( EXIT_FAILURE );
for( ix = 0; ThisSize > ix; ++ix )
STACK[ ix ] = NULL;
}
for( ix = 0; ThisSize > ix && NULL != STACK[ ix ]; ++ix )
;
if( ThisSize == ix )
{
ThisSize += INITUP;
Temp = ( L * )realloc( STACK, ThisSize * sizeof( L ) );
if( NULL == Temp )
exit( EXIT_FAILURE );
STACK = Temp;
for( int i = ix; ThisSize > i; ++i )
STACK[ i ] = NULL;
}
STACK[ ix ] = malloc( sizeof( struct L ) );
if( NULL == STACK[ ix ] )
exit( EXIT_FAILURE );
STACK[ ix ]->Element = malloc( INITSIZE * DataSize );
if( NULL == STACK[ ix ]->Element )
exit( EXIT_FAILURE );
STACK[ ix ]->Top = STACK[ ix ]->Element;
STACK[ ix ]->Step = DataSize;
STACK[ ix ]->CurrentSize = INITSIZE;
return ix;
}
int
DestroyStack( T Stack )
{
int ix;
if( 0 > Stack || ThisSize <= Stack || NULL == STACK[ Stack ] )
return 1;
free( STACK[ Stack ]->Element );
free( STACK[ Stack ] );
STACK[ Stack ] = NULL;
for( ix = 0; ThisSize > ix; ++ix )
if( NULL != STACK[ ix ] )
break;
if( ThisSize == ix )
{
free( STACK );
ThisSize = 0;
}
return 0;
}
void
PoshStack( T Stack, void *Value )
{
if( 0 > Stack || ThisSize <= Stack || NULL == STACK[ Stack ] )
return;
if( !IsFullStack( Stack ) )
{
memmove( STACK[ Stack ]->Top, Value, STACK[ Stack ]->Step );
STACK[ Stack ]->Top = ( char * )( STACK[ Stack ]->Top ) + STACK[ Stack ]->Step;
}
else
return;
}
void *
TopStack( T Stack )
{
if( 0 > Stack || ThisSize <= Stack || NULL == STACK[ Stack ] )
return NULL;
if( !IsEmptyStack( Stack ) )
return ( char * )( STACK[ Stack ]->Top ) - STACK[ Stack ]->Step;
else
return NULL;
}
void
PopStack( T Stack )
{
if( 0 > Stack || ThisSize <= Stack ||NULL == STACK[ Stack ] )
return;
if( !IsEmptyStack( Stack ) )
STACK[ Stack ]->Top = ( char * )( STACK[ Stack ]->Top ) - STACK[ Stack ]->Step;
}
int
IsEmptyStack( T Stack )
{
if( 0 > Stack || ThisSize <= Stack || NULL == STACK[ Stack ] )
return 1;
return STACK[ Stack ]->Top == STACK[ Stack ]->Element;
}
int
IsFullStack( T Stack )
{
int c;
void *Temp;
if( 0 > Stack || ThisSize <= Stack || NULL == STACK[ Stack ] )
return 1;
c = ( ( char * )( STACK[ Stack ]->Top ) - ( char * )( STACK[ Stack ]->Element ) ) / STACK[ Stack ]->Step;
if( STACK[ Stack ]->CurrentSize == c + 1 )
{
STACK[ Stack ]->CurrentSize += INITSIZE;
Temp = realloc( STACK[ Stack ]->Element,
STACK[ Stack ]->CurrentSize * STACK[ Stack ]->Step );
if( NULL == Temp )
return 1;
STACK[ Stack ]->Element = Temp;
STACK[ Stack ]->Top = ( char * )( STACK[ Stack ]->Element ) + c * STACK[ Stack ]->Step;
return 0;
}
else
return 0;
}
[此贴子已经被作者于2017-5-20 11:50编辑过]
