CLRS2e读书笔记—Chapter10

本章为基本数据结构的一些操作，很基础，当然也很重要。数据结构必须是泛型的，但是C对于泛型的支持只有通过void*强制转换，而且这也不是万能的，比较好的书籍可以参看《C interfaces and implementions》，当然这方面的代码是很成熟的。

ADT在C中的实现大致通过三种方式：静态数组、动态数组和链表。如果不使用指针，那么必须用宏来实现Stack_Type的泛型，push,pop和top的操作数类型都和Stack_Type关联。静态数组的stack实现就是简单的：

#define Stack_Type int
#define Stack_Size 2048
//static array
Stack_Type G_Stack_Node[Stack_Size];
void push(Stack_Type elem);
Stack_Type pop(void);
Stack_Type top(void);

由于引入了全局静态数组，带来了诸如溢出、导出不便的很多问题，所以一般不会采用这种方式。动态数组可以参照std::vector的内存管理方式，如：

#include <malloc.h>
#include <stdlib.h>
#include <assert.h>

#define Stack_Type int
typedef struct stack{
    size_t stack_size;
    size_t stack_limit;
    Stack_Type* stack_name;
}Stack;

Stack* stack_create(void);
{
    Stack* s=malloc(sizeof(*s));
    assert(s);
    s->size=0;
    s->stack_limit=8;
    s->stack_name=(Stack_Type*)malloc(8*sizeof Stack_Type);
}
void push(Stack* s,Stack_Type value)
{
    if(s->stack_size==s->stack_limit)
    {
        Stack_Type* temp=s->stack_name;
        s->stack_limit*=2;
        s->stack_name=(Stack_Type*)malloc(s->stack_limit * sizeof(Stack_Type);
        memcpy(s->stack_name,temp,s->stack_size * sizeof(Stack_Type);
        free(temp);
    }
    s->stack_name[s->stack_size]=value;
    s->stack_size+=1;
}
Stack_Type pop(Stack* s)
{
    if(!s->stack_size)exit(EXIT_FAILTRUE);
    Stack_Type temp=s->stack_name[--s->stack_size];
    return temp;
}
Stack_Type top(Stack* s)
{
    if(!s->stack_size)exit(EXIT_FAILTRUE);
    return s->stack_name[s->stack_size-1];
}
void stack_free(Stack* s)
{
    free(s.stack_name);
    free(s);
}

还有就是采用链表的形式实现，需要定义链表结点，下面的实现没有依赖Stack_Type宏，而是使用了泛型指针：

struct node{
    void* value;
    struct node* link;
};
struct stack{
    node* stack_top;
    size_t count;
};
typedef struct stack* stack;

stack stack_create(void)
{
    stack s=(stack)malloc(sizeof(stack));
    assert(s);
    s->count=0;
    s->stack_top=NULL;
    return s;
}
void push(stack s,void* v)
{
    struct node* tmp=s->stack_top;
    s->stack_top=(node*)malloc(sizeof(node));
    s->stack_top->link=tmp;
    s->stack_top->value=v;
    s->count+=1;
}
void* top(stack s)
{
    if(s->stack_top==NULL)
        exit(EXIT_FAILTURE);
    void* r=s->stack_top->value;
    return r;
}
void* pop(stack s)
{
    void* r=top(s);
    s->stack_top=s->stack_top->link;
    s->count-=1;
    return r;
}
void stack_free(stack s)
{
    while(s->stack_top)
    {
        node* tmp=s->stack_top;
        s->stack_top=s->stack_top->link;
        free(tmp);
    }
    free(s);
}

队列的实现和接口类似于栈，不同的是队列需要两个指针（或下标），分别指出队列尾部（超出末端的）和头部。如果基于链表来实现队列，不用考虑如何判定边界条件（也可以使用哨兵来简化边界条件），如果基于数组实现，不使用循环数组会造成空间浪费，使用循环数组要注意边界条件不能通过下标的大小关系简单判定。

链表的实现非常简单，在《Pointers on c》这本书里面还讲述了使用指向link字段的指针来简化搜索的技巧（使用指向结点的指针的指针而不是link字段作为循环更迭量）。

树的实现依赖于双链表，可以用两个指针表示任意子女数的树，方法是存放一个指向其最左子节点的指针和一个指向其右边兄弟的指针。

二叉树的遍历：

递归实现很简单，略过…非递归使用堆栈的话，主要有两种思想：

一种是考虑迭代，核心是“访问”。对于前序和中序，节点一旦访问完毕，就可以弹出了，因为我们能保证已弹出节点的所有子树都被访问过。对于后续遍历，弹出节点的同时必须有方法确认节点已经访问过，因为我们无法确定其右子树是否已经访问过（即是入栈访问后弹出还是压根没有入栈过）。所以下面后续遍历的版本1增加了一个变量来确认其右子树已经访问过。（没访问过就入栈右子树，访问过就可以弹出这个节点了）。

第二种是模拟堆栈，核心是“入栈”，即如何布置入栈顺序。比如前序的访问顺序是先根再左后右，那么入栈顺序就是相反的先右后左最后根，其他的类似推理。那么对于栈顶元素何时访问呢？对于前序，是无条件的，对于中序是其左子树已访问过，对于后序则是左右子树均访问过。因此需要一个标记位来确定是否已经访问过，没有访问过就入栈。

#include "stack.h"
bool is_visited(bin_tree* T)
{
    if(!T)return true;              //not existed is equal to visited
    else return T->isvisited;
}
//使用迭代的思想
void preorder_traversal(bin_tree* T)
{
    stack S;
    while(T || !is_empty(S))
    {
        if(T)
          {  
             visit(T);
             push(S,T);
             T=left(T);
          }
          else 
          { 
             T=pop(S);
             T=right(T);
          }
}
//直接对递归进行模拟
//即仅考虑入栈和出栈顺序
//状态机
void preorder_traversal_ver2(bin_tree* T)
{
    stack S;
    if(T)push(S,T)
    while(!is_empty(S))
    {
        bin_tree* tmp=pop(S);
        visit(tmp);
        if(right(T))push(S,right(T));
        if(left(T))push(S,left(T));
    }
}
void inorder_traversal(bin_tree* T)
{
    stack S;
    while(T || !is_empty(S))
    {
      while(T)
      {
        push(S,T);
        T=left(T);
      }
      if(!is_empty(S))
      {
        T=pop(S);
        visit(T);
        if(right(T))T=right(T);
      }
    }
}

void inorder_traversal_ver2(bin_tree* T)
{
    stack S;
    bin_tree* tmp;
    if(T)push(S,T)
    while(!is_empty(S))
    {
        tmp=pop(S);             //attention here.
        if(!is_visited(left(tmp)))     //left tree is existed and not visited
        {
            if(right(tmp))push(S,right(tmp));
            push(S,tmp);
            push(S,left(tmp));
        }
        else{
            visit(tmp);
            set_visited(tmp);
            if(!left(tmp) && right(tmp))push(S,right(tmp)); //left tree is not existed and right existed
        }
    }
} 
void postorder_traversal(bin_tree* T)
{
    stack S;
    bin_tree* previsited=NULL;
    while(T || !is_empty(S))
    {
        while(T)
        {
            push(S,T);
            T=left(T);
        }
        T=top(S);
        if(!right(T) || right(T)==previsited)
        {
            visit(T);
            previsited=T;
            pop(S);
            T=NULL;         //to prevent from pushing left tree twice
        }else
        T=right(T);
    }
}
         
void postorder_traversal_ver2(bin_tree* T)
{
    stack S;
    bin_tree* tmp;
    if(T)push(S,T);
    while(!is_empty(S))
    {
      tmp=pop(S);
      if(is_visited(right(tmp)) && is_visited(left(tmp)))       //left and right both are visited
      {
         visit(tmp);
         set_visited(tmp);
         pop(S);
      }else{
      if(!is_visited(right(tmp)))                               //right first
        push(S,right(tmp));
      if(!is_visited(left(tmp)))                                //then left
        push(S,left(tmp));
     }
    }
}

当然除了链表外，也可以考虑使用其他技巧实现，比如堆。

本章的习题先略过了…