C源码@数据结构与算法->栈Stack

/*
* fatal.h
* Header file for print error message.
*/
#ifndef _FATAL_H
#define _FATAL_H

#include
#include

#define Error(str) FatalError(str)
#define FatalError(str) fprintf(stderr, "%s\n", str), exit(-1)

#endif /* _FATAL_H */

/*
* stack.h
*/
#ifndef _STACK_H
#define _STACK_H

#define _STACK_ARRAY_

#ifndef NULL
#define NULL (0)
#endif

typedef int ElementType;

#ifndef _STACK_ARRAY_
struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode Stack;
#else /* ifndef _STACK_ARRAY_ */
struct StackRecord;
typedef struct StackRecord *Stack;
#endif /* ifndef _STACK_ARRAY_ */

#ifdef __cplusplus
extern "C" {
#endif

int IsEmpty(Stack S);
#ifndef _STACK_ARRAY_
Stack CreateStack();
#else /* _STACK_ARRAY_ */
Stack CreateStack(int MaxElements);
int IsFull(Stack S);
ElementType TopAndPop(Stack S);
#endif /* _STACK_ARRAY_ */
void MakeEmpty(Stack S);
void DisposeStack(Stack S);
void Push(ElementType X, Stack S);
ElementType Top(Stack S);
void Pop(Stack S);

#ifdef __cplusplus
}
#endif

#endif /* _STACK_H */

/*
* stack.cpp
*/
#include
#include "fatal.h"
#include "stack.h"

#ifndef _STACK_ARRAY_
/* --------------------Linked List Implementation of Stacks------------------- */

struct Node
{
ElementType Element;
PtrToNode Next;
};

/*
* Test whether a stack is empty.
*/
int IsEmpty(Stack S)
{
return S->Next == NULL;
}

/*
* Create a header node.
* Then, set the next pointer to NULL.
*/
Stack CreateStack()
{
Stack S;

S = (Stack)malloc(sizeof(struct Node));
if (S == NULL)
{
FatalError("Out of memory!");
}

S->Next = NULL;

MakeEmpty(S);

return S;
}

void MakeEmpty(Stack S)
{
if (S == NULL)
{
FatalError("Must use CreateStack first");
}
else
{
while (!IsEmpty(S))
{
Pop(S);
}
}
}

void DisposeStack(Stack S)
{
MakeEmpty(S);
free(S);
}

/*
* The Push is implemented as an insertion into the front of a linked list,
* where the front of the list serves as the top of the stack.
*/
void Push(ElementType X, Stack S)
{
PtrToNode TmpCell;

TmpCell = (PtrToNode)malloc(sizeof(struct Node));
if (TmpCell == NULL)
{
FatalError("Out of memory!");
}
else
{
TmpCell->Element = X;
TmpCell->Next = S->Next;
S->Next = TmpCell;
}
}

/*
* Retrieve the element in the first position of the list.
*/
ElementType Top(Stack S)
{
if (!IsEmpty(S))
{
return S->Next->Element;
}
else
{
Error("Empty stack");
return -1;		/* Return value used to avoid warning */
}
}

/*
* Delete a cell from the front of the list.
*/
void Pop(Stack S)
{
PtrToNode FirstCell;

if (IsEmpty(S))
{
FatalError("Empty stack");
}
else
{
FirstCell = S->Next;
S->Next = S->Next->Next;
free(FirstCell);
}
}

#else /* #ifndef _STACK_ARRAY_ */
/* --------------------Array Implementation of Stacks------------------- */
#define EmptyTOS		(-1)
#define MinStackSize	(5)

struct StackRecord
{
int Capacity;
int TopOfStack;
ElementType *Array;
};

/*
* Test whether stack is empty.
*/
int IsEmpty(Stack S)
{
return S->TopOfStack == EmptyTOS;
}

/*
* Test whether stack is full.
*/
int IsFull(Stack S)
{
return S->TopOfStack == S->Capacity - 1;
}

/*
* Create stack.
*/
Stack CreateStack(int MaxElements)
{
Stack S;

if (MaxElements < MinStackSize)
{
FatalError("Stack size is too small!");
}

S = (Stack)malloc(sizeof(struct StackRecord));
if (S == NULL)
{
FatalError("Out of memory!");
}

S->Array = (ElementType *)malloc(sizeof(ElementType) * MaxElements);
if (S->Array == NULL)
{
FatalError("Out of memory!");
}

S->Capacity = MaxElements;

MakeEmpty(S);

return S;
}

/*
* Make stack empty.
*/
void MakeEmpty(Stack S)
{
S->TopOfStack = EmptyTOS;
}

/*
* Free the stack structure.
*/
void DisposeStack(Stack S)
{
if (S != NULL)
{
free(S->Array);
free(S);
}
}

/*
* A Push on a full stack will overflow the array bounds and cause a crash.
*/
void Push(ElementType X, Stack S)
{
if (IsFull(S))
{
FatalError("Full stack!");
}
else
{
S->Array[++S->TopOfStack] = X;
}
}

/*
* Return top of stack.
*/
ElementType Top(Stack S)
{
if (IsEmpty(S))
{
FatalError("Empty stack!");
return 0;		/* Return value used to avoid warning */
}
else
{
return S->Array[S->TopOfStack];
}
}

/*
* A Pop on an empty stack will underflow the array bounds and cause a crash.
*/
void Pop(Stack S)
{
if (IsEmpty(S))
{
FatalError("Empty stack!");
}
else
{
--S->TopOfStack;
}
}

ElementType TopAndPop(Stack S)
{
if (IsEmpty(S))
{
FatalError("Empty stack!");
return 0;		/* Return value used to avoid warning */
}
else
{
return S->Array[S->TopOfStack--];
}
}

#endif /* #ifndef _STACK_ARRAY_ */

/*
* teststack.cpp
*/
#include
#include "stack.h"

int main()
{
Stack S = NULL;
int i;
#ifndef _STACK_ARRAY_
S = CreateStack();
#else
S = CreateStack(12);
#endif
for (i = 0; i < 10; ++i)
{
Push(i, S);
}

while (!IsEmpty(S))
{
printf("%d\n", Top(S));
Pop(S);
}

DisposeStack(S);

return 0;
}