栈-顺序存储

数组实现栈

---

创建3个文件：stackArray.h、stackArray.c、stackArrayTest.c

---

stackArray.h

#ifndef STACK_ARRAY_H_
#define STACK_ARRAY_H_

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

#define ADT StackArray

// 功能: 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 StackArray ADT;

// 功能: 创建一个新的栈.
// 参数: capacity(栈的最大容量).
// 返回: 一个新的栈.
// 注意: 当 capacity 小于0时,默认为512; 当内存分配失败时,将错误退出程序.
extern ADT *newStackArray( int32_t capacity );

// 功能: 将用户数据压入栈顶.
// 参数: stack(栈对象指针), data(用户数据).
// 返回: 被压入栈顶的用户数据.
// 注意: 当 stack 为NULL 或 满栈状态 时, 将错误退出程序.
extern void *pushStackArray( ADT *stack, void *data );

// 功能: 将栈顶用户数据弹出栈.
// 参数: stack(栈对象指针).
// 返回: 被弹出的栈顶用户数据.
// 注意: 当 stack 为NULL 或 空栈状态 时, 将错误退出程序.
extern void *popStackArray( ADT *stack );

// 功能: 偷看栈顶用户数据.
// 参数: stack(栈对象指针).
// 返回: 栈顶用户数据.
// 注意: 当 stack 为NULL 或 空栈状态 时, 将错误退出程序.
extern void *peekStackArray( ADT *stack );

// 功能: 偷看栈底用户数据.
// 参数: stack(栈对象指针).
// 返回: 栈顶用户数据.
// 注意: 当 stack 为NULL 或 空栈状态 时, 将错误退出程序.
extern void *peekBottomStackArray( ADT *stack );


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

// 功能: 从栈顶到栈底方向开始查找data.
// 参数: stack(栈对象指针), data(需查找的用户数据), cmp(用户自定义比较函数).
// 返回: 栈中包含了data, 返回data所在位置, 否则返回-1.
// 注意: 当 stack 为NULL 或 cmp 为NULL 时, 将错误退出程序.
extern int32_t findStackArray( ADT *stack, void *data, CompareFunc *cmp );

// 功能: 从栈底到栈顶方向开始查找data.
// 参数: stack(栈对象指针), data(需查找的用户数据), cmp(用户自定义比较函数).
// 返回: 栈中包含了data, 返回data所在位置, 否则返回-1.
// 注意: 当 stack 为NULL 或 cmp 为NULL 时, 将错误退出程序.
extern int32_t findTailStackArray( ADT *stack, void *data, CompareFunc *cmp );

// 功能: 栈实际已使用大小.
// 参数: stack(栈对象指针).
// 返回: 栈实际已使用大小.
// 注意: 当 stack 为NULL 时, 将错误退出程序.
extern int32_t sizeStackArray( ADT *stack );

// 功能: 空栈状态.
// 参数: stack(栈对象指针).
// 返回: 是空栈返回1, 否则返回0.
// 注意: 当 stack 为NULL 时, 将错误退出程序.
extern int emptyStackArray( ADT *stsack );

// 功能: 满栈状态.
// 参数: stack(栈对象指针).
// 返回: 是满栈返回1, 否则返回0.
// 注意: 当 stack 为NULL 时, 将错误退出程序.
extern int fullStackArray( ADT *stack );

// 功能: 栈最大容量.
// 参数: stack(栈对象指针).
// 返回: 栈最大容量.
// 注意: 当 stack 为NULL 时, 将错误退出程序.
extern int32_t capacityStackArray( ADT *stack );

// 功能: 清空栈.
// 参数: stack(栈对象指针).
// 返回: 无.
// 注意: 当 stack 为NULL 时, 将错误退出程序.
extern void clearStackArray( ADT *stack );

// 功能: 销毁栈.
// 参数: stack(存放栈对象指针的指针).
// 返回: 无.
// 注意: 当 stack 为NULL 时, 将错误退出程序.
extern void delStackArray( ADT **stack );

#undef ADT

#endif

stackArray.c

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


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

#define ADT StackArray


struct StackArray {
	int32_t capacity;
	int32_t top;
	void *array[0];
};


ADT *newStackArray( int32_t capacity ) {
	ADT *stack = NULL;

	capacity = capacity < 0 ? 512 : capacity;
	stack = malloc( sizeof(*stack) + sizeof(stack->array[0]) * capacity );
	ERROR_EXIT( !stack, NULL );
	stack->capacity = capacity;
	stack->top = 0;

	return stack;
}

void *pushStackArray( ADT *stack, void *data ) {
	ERROR_EXIT( !stack || stack->top >= stack->capacity, NULL );

	return (stack->array[stack->top++] = data);
}

void *popStackArray( ADT *stack ) {
	ERROR_EXIT( !stack || stack->top < 1, NULL );

	return stack->array[--stack->top];
}

void *peekStackArray( ADT *stack ) {
	ERROR_EXIT( !stack || stack->top < 1, NULL );

	return stack->array[stack->top - 1];
}

void *peekBottomStackArray( ADT *stack ) {
	ERROR_EXIT( !stack || stack->top < 1, NULL );

	return stack->array[0];
}

int existStackArray( ADT *stack, void *data, CompareFunc *cmp ) {
	ERROR_EXIT( !stack || !cmp, NULL );

	for( int32_t i = 0; i < stack->top; ++i ) {
		if( !cmp( stack->array[i], data ) ) {
			return 1;
		}
	}

	return 0;
}

int32_t findStackArray( ADT *stack, void *data, CompareFunc *cmp ) {
	ERROR_EXIT( !stack || !cmp, NULL );

	for( int32_t i = 0; i < stack->top; ++i ) {
		if( !cmp( stack->array[i], data ) ) {
			return i;
		}
	}

	return -1;
}

int32_t findTailStackArray( ADT *stack, void *data, CompareFunc *cmp ) {
	ERROR_EXIT( !stack || !cmp, NULL );

	for( int32_t i = stack->top - 1; i >= 0; --i ) {
		if( !cmp( stack->array[i], data ) ) {
			return i - 0; // 0为栈底位置.
		}
	}

	return -1;
}

int32_t sizeStackArray( ADT *stack ) {
	ERROR_EXIT( !stack, NULL );

	return stack->top;
}


int emptyStackArray( ADT *stack ) {
	ERROR_EXIT( !stack, NULL );

	return stack->top < 1;
}

int fullStackArray( ADT *stack ) {
	ERROR_EXIT( !stack, NULL );

	return stack->top >= stack->capacity;
}

int32_t capacityStackArray( ADT *stack ) {
	ERROR_EXIT( !stack, NULL );

	return stack->capacity;
}

void clearStackArray( ADT *stack ) {
	ERROR_EXIT( !stack, NULL );

	stack->top = 0;
}

void delStackArray( ADT **stack ) {
	ERROR_EXIT( !stack, NULL );
	free( *stack );
	*stack = NULL;
}

stackArrayTest.c

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

// a>b返回正数, a<b返回负数, 否则返回0.
static int cmp( const void *a, const void *b ) {
	return *(int32_t *) a - *(int32_t *) b;
}

int main( int argc, char *argv[] ) {
	char *tf[] = {"false", "true"};
	int32_t *a = NULL, n = 0;
	int32_t i = 0, k = 0;
	StackArray *s = NULL;

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

	a = malloc( sizeof(*a) * n );
	for( i = 0; i < n; ++i ) {
		a[i] = rand() % 322;
		//a[i] = 1;
	}

	printf( "&s = %p, s = %p
", &s, s );
	s = newStackArray( n );
	printf( "new: &s = %p, s = %p
", &s, s );

	printf( "peek       = %d
", emptyStackArray( s ) ? INT32_MIN : *(int32_t *) peekStackArray( s ) );
	printf( "peekBottom = %d
", emptyStackArray( s ) ? INT32_MIN : *(int32_t *) peekBottomStackArray( s ) );
	printf( "size     = %d
", sizeStackArray( s ) );
	printf( "empty = %s
", tf[emptyStackArray( s )]);
	printf( "full  = %s
", tf[fullStackArray( s )] );
	printf( "capacity = %d
", capacityStackArray( s ) );
	printf( "
" );

	printf( "push all: [" );
	for( i = 0; i < n; ++i ) {
		printf( ", %5d", *(int32_t *) pushStackArray( s, &a[i] ) );
	}
	printf( "]
" );

	printf( "peek       = %d
", emptyStackArray( s ) ? INT32_MIN : *(int32_t *) peekStackArray( s ) );
	printf( "peekBottom = %d
", emptyStackArray( s ) ? INT32_MIN : *(int32_t *) peekBottomStackArray( s ) );
	printf( "size     = %d
", sizeStackArray( s ) );
	printf( "empty = %s
", tf[emptyStackArray( s )] );
	printf( "full  = %s
", tf[fullStackArray( s )] );
	printf( "capacity = %d
", capacityStackArray( s ) );
	printf( "
" );

	//k = a[0];
	k = rand();
	printf( "exist &k(%d) = %s
", k, tf[existStackArray( s, &k, cmp )] );
	printf( "
" );

	k = a[0];
	//k = rand();
	printf( "find &k(%d) = %d
", k, findStackArray( s, &k, cmp ) );
	printf( "
" );

	//k = a[0];
	k = rand();
	printf( "findTile &k(%d) = %d
", k, findTailStackArray( s, &k, cmp ) );
	printf( "
" );

	printf( "pop all:  [" );
	while( !emptyStackArray( s ) ) {
		printf( ", %5d", *(int32_t *) popStackArray( s ) );
	}
	printf( "]
" );

	printf( "peek       = %d
", emptyStackArray( s ) ? INT32_MIN : *(int32_t *) peekStackArray( s ) );
	printf( "peekBottom = %d
", emptyStackArray( s ) ? INT32_MIN : *(int32_t *) peekBottomStackArray( s ) );
	printf( "size     = %d
", sizeStackArray( s ) );
	printf( "empty = %s
", tf[emptyStackArray( s )] );
	printf( "full  = %s
", tf[fullStackArray( s )] );
	printf( "capacity = %d
", capacityStackArray( s ) );
	printf( "
" );

	delStackArray( &s );
	printf( "del: &s = %p, s = %p
", &s, s );

	return EXIT_SUCCESS;
}