没有哪个简单之说，只是适用范围不一样

像搜索最短路径这些的很明显要是用广搜，因为广搜的特性就是一层一层往下搜的，保证当前搜到的都是最优解，当然，最短路径只是一方面的应用，像什么最少状态转换也是可以应用的。

深搜就是优先搜索一棵子树，然后是另一棵，它和广搜相比，有着内存需要相对较少的优点，八皇后问题就是典型的应用，这类问题很明显是不能用广搜去解决的。或者像图论里面的找圈的算法，数的前序中序后序遍历等，都是深搜

[quote]没有哪个简单之说，只是适用范围不一样

像搜索最短路径这些的很明显要是用广搜，因为广搜的特性就是一层一层往下搜的，保证当前搜到的都是最优解，当然，最短路径只是一方面的应用，像什么最少状态转换也是可以应用的。

深搜就是优先搜索一棵子树，然后是另一棵，它和广搜相比，有着内存需要相对较少的优点，八皇后问题就是典型的应用，这类问题很明显是不能用广搜去解决的。或者像图论里面的找圈的算法，数的前序中序后序遍历等，都是深搜[/quote]

我准备写这几个算法，但觉得有些难以入手．

typedef int InfoType;
#define MAXV 100
/*定义邻接矩阵*/
typedef struct
{
    int no;
    InfoType info;
}VertexType;
typedef struct
{
    int edges[MAXV][MAXV];
    int vexnum,arcnum;
    VertexType vexs[MAXV];
}MGraph;//图的邻接矩阵类型
/*定义邻接表*/
typedef struct ANode
{
    int adjvex;
    struct ANode* nextarc;
    InfoType info;
}ArcNode;
typedef int Vertex;
typedef struct Vnode
{
    Vertex data;
    ArcNode* firstarc;
}VNode;
typedef VNode AdjList[MAXV];
typedef struct
{
    AdjList adjlist;
    int n,e;
}ALGraph;//图的邻接表类型
void DFS1(ALGraph* G,int v)/*非递归算法*/
{
    VNode St[MAXV];
    int top=-1;
    for(int i=0;i<G->n;i++)
        visited[i]=0;
    top++;
    if(visited[v]!=1)
    {
        printf("%d ",v);
        visited[v]=1;
        St[top]=G->adjlist[v];
    }
    while(top>-1)
    {
        ArcNode* p=St[top].firstarc;
        VNode t=St[top];
        top--;
        while(p!=NULL)
        {
            if(visited[p->adjvex]!=1)
            {
                top++;
                St[top]=G->adjlist[p->adjvex];
                t=St[top];
            }
            p=p->nextarc;
        }
        if(visited[t.data]!=1)
        {
            printf("%d ",t.data);
            visited[t.data]=1;
        }
    }
    printf("\n");
}
void BFS(ALGraph* G,int v)/*非递归算法*/
{
    int Qu[MAXV];
    int front,rear;
    ArcNode* p;
    front=rear=0;
    for(int i=0;i<G->n;i++)
        visited[i]=0;
    if(visited[v]==0)
    {
        Qu[front]=v;
        rear=(rear+1)%MAXV;
        printf("%d ",v);
        visited[v]=1;
    }
    while((rear-front)%MAXV!=0)
    {
        p=G->adjlist[Qu[front]].firstarc;
        while(p!=NULL)
        {
            if(visited[p->adjvex]==0)
            {
                Qu[rear]=p->adjvex;
                printf("%d ",p->adjvex);
                visited[p->adjvex]=1;
                rear=(rear+1)%MAXV;
            }
            p=p->nextarc;
        }
        front=(front+1)%MAXV;
    }
}
这是邻接矩阵的广度优先和宽度优先遍历

[quote]typedef int InfoType;
#define MAXV 100
/*定义邻接矩阵*/
typedef struct
{
    int no;
    InfoType info;
}VertexType;
typedef struct
{
    int edges[MAXV][MAXV];
    int vexnum,arcnum;
    VertexType vexs[MAXV];
}MGraph;//图的邻接矩阵类型
/*定义邻接表*/
typedef struct ANode
{
    int adjvex;
    struct ANode* nextarc;
    InfoType info;
}ArcNode;
typedef int Vertex;
typedef struct Vnode
{
    Vertex data;
    ArcNode* firstarc;
}VNode;
typedef VNode AdjList[MAXV];
typedef struct
{
    AdjList adjlist;
    int n,e;
}ALGraph;//图的邻接表类型
void DFS1(ALGraph* G,int v)/*非递归算法*/
{
    VNode St[MAXV];
    int top=-1;
    for(int i=0;i<G->n;i++)
        visited[i]=0;
    top++;
    if(visited[v]!=1)
    {
        printf("%d ",v);
        visited[v]=1;
        St[top]=G->adjlist[v];
    }
    while(top>-1)
    {
        ArcNode* p=St[top].firstarc;
        VNode t=St[top];
        top--;
        while(p!=NULL)
        {
            if(visited[p->adjvex]!=1)
            {
                top++;
                St[top]=G->adjlist[p->adjvex];
                t=St[top];
            }
            p=p->nextarc;
        }
        if(visited[t.data]!=1)
        {
            printf("%d ",t.data);
            visited[t.data]=1;
        }
    }
    printf("\n");
}
void BFS(ALGraph* G,int v)/*非递归算法*/
{
    int Qu[MAXV];
    int front,rear;
    ArcNode* p;
    front=rear=0;
    for(int i=0;i<G->n;i++)
        visited[i]=0;
    if(visited[v]==0)
    {
        Qu[front]=v;
        rear=(rear+1)%MAXV;
        printf("%d ",v);
        visited[v]=1;
    }
    while((rear-front)%MAXV!=0)
    {
        p=G->adjlist[Qu[front]].firstarc;
        while(p!=NULL)
        {
            if(visited[p->adjvex]==0)
            {
                Qu[rear]=p->adjvex;
                printf("%d ",p->adjvex);
                visited[p->adjvex]=1;
                rear=(rear+1)%MAXV;
            }
            p=p->nextarc;
        }
        front=(front+1)%MAXV;
    }
}
这是邻接矩阵的广度优先和宽度优先遍历[/quote]

好．

1024~1031
 一个星期以前，我提出了这个问题．
现在我可以自己回答这个问题了．

显然是深搜要较广搜简单．
为什么呢？
因为在广搜中必须要用到一个＂队列＂来控制遍历的进程．
这个队列有点类似于层次遍历法中的树．

而用邻接表来进行深搜和广搜要比邻接矩阵直观和简单一些．

这个帖子自己顶一下，然后要开始难度较大的学习，还是有些累的．

其实两个算法确实都差不多，如果说队列的应用可以忽略不计的话．

到这个网站看有人的算法没有
算法源码吧  [url=http://www.sfcode.cn/]http://www.sfcode.cn/[/url]