精华内容
下载资源
问答
  • DFS 深度遍历

    2018-11-09 20:56:34
    public abstract class DFS extends GraphTraverse { //变量 protected static int clock = 0;//遍历过程中使用的计时钟 ...//深度优先遍历算法 protected Object traverse(Vertex v, Object...
    public abstract class DFS extends GraphTraverse {
    //变量
    	protected static int clock = 0;//遍历过程中使用的计时钟
    
    //构造方法
    	public DFS(Graph g) { super(g); }
    
    //深度优先遍历算法
    	protected Object traverse(Vertex v, Object info) {//从顶点v出发,做深度优先查找
    		if (UNDISCOVERED != v.getStatus())	return null;//跳过已访问过的顶点(针对非连通图)
    		v.setDStamp(clock++);		v.setStatus(DISCOVERED);	visit(v, info);//访问当前顶点
    		for (Iterator it = v.outEdges(); it.hasNext();) {//检查与顶点v
    			Edge e = (Edge)it.getNext();//通过边e = (v, u)
    			Vertex u = (Vertex)e.getVPosInV(1).getElem();//相联的每一顶点u
    			switch (u.getStatus()) {//根据u当前的不同状态,分别做相应处理
    				case	UNDISCOVERED ://若u尚未被发现,则
    					e.setType(TREE);//e被归类为“树边”
    					traverse(u, info);//从u出发,继续做深度优先查找
    					break;
    				case	DISCOVERED ://若u已经被发现,但对其访问尚未结束,则
    					e.setType(BACKWARD);//将e归类为“后向跨边”
    					break;
    				default ://VISITED,即对u的访问已经结束
    					if (u.getDStamp() < v.getDStamp())//若相对于v,u被发现得更早,则
    						e.setType(CROSS);//将e归类为“横跨边”
    					else//否则
    						e.setType(FORWARD);//将e归类为“前向跨边”
    					break;
    			}
    		}//至此,v的所有邻居都已访问结束,故
    		v.setFStamp(clock++);	v.setStatus(VISITED);//将v标记为VISITED
    		return null;//然后回溯
    	}
    }

     

    展开全文
  • 利用dfs深度遍历

    2020-12-28 17:40:04
    } // 执行深度优先遍历,搜索可能的结果 dfs("", n, n, res); return res; } /** * @param curStr 当前递归得到的结果 * @param left 左括号还有几个可以使用 * @param right 右括号还有几个可以使用 * @param res ...

    数字 n 代表生成括号的对数,请你设计一个函数,用于能够生成所有可能的并且 有效的 括号组合。

    示例:

    输入:n = 3
    输出:[
    “((()))”,
    “(()())”,
    “(())()”,
    “()(())”,
    “()()()”
    ]

    当前左右括号都有大于 0 个可以使用的时候,才产生分支;
    产生左分支的时候,只看当前是否还有左括号可以使用;
    产生右分支的时候,还受到左分支的限制,右边剩余可以使用的括号数量一定得在严格大于左边剩余的数量的时候,才可以产生分支;
    在左边和右边剩余的括号数都等于 00 的时候结算。

    在这里插入图片描述

    import java.util.ArrayList;
    import java.util.List;
    
    public class Solution {
    
        // 做减法
    
        public List<String> generateParenthesis(int n) {
            List<String> res = new ArrayList<>();
            // 特判
            if (n == 0) {
                return res;
            }
    
            // 执行深度优先遍历,搜索可能的结果
            dfs("", n, n, res);
            return res;
        }
    
        /**
         * @param curStr 当前递归得到的结果
         * @param left   左括号还有几个可以使用
         * @param right  右括号还有几个可以使用
         * @param res    结果集
         */
        private void dfs(String curStr, int left, int right, List<String> res) {
            // 因为每一次尝试,都使用新的字符串变量,所以无需回溯
            // 在递归终止的时候,直接把它添加到结果集即可,注意与「力扣」第 46 题、第 39 题区分
            if (left == 0 && right == 0) {
                res.add(curStr);
                return;
            }
    
            // 剪枝(如图,左括号可以使用的个数严格大于右括号可以使用的个数,才剪枝,注意这个细节)
            if (left > right) {
                return;
            }
    
            if (left > 0) {
                dfs(curStr + "(", left - 1, right, res);
            }
    
            if (right > 0) {
                dfs(curStr + ")", left, right - 1, res);
            }
        }
    }
    
    
    展开全文
  • //DFS深度遍历 #include <iostream> using namespace std; char maps[10][10]; bool vis[10]; int n,k,y,ans; void DFS(int x,int num) //x为行数,num为此时棋子的数量 { if(num==0) //当...
  • java实现DFS深度遍历二叉树

    千次阅读 2018-04-10 23:04:22
    用栈实现DFS public static &lt;T extends Comparable&lt;T&gt;&gt; void dfs(BTree&lt;T&gt; tree) { dfs(tree.root); System.out.println(); } private static &lt;T extends...

    用栈实现DFS

        public static <T extends Comparable<T>> void dfs(BTree<T> tree) {
    		dfs(tree.root);
    		System.out.println();
    	}
    
    	private static <T extends Comparable<T>> void dfs(BTree<T>.BNode node) {
    		if (node == null)
    			return;
    		stack.push(node);
    		System.out.print(node.value + "  ");
    		dfs(node.left);
    		dfs(node.right);
    		stack.pop();
    	}

    展开全文
  • "深度遍历" endl ; DFSTraverse ( Graph , visited ) ; cout endl "广度遍历" endl ; BFSTraverse ( Graph , visited ) ; system ( "pause" ) ; } 测试效果 开发环境:Visual ...

    在这里插入图片描述

    邻接表如图所示

    这里没有加上权重,实际数据结构是有的
    在这里插入图片描述

    代码

    #include <iostream>
    #include <string>
    #include <vector>
    #define  VertexType string
    typedef int EdgeType;
    using namespace std;
    
    /********链表队列LinkQueue************/
    typedef int QElemType;
    
    /*LinkQueue节点数据结构*/
    typedef struct QNode
    {
    	QElemType data;
    	struct QNode *next;
    }QNode, *QueuePtr;
    
    /*LinkQueue数据结构*/
    typedef struct
    {
    	QueuePtr front, rear;
    }LinkQueue;
    
    /*LinkQueue初始化*/
    bool InitQueue(LinkQueue &Q)
    {
    	QNode *temp = new QNode;
    	if (!temp) return false;
    	temp->data = -1;
    	temp->next = NULL;
    	Q.front = Q.rear = temp;
    	return true;
    }
    
    /*判断LinkQueue是否为空*/
    bool isEmpty(const LinkQueue Q)
    {
    	return Q.front->next == NULL;
    }
    
    /*入队操作*/
    bool EnQueue(LinkQueue &Q, QElemType i)
    {
    	QNode *temp = new QNode;
    	if (!temp) return false;
    	temp->data = i;
    	temp->next = NULL;
    	Q.rear->next = temp;
    	Q.rear = temp;
    
    	return true;
    }
    
    /*出队操作*/
    QElemType DeQueue(LinkQueue &Q)
    {
    	QNode *ptr = Q.front->next;
    	if (ptr->next)
    		Q.front->next = ptr->next;
    	else
    		Q.front->next = NULL;
    	int Data = ptr->data;
    	delete(ptr);
    	return Data;
    }
    /***********邻接表数据结构*************/
    
    /*相邻接点的数据结构*/
    typedef struct EdgeNode 
    {
    	int adivex;         //邻接点下标
    	EdgeType weight;    //顶点与邻接点之间的权重
    	struct EdgeNode *next;//指向顶点的下一个邻接点
    }EdgeNode;
    
    /*顶点的数据结构*/
    typedef struct VertexNode
    {
    	VertexType data;    //顶点存储的数据类型
    	EdgeNode *firstedge;//指向第一个邻接点
    }VertexNode,*AdjList;
    
    /*图的数据结构*/
    typedef struct        
    {
    	AdjList adjList;
    	int numVertexes, numEdges;
    }GraphAdiList;
    
    /*创建图*/
    void CreateALFraph(GraphAdiList &G)
    {
    	cout << "请输入顶点数和边数" << endl;
    	cin >> G.numVertexes >> G.numEdges;
    	cout << "请输入每个顶点的名称" << endl;
    	G.adjList = new VertexNode[G.numVertexes];
    	for (int i = 0; i < G.numVertexes; i++)
    	{
    		cin >> G.adjList[i].data;
    		G.adjList[i].firstedge = NULL;
    	}
    
    	int i, j ,Weight;
    	for (int k = 0; k < G.numEdges; k++)
    	{
    		cout << "请输入第"<<k+1<<"条边上的顶点序号和权重" << endl;
    		cin >> i >> j>> Weight;
    
    		/*头插法将节点接到邻接表上*/
    		EdgeNode *temp1 = new EdgeNode;
    		temp1->adivex = j;
    		temp1->weight = Weight;
    		temp1->next = G.adjList[i].firstedge;
    		G.adjList[i].firstedge = temp1;
    
    		EdgeNode *temp2 = new EdgeNode;
    		temp2->adivex = i;
    		temp2->weight = Weight;
    		temp2->next = G.adjList[j].firstedge;
    		G.adjList[j].firstedge = temp2;	
    	}
    }
    
    /*输出邻接表*/
    void Display(const GraphAdiList G)
    {
    	for (int i = 0; i < G.numVertexes; i++)
    	{
    		cout << G.adjList[i].data << "->{";
    		EdgeNode *ptr = G.adjList[i].firstedge;
    		while (ptr)
    		{
    			cout << " [" << ptr->adivex<<","<<ptr->weight<<"]";
    			ptr = ptr->next;
    		}
    		cout << " }" << endl;
    	}
    }
    
    void DFS(GraphAdiList G, int i,vector<bool> &visited)
    {
    	visited[i] = true;
    	cout << G.adjList[i].data<<" ";
    	EdgeNode *ptr = G.adjList[i].firstedge;
    	while (ptr)
    	{
    		if (!visited[ptr->adivex])
    			DFS(G, ptr->adivex,visited);
    		ptr = ptr->next;
    	}
    }
     
    void DFSTraverse(GraphAdiList G, vector<bool> &visited)
    {
    	for (int i = 0; i < G.numVertexes; i++)
    		visited[i] = false;
    
    	/*如果是连通图就不必循环*/
    	for (int i = 0; i < G.numVertexes; i++)
    	{
    		if (!visited[i])
    			DFS(G, i, visited);
    	}
    
    	/*DFS(G, i, visited);*/
    }
    
    void BFSTraverse(GraphAdiList G, vector<bool> &visited)
    {
    	LinkQueue Q;
    	InitQueue(Q);
    
    	for (int i = 0; i < G.numVertexes; i++)
    		visited[i] = false;
    
    	for (int i = 0; i < G.numVertexes; i++)
    	{
    		if (!visited[i])
    		{
    			visited[i] = true;
    			cout << G.adjList[i].data << " ";
    			EnQueue(Q, i);
    			while (!isEmpty(Q))
    			{
    				int index = DeQueue(Q);
    				EdgeNode *ptr = G.adjList[index].firstedge;
    				while (ptr)
    				{
    					if (!visited[ptr->adivex])
    					{
    						visited[ptr->adivex] = true;
    						cout << G.adjList[ptr->adivex].data << " ";
    						EnQueue(Q, ptr->adivex);
    					}
    					ptr = ptr->next;
    				}
    			}
    		}
    		
    	}
    }
    
    int main()
    {
    	GraphAdiList Graph;
    	CreateALFraph(Graph);
    	vector<bool> visited(Graph.numVertexes);//定义访问数组
    
    	cout << "邻接表如下:" << endl;
    	Display(Graph);
    
    	cout << "深度遍历" << endl;
    	DFSTraverse(Graph, visited);
    
    	cout <<endl<< "广度遍历" << endl;
    	BFSTraverse(Graph, visited);
    
    	system("pause");
    }
    

    测试效果

    在这里插入图片描述
    开发环境:Visual Studio 2017
    参考书籍:《大话数据结构》

    展开全文
  • Given a digit string, return all possible letter combinations that the number could represent. ...A mapping of digit to letters (just like ...//遍历到最深一层,依次往上一层返回遍历 } } } }
  • 深度遍历DFS&广度遍历BFS 定义 深度遍历DFS: 深度优先搜索属于图算法的一种,英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止。 广度遍历BFS: 广度遍历...
  • 深度遍历DFS 递归 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} ...
  • DFS深度优先遍历

    2021-05-22 20:53:00
    图分支算法 访问-遍历{DFS深度优先遍历),BFS(广度优先遍历)} #include<bits/stdc++.h> using namespace std; const int maxn = 105; vector<int> e[maxn]; int bk[maxn]; // 某个点是否被访问 //...
  • 采用深度优先算法(DFS遍历有向无环图寻找最优路径,经过优化的深度优先算法,在遍历有向无环图的时候保存路径,并计算路径权值,最总返回最优路径及最有路径的权值
  • DFS深度优先遍历算法,VS2010环境,可运行,数据是自己随便编的
  • 搜索或者遍历主要涉及以下三点内容 每个节点都要访问一次 每个节点仅仅访问一次 对于节点的访问顺序不同...[深度遍历执行顺序](https://img-blog.csdnimg.cn/20200328221856510.jpg?x-oss-process=image/water...
  • poj 2488——dfs深度优先遍历 //给行数列数,求问能否遍历,给出字典序的一种遍历
  • } 深度遍历就像是递归对每一个结点遍历完了之后才遍历地位相同的结点。 bool isBipartite(int** graph, int graphSize, int* graphColSize) { int* color = (int*)malloc(sizeof(int) * graphSize); memset(color, ...
  • 目录一、图的遍历介绍二、图的深度优先搜索(Depth First Search)三、图的深度优先遍历算法步骤四、图的深度优先遍历示例需求五、图的深度优先遍历代码示例 一、图的遍历介绍 所谓图的遍历,即是对结点的访问。一个...
  • 问题及代码: ...*问题描述:利用图算法库实现深度优先(DFS)遍历 */ 1、graph.h的代码(见图基本算法库) 2、graph.cpp的代码(见图基本算法库) 3、main.cpp的代码 #include #include #include "gr
  • 采用深度优先算法(DFS遍历有向无环图寻找最优路径,经过优化的深度优先算法,在遍历有向无环图的时候保存路径,并计算路径权值,最总返回最优路径及最有路径的权值
  • DFS 深度优先遍历

    2016-08-30 11:28:39
    图的样子: DFS.c #include ...图的深度优先遍历 vertex是邻接矩阵,每一行代表一个顶点,每一个元素代表与其它顶点是否有连接。 color[8]是一个染色数组 用于区分 是否已经走过这个vertex. DF
  • 数据结构DFS深度优先遍历非递归算法实现,是自己编写的,可靠。
  • 文章目录思路文章参考代码深度遍历DFS)广度遍历(BFS)Node类遍历方法接口main方法类 思路文章参考 Java实现深度优先遍历和广度优先遍历 代码 深度遍历DFS) package tree; import java.util.Stack; /** * 深度...
  • 由于一直对广度优先遍历深度优先遍历不是特别清楚,希望写下这篇文章加深自己的印象,并且能写出二叉树的广度优先遍历深度优先遍历的代码。 广度优先遍历(层次遍历) 例如: 广度优先遍历的结果:A B C D E 其实...
  • DFS深度优先遍历理解

    千次阅读 2019-04-17 00:10:34
    文章目录一、DFS1.DFS原理2.剪枝二、树的DFS1.部分和问题三、矩阵迷宫1.八联通 一、DFS 1.DFS原理 DFS(Depth First Search) 从某个状态开始,不断地转移状态直到无法转移,然后退回到前一步的状态,继续转移到...
  • DFS深度优先遍历算法详解与实现

    千次阅读 2018-12-01 15:26:21
    DFS深度优先遍历算法详解与实现 概括:深度优先是沿着一条路一直走到底,然后进行回溯 该算法是基于图的邻接表存储实现的 图的邻接表存储方式 注意,邻接表中边表节点中存储的值是该节点在数组中的索引值,而...
  • 图的【广度优先】与【深度优先】遍历 本文内容主要学习自视频 link BFS与DFS BFS (Breadth First Search) 是指从任意起始点开始,一层一层地向外搜索,即从起始点开始,先搜索到与其相距为1的节点,然后再搜索到...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,859
精华内容 2,343
关键字:

dfs深度遍历