非递归DFS遍历

• 深度优先搜索DFS

　　DFS就是回溯法，用递归的方法是很自然的。那么该如何递归呢？

　　简单的说就是:1、如果当前节点没有被搜索过，那么处理当前节点，并标记为搜索过；如果当前节点已经被搜索过，退出；

　　　　　　　　2、递归遍历所有没有被搜索过的临接节点。

　　注意，第一步的退出条件。递归必须有退出条件，否则会出现死循环。

　　对任意节点调用上述DFS函数，将搜索到所有和该节点联通的节点。

 

• 非递归方式实现DFS

　　递归和栈总是联系在一起的，如果不采用递归，那么就需要自己维护一个栈。

　　1、从某节点开始，入栈；

　　2、当栈不为空时，循环3、4；当栈为空时，退出循环；

　　3、对栈顶节点处理，标记为搜索过；注意，如果该节点的某个临接节点处理完后，会回溯到该节点，注意不要重复处理该节点。

　　4、对栈顶节点，任意找一个没有搜索过的临接节点，入栈(注意只入栈一个临接节点，DFS就是找到一条路一直走下去，走不通了再回溯)；如果发现该栈顶节点所有的临接节点都被搜索过，或者该节点没有临接节点，将该栈顶节点出栈。　

 

• 实现代码

　　下面是DFS的递归和非递归的代码，C实现。为了简单起见，搜索对象为下图所示的满二叉树，用数组表示。

　　

　　

#include<stdio.h>
#include<string.h>

#define true 1
#define false 0
#define ok 0
#define error -1

#define MAX_LEN  20
#define TREE_LEN  10

typedef struct
{
    int arr[MAX_LEN];
    int top;
}STACK;

int is_empty(STACK *s)
{
    if(s == NULL )
    {
        printf("null param.\n");
        return error;
    }        
    if(0 == s->top)
        return true;
    else
        return false;
}

int is_full(STACK *s)
{
    if(s == NULL )
    {
        printf("null param.\n");
        return error;
    }        
    if( MAX_LEN == s->top)
        return true;
    else 
        return false;
}
void push(STACK* s,int elem)
{
    if(s == NULL )
    {
        printf("null param.\n");
        return;
    }
        
    if(is_full(s))
    {
        printf("is full.\n");
        return;
    }

    s->arr[s->top++] = elem;
}

void pop(STACK* s)
{
    if(s == NULL )
    {
        printf("null param.\n");
        return;
    }
        
    if(is_empty(s))
    {
        printf("is empty.\n");
        return;
    }    

    s->arr[--s->top] = 0;
}

int top(STACK* s)
{
    if(s == NULL )
    {
        printf("null param.\n");
        return error;
    }
        
    if(is_empty(s))
    {
        printf("is full.\n");
        return error;
    }        

    return s->arr[s->top-1];
}

void dfs(STACK* p_stack,int *p_tree,int tree_len)
{
    int visited[tree_len];
    int temp = 0;
    int treeIndex = 0;

    memset(visited,0,sizeof(visited));
    
    push(p_stack,p_tree[treeIndex]);
    while(!is_empty(p_stack))
    {
        temp = top(p_stack);

        if(treeIndex < tree_len && !visited[treeIndex])
        {
            printf("%d->",temp);
            visited[treeIndex] = true;            
        }

        if(2*treeIndex+1 < tree_len && !visited[2*treeIndex+1])
        {
            push(p_stack,p_tree[2*treeIndex+1]);    
            treeIndex = 2*treeIndex+1;
        }
        else if( 2*treeIndex+2 < tree_len && !visited[2*treeIndex+2] )
        {
            push(p_stack,p_tree[2*treeIndex+2]);
            treeIndex = 2*treeIndex+2;
        }
        else
        {
            pop(p_stack);
            treeIndex = (treeIndex-1)>>1;
        }        
    }
    printf("\n");
}


void dfs_reverse(int *p_tree,int*p_visited,int tree_len,int treeIndex)
{
    int left,right = 0;

    if(treeIndex < tree_len && !p_visited[treeIndex])
    {
        printf("%d->",p_tree[treeIndex]);
        p_visited[treeIndex] = true;

        left = 2*treeIndex+1;
        if( left < tree_len && !p_visited[left])
            dfs_reverse(p_tree,p_visited,tree_len,left);

        right = 2*treeIndex+2;
        if( right < tree_len && !p_visited[right])
            dfs_reverse(p_tree,p_visited,tree_len,right);
    }
}


int tree[TREE_LEN] = {1,2,3,4,5,6,7,8,9,10};
STACK stack ;

#ifdef REVERSE
int main()
{
    int visited[TREE_LEN] = {0};
    memset(visited,0,sizeof(visited));

    dfs_reverse(tree,visited,TREE_LEN,0);
}
#else
int main()
{
    memset(&stack,0,sizeof(stack));
    dfs(&stack,tree,TREE_LEN);
}
#endif

　　编译运行结果：

　　可以看出结果是符合预期的。代码中对左右子树的处理，是对临接节点处理的一种特殊情况。