第17章 经典数据结构类型
- 堆栈
堆栈接口提供三种基本的操作：push、pop 和 top。
Push：把一个新值压入到堆栈的顶部。
Pop： 只把顶部元素从堆栈中移除，它并不返回这个值。
Top： 返回顶部元素的值，但它并不把顶部元素从堆栈中移除。
（1）堆栈接口
#ifndef STACK_H
#define STACK_H
#include<stdlib.h>
#define STACK_TYPE int
//push 把一个新值压入到堆栈中，它的参数是需要被压入的值
void push( STACK_TYPE value);
//pop 从堆栈中弹出一个值，并将其丢弃
void pop();
//top 返回堆栈顶元素的值，但不对堆栈进行修改
STACK_TYPE top();
//is_empty 如果堆栈为空，返回TRUE，否则返回FALSE
int is_empty();
//is_full 如果堆栈已满，返回TRUE，否则返回FALSE
int is_full();
//create_stack 创建堆栈，参数指定堆栈可以保存多少个元素（动态才有）
void create_stack(size_t size);
//destroy_stack 销毁堆栈，它释放堆栈所使用的内存（动态才有）
void destroy_stack();
#endif
（2）数组堆栈（静态数组存储）
#include "stack.h"
#include <assert.h>
#define STACK_SIZE 100
//存储堆栈中值的数组和一个指向堆栈顶部元素的指针
static STACK_TYPE stack[STACK_SIZE];
static int top_element=-1;
void push( STACK_TYPE value )
{
assert ( ! is_full() ); //和if用法差不多，如assert参数为0，则终止
top_element += 1;
stack [top_element] = value;
}
void pop ()
{
assert ( !is_empty() );
top_elememt -= 1;
}
STACK_TYPE top ()
{
assert ( !is_empty() );
return stack[top_element];
}
int is_empty ()
{
return top_element == -1;
}
int is_full ()
{
return top_element == STACK_SIZE - 1;
}
（3）动态数组堆栈（动态数组存储）
#include "stack.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>
static STACK_TYPE *stack;
static size_t stack_size;
static int top_element = -1;
void create_stack ( size_t size )
{
assert ( stack_size == 0 ); //还没有分配内存空间
stack_size = size;
stack = malloc ( stack_size * sizeof( STACK_TYPE )); //分配内存空间
assert ( stack != NULL );
}
void destroy_stack ()
{
assert ( stack_size > 0 );
stack_size = 0;
free ( stack );
stack = NULL;
}
void push ( STACK_SIZE value ) //进栈
{
assert ( !is_full() );
top_element += 1;
stack [top_element] = value;
}
void pop () //移动顶端指针
{
assert ( !is_empty() );
top_element -= 1;
}
STACK_TYPE top () //出栈
{
assert ( !is_empty() );
return stack[top_element];
}
int is_empty ()
{
assert ( stack_size > 0 ); //有内存空间只是没有值
return top_element == -1;
}
int is_full ()
{
assert ( stack_size > 0 );
return top_element == stack_size -1;
}
（4）链式堆栈（链表存储）
#include "stack.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>
#define FALSE 0
typedef struct STACK_NODE {
STACK_TYPE value;
struct STACK_NODE *next;
}StackNode;
static StackNode *stack;
void create_stack ( size_t size )
{
}
void destroy_stack ()
{
while ( !is_empty() );
pop ();
}
void push ( STACK_TYPE value)
{
StackNode *new_node;
new_node = malloc (sizeof( StackNode ))
assert ( new_node ! = NULL );
new_node -> value = value;
new_node -> next = stack;
stack = new_node;
}
void pop () //顶部元素移除
{
StackNode *first_node;
assert ( !is_empty() );
first_node = stack;
stack = first_node -> next;
free ( first_node );
}
STACK_TYPE top () //返回顶部元素值
{
assert ( !is_empty() );
return stack -> value;
}
int is_empty ()
{
return stack == NULL;
}
int is_full () //链式堆栈不会填满，所以is_full始终返回false
{
return FALSE;
}
2.队列
（1）队列接口
#ifndef QUEUE_H
#define QUEUE_H
#include <stdlib.h>
#define QUEUE_TYPE
//create_queue 创建一个队列，参数指定队列可以存储的元素的最大数量(动态)
void create_queue ( size_t size );
//destroy_queue 销毁一个队列。
void destroy_queue ();
//insert 向队列添加一个新元素，参数就是要添加的元素
void insert ( QUEUE_TYPE value );
//delete 从队列中移除一个元素并将其丢弃
void delete ();
//first 返回队列中第一个元素的值，但不修改队列本身
QUEUE_TYPE first ();
//is_empty 如果队列为空，返回true，否则返回false
int is_empty ();
//is_full 如果队列已满，返回true，否则返回false
int is_full ();
#endif
（2）数组队列
#include "queue.h"
#include <stdio.h>
#include <assert.h>
#define QUEUE_SIZE 100 //队列中元素最大数量
#define ARRAY_SIZE ( QUEUE_SIZE + 1) //数组长度
//用于存储队列元素的数组和指向队列头和尾的指针
static QUEUE_TYPE queue[ QUEUE_SIZE ];
static size_t front = 1;
static size_t rear = 0;
void insert ( QUEUE_TYPE value )
{
assert ( !is_full() );
rear = ( rear + 1 ) % ARRAY_SIZE;
queue[rear] = value;
}
void delete ()
{
assert ( !is_empty() );
front = ( front + 1 ) % ARRAY_SIZE;
}
QUEUE_TYPE first ()
{
assert ( !is_empty() );
return queue[front];
}
int is_empty ()
{
return ( rear + 1 ) % ARRAY_SIZE == front;
}
int is_full ()
{
return ( rear + 2 ) % ARRAY_SIZE == front;
}
（3）动态数组队列
#include "queue.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>
static QUEUE_TYPE *queue;
static size_t queue_size;
static size_t array_size = queue_size + 1;
static size_t front = 1;
static size_t rear = 0;
void create_queue ( size_t size )
{
assert ( queue_size == 0 );
queue_size = size;
queue = malloc ( queue_size * sizeof( QUEUE_TYPE ) );
assert ( queue != NULL );
}
void destory_queue ()
{
assert ( queue_size > 0 );
queue_size == 0;
free ( queue );
queue == NULL;
}
void insert ( QUEUE_TYPE value )
{
assert ( !is_full() );
rear = ( rear + 1 ) % array_size;
queue[rear] = value;
}
void delete ()
{
assert ( !is_empty() );
front = ( front + 1 ) % array_size;
}
QUEUE_TYPE first ()
{
assert ( !is_empty() );
return queue[front];
}
int is_empty ()
{
assert ( queue_size > 0 ); //有内存没有存值
return ( rear + 1 ) % ARRAY_SIZE == front;
}
int is_full ()
{
assert ( queue_size > 0 );
return ( rear + 2 ) % ARRAY_SIZE == front;
}
（4）链式队列
#include "queue.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>
#define FALSE 0
typedef struct QUEUE_NODE {
QUEUE_TYPE value;
struct QUEUE_NODE *next;
}QueueNode;
static QueueNode *front;
static QueueNode *rear;
void destroy_queue ()
{
while ( !is_empty() );
delete ();
}
void insert ( QUEUE_TYPE value )
{
QueueNode *new_node;
new_node = ( QueueNode *) malloc ( sizeof( QueueNode ) );
assert ( new_node != NULL );
new_node -> value = value;
new_node -> next = NULL;
//把节点插到队列尾部
if ( rear == NULL )
front = new_node;
else
rear -> next = new_node;
rear = new_node;
}
void delete ()
{
QueueNode *first_node;
assert ( !is_empty() );
first_node = front -> next;
free ( front );
front = first_node;
if ( front == NULL )
rear = NULL;
}
QUEUE_TYPE first ()
{
assert ( !is_empty() );
return front -> value;
}
int is_empty ()
{
return front == NULL;
}
int is_full ()
{
return FALSE;
}