C和指针之学习笔记（6）

第17章 经典数据结构类型

1. 堆栈

堆栈接口提供三种基本的操作：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;

}