非递归学习树结构（一）--栈和队列的实现

        在开始学习树结构之前，有必要先学习一下栈和队列的知识，我们知道，在树结构中最让人头疼的就是各种递归，据传言，所有的递归都可以用栈来实现，因为递归的过程其实就是进栈出栈的过程，因此，可以把递归改写成对栈的迭代操作，对于是递归好还是迭代好这样的讨论我们就不复述了，没有最好，只有最合适。

        栈和队列是学习树结构之前应该掌握的知识，我们知道树有前中后序遍历，深广优先搜索，如果树的遍历中使用递归方法，则涉及不到栈和队列的概念，但是非递归实现时就得用到stack和queue，前中后序遍历以及深度优先搜索用到了stack结构，广度优先搜索用到了queue结构。其实，即使你不用stack和queue的实现方法，只要你知道其特性：LIFO和FIFO，也不会影响你理解树的非递归遍历。不过下面还是给出了栈和队列的一种另类实现方式，并不是说算法另类，只是结构比较另类，因为这里我们要用纯C来模仿C++的class，即我们要让纯C的结构体有“函数”（纯C结构体是没有函数的，这里所说的“函数”只是表象上的，并不是真正的函数）。

    C语言中的结构体与C++中类有很多的区别，最大的区别应当是C++类中有操作函数，也就是方法，而C的结构体中没有函数。也许有人会质问，以下代码也能编译通过：

#include "stdio.h"

typedef struct __Stu{
	int _val;
	void init(int val);
	void display();
}Stu;

void __Stu::init(int val)
{
	_val = val;
}

void __Stu::display()
{
	printf("%d\n",_val);
}

int main()
{
	Stu s;
	s.init(10);
	s.display();
	return 0;
}

    上面代码g++编译通过，gcc是编译通不过的,或者在VC++下把文件名改为.c结尾，也是编译不通过的。因为纯C的结构体是没有函数的。

 

        那么，有没有什么方式在纯C中做到让“结构体拥有函数”呢？答案是肯定的，C语言跟其他高级语言相比最大的特点是什么？指针，指针可谓是C语言的精髓。所以，我们要实现“结构体拥有函数”，指针是关键。

        下面，我们以实现下栈（stack）和队列（queue）结构为例，简单的做到“用纯C结构体模仿C++中的结构体”（你要问我有毛用，我只能说毛用没有，纯属娱乐）。

/*stack.h*/
typedef struct __Stack{
	ELEM_TYPE**elem_list;/*元素列表，元素是ELEM_TYPE的指针，比如本例中存放的就是树节点的指针，至于不是很理解二级指针的童鞋，可以回炉一下补一补C的指针相关知识*/
	int initsize;/*初始化栈大小*/
	int size;/*栈内实际元素个数*/
	int top_element;/*栈顶元素的偏移*/

	void(*init_size)(struct __Stack* s, size_t size);
	void(*destroy)(struct __Stack* s);
	void(*push)(struct __Stack* s, ELEM_TYPE* value);
	void(*pop)(struct __Stack* s);
	ELEM_TYPE*(*top)(const struct __Stack* s);
	int(*is_empty)(const struct __Stack* s);
	int(*is_full)(const struct __Stack* s);
}Stack;

void registstack(Stack* s);

/*stack.c*/
#include "stack.h"

static int is_empty(const Stack* s)
{
	assert((*s).initsize > 0);
	return (*s).top_element == -1;
}
/*栈是否为满，因为我们使用的是连续列表，因此有有效大小范围*/
static int is_full(const Stack* s)
{
	assert((*s).initsize > 0);
	return (*s).top_element == (*s).initsize - 1;
}

static void init_size(Stack* s, size_t initsize)
{
	/*assert((*s).initsize == 0);*/
	(*s).initsize = initsize;
	(*s).elem_list = (ELEM_TYPE* *)malloc((*s).initsize * sizeof(ELEM_TYPE));
	if ((*s).elem_list == NULL)
		perror("malloc分配失败");
}
/**/
static void destroy(Stack* s)
{
	assert((*s).initsize > 0);
	(*s).initsize = 0;
	free((*s).elem_list);
	(*s).elem_list = NULL;
}
/*入栈*/
static void push(Stack* s, ELEM_TYPE* value)
{
	assert(!is_full(s));
	(*s).top_element += 1;
	(*s).size++;
	(*s).elem_list[(*s).top_element] = value;
}
/*弹出栈顶元素*/
static void pop(Stack* s)
{
	assert(!is_empty(s));
	(*s).size--;
	(*s).top_element -= 1;
}
/*获取栈顶元素*/
static ELEM_TYPE* top(const Stack* s)
{
	assert(!is_empty(s));
	return (*s).elem_list[(*s).top_element];
}

void registstack(Stack* s)
{
	(*s).initsize = 1000;
	(*s).size = 0;
	(*s).top_element = -1;
	(*s).init_size = init_size;
	(*s).destroy = destroy;
	(*s).push = push;
	(*s).pop = pop;
	(*s).top = top;
	(*s).is_empty = is_empty;
	(*s).is_full = is_full;
}

/*test.c*/
#include “stack.h”
int main()
{
	Stack stack;
	RegistAll(&stack);
	stack.init_size(&stack,100);
	stack.push(&stack,10);
	stack.push(&stack,11);
	stack.push(&stack, 12);
	printf("stack.size:%d\n",stack.top_element + 1);
	printf("%d\n", stack.top(&stack));
	stack.pop(&stack);
	printf("stack.size:%d\n", stack.top_element + 1);
	printf("%d\n", stack.top(&stack));

	return 0;
}

        上面代码可以看出，我们使用了函数指针，使得纯C结构体看上去“有了”函数，实质上结构体中只是拥有了函数的指针，并没有拥有函数，函数的指针放在数据区，而函数是放在代码区的，这就是本质区别。

下面在附上实现queue的代码

/*queue.h*/
typedef int RESULT;
typedef int BOOL;

#ifndef SUCCESS 
#define SUCCESS 0
#endif
#ifndef FAILURE
#define FAILURE -1
#endif

typedef struct _Elem{
	ELEM_TYPE* val;
	struct _Elem* pnext;
}Elem;

typedef struct _Queue{
	int size;/*队列大小*/
	Elem* pfont;/*队头指针*/
	Elem* pback;/*队尾指针*/
	void(*initqueue)(struct _Queue* queue);
	RESULT(*push)(struct _Queue* queue, ELEM_TYPE* elem);
	BOOL(*is_empty)(struct _Queue* queue);
	Elem* (*get)(struct _Queue* queue);
	RESULT(*pop)(struct _Queue* queue);
	void(*clear)(struct _Queue* queue);
	void(*display)(struct _Queue* queue);
}Queue;

void registerqueue(Queue* queue);

/*queue.c*/
#include "queue.h"
 
static void initqueue(Queue* queue)
{
     queue->size= 0;
     queue->pback= NULL;
     queue->pfont= NULL;
}
 
static RESULT push(Queue* queue, ELEM_TYPE* val)
{
     Elem* elem =(Elem*)malloc(sizeof(Elem));
     if (!elem)
     {
            perror("mallocerror!!!\n");
            returnFAILURE;
     }
 
     elem->val= val;
     elem->pnext= NULL;
     /*如果是空队列*/
     if(queue->pback == NULL && queue->pfont == NULL)
     {
            /*队尾和队头同时指向第一个结点*/
            queue->pback= elem;
            queue->pfont= elem;
            queue->size++;
     }
     else /*队列不为空*/
     {
            queue->pfont->pnext= elem;/*当前队头结点指向即将入队的结点*/
            queue->pfont= elem;/*队头指针指向新的队头结点*/
            queue->size++;/*队列结点个数增加*/
     }
    
     returnSUCCESS;
}
/*队列是否为空*/
static BOOL is_empty(Queue* queue)
{
     if(queue->size < 1)
            return1;
     return 0;
}
/*根据队列的特点，获取队尾结点  FIFO规则，返回最早进来的元素*/
static Elem* get(Queue* queue)
{
     if(is_empty(queue))
     {
            printf("queueis empty");
            returnNULL;
     }
 
     returnqueue->pback;
}
/*将队尾元素从队列中pop掉*/
static RESULT pop(Queue* queue)
{
     if(is_empty(queue))
     {
            printf("queueis empty");
            returnSUCCESS;
     }
 
     Elem* Elem =queue->pback; /*取得队尾结点的地址*/
     queue->pback= queue->pback->pnext; /*移动队尾指针到下一个结点上*/
     free(Elem);/*释放队尾指针*/
     Elem = NULL;
     queue->size--;
     returnSUCCESS;
}
 
static void clear(Queue* queue)
{
     while(queue->size--)
     {
            Elem*Elem = queue->pback;
            queue->pback= queue->pback->pnext;
            free(Elem);
            Elem= NULL;
     }
     queue->pfont= NULL;
}
 
static void display(Queue* queue)
{
     if(is_empty(queue))
     {
            printf("queueis empty!!!\n");
            return;
     }
 
     Elem* curr =queue->pback;
     while (curr)
     {
            printf("%d\t",curr->val);
            curr= curr->pnext;
     }
}
 
/*注册队列的函数（初始化队列变量的函数指针）*/
void registerqueue(Queue* queue)
{
     queue->initqueue= initqueue;
     queue->clear= clear;
     queue->is_empty= is_empty;
     queue->get= get;
     queue->push= push;
     queue->pop= pop;
     queue->display= display;
}

/*test.c*
#include "Queue.h"

int main()
{
	Queue queue;
	registerqueue( &queue );
	queue.initqueue(&queue);
	queue.push(&queue, 25);
	queue.push(&queue, 35);
	queue.push(&queue, 45);
	queue.push(&queue, 55);
	queue.display(&queue);
	Node* node = queue.get(&queue);
	printf("\n%d\n",node->val);
	queue.pop(&queue);
	queue.display(&queue);
	printf("\n");
	queue.clear(&queue);
	return 0;
}

        通过以上stack和queue两种结构的实现过程我们可以看到，在stack中我们使用了顺序存储的方式，即一开始就为栈申请一个1000的空间，而在queue中我们并没有这样做，而是动态申请空间，即进来一个元素，我们申请一个node空间，众所周知，访问顺序列表比方位链表要快，而且链表占用多有的空间指向下一个元素。

        这样做的原因是，在stack中，栈底指针是不变的，永远指向栈底，而且本文实现stack只用了一个栈底指针，并没有栈顶指针，因为栈顶指针不是必须的，只需要一个元素个数，加上栈底指针就可以访问所有的栈元素。

        如果在queue中如果也用顺序存储，随着进进出出的元素增多，最后queue所能保存的元素也会越来越少，因为queue的两个指针都在移动，例如提前申请的空间是从0x12345678 – 0x12346677(假设一个元素占用一个字节，char类型)，申请了1000个元素的空间，随着出队操作，queue->back指针是一直往前移动的，一开始是指向0x12345678的，如果出队列999次，queue->就会指向0x123456677,再移动就超出了申请的空间，一种办法是当queue->back距离起点0x12345678一定距离后，将队列里的元素整体移动到原始起点开始，及reset一下队列尾部元素的地址到原始起点地址处。如果这样来回的reset，对于队列的操作效率肯定是由影响的。因此我这里采用链表而不是顺序表来表示队列，虽然占用了多于空间，但是也避免了reset的过程，而且链表相对于顺序表，更加灵活。

        以上代码是后面实现树遍历和搜索需要用到的代码，不过也可以单独调试测试，下面是下载地址。

栈和队列的实现代码

代码写的比较粗糙，仅为介绍原理所用，错误之处，望指出。