非遞歸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

　　編譯運行結果：

　　可以看出結果是符合預期的。代碼中對左右子樹的處理，是對臨接節點處理的一種特殊情況。