数据结构之图源码复习笔记（邻接矩阵、广度搜索、深度搜索、最小生成树...）...

最新推荐文章于 2020-10-04 23:48:49 发布

weixin_34404393

最新推荐文章于 2020-10-04 23:48:49 发布

阅读量129

点赞数

文章标签：数据结构与算法 python

原文链接：https://my.oschina.net/997155658/blog/3041710

版权

2019独角兽企业重金招聘Python工程师标准>>>

graph.go

package maps

import (
	"fmt"
)

/*
涉及对象：
	1. 顶点(Node): 顶点内容、是否访问
	2. 边(Edge): 顶点A-B，权重，是否访问
	3. 图(map): 容量、邻接矩阵、当前顶点个数、顶点集合、边集合

涉及概念：
	顶点集合数量 = 容量
	边集合数量 = 顶点集合数量 - 1
	邻接矩阵大小 = 容量 ^ 2
*/

// Node struct.
type Node struct {
	Data      rune
	IsVisited bool
}

// Edge struct.
type Edge struct {
	NodeIndexA  int
	NodeIndexB  int
	WeightValue int
	IsVisited   bool
}

// CMap struct.
type CMap struct {
	Capacity  int    // 容量
	Matrix    []int  // 邻接矩阵
	NodeCount int    // 节点个数
	NodeArray []Node // 节点数据
	Edge      []Edge // 边数据
}

// CreateEdge .
func CreateEdge(nodeIndexA, nodeIndexB, weightValue int) *Edge {
	return &Edge{
		NodeIndexA:  nodeIndexA,
		NodeIndexB:  nodeIndexB,
		WeightValue: weightValue,
		IsVisited:   false,
	}
}

// CreateCMap impl.
func CreateCMap(capacity int) *CMap {
	return &CMap{
		Capacity:  capacity,
		Matrix:    make([]int, capacity*capacity),
		NodeCount: 0,
		NodeArray: make([]Node, capacity),
		Edge:      make([]Edge, capacity-1),
	}
}

// AddNode impl.
func (cmap *CMap) AddNode(node *Node) bool {
	if node == nil {
		return false
	}
	cmap.NodeArray[cmap.NodeCount].Data = node.Data
	cmap.NodeCount++
	return true
}

// ResetNode impl
func (cmap *CMap) ResetNode() {
	for i := 0; i < len(cmap.NodeArray); i++ {
		cmap.NodeArray[i].IsVisited = false
	}
}

// SetValueToMatrixForDirectedGraph impl.
func (cmap *CMap) SetValueToMatrixForDirectedGraph(row, col, val int) bool {
	if row <= 0 || row >= cmap.Capacity {
		return false
	}
	if col < 0 || col >= cmap.Capacity {
		return false
	}

	cmap.Matrix[row*cmap.Capacity+col] = val
	return true
}

// SetValueToMatrixForUnDirectedGraph impl.
func (cmap *CMap) SetValueToMatrixForUnDirectedGraph(row, col, val int) bool {
	if row < 0 || row >= cmap.Capacity {
		return false
	}
	if col < 0 || col >= cmap.Capacity {
		return false
	}

	cmap.Matrix[row*cmap.Capacity+col] = val
	cmap.Matrix[col*cmap.Capacity+row] = val

	return true
}

// GetWeightValueFromMatrix impl
func (cmap *CMap) GetWeightValueFromMatrix(row, col int) int {
	if row < 0 || row >= cmap.Capacity {
		return 0
	}
	if col < 0 || col >= cmap.Capacity {
		return 0
	}
	return cmap.Matrix[row*cmap.Capacity+col]
}

// PrinMatrix impl.
func (cmap *CMap) PrinMatrix() {
	for i := 0; i < cmap.Capacity; i++ {
		for k := 0; k < cmap.Capacity; k++ {
			fmt.Printf("%d\t", (cmap.Matrix[i*cmap.Capacity+k]))
		}
		fmt.Println()
	}

}

// DepthFirstTraverse impl.
func (cmap *CMap) DepthFirstTraverse(nodeIndex int) {
	fmt.Print(string(cmap.NodeArray[nodeIndex].Data), " ")
	cmap.NodeArray[nodeIndex].IsVisited = true

	for i := 0; i < cmap.Capacity; i++ {
		value := cmap.GetWeightValueFromMatrix(nodeIndex, i)
		if value != 0 {
			if !cmap.NodeArray[i].IsVisited {
				cmap.DepthFirstTraverse(i)
			}
		}
	}

}

// BreadthFirstTraverse impl
func (cmap *CMap) BreadthFirstTraverse(nodeIndex int) {
	fmt.Println(cmap.NodeArray[nodeIndex].Data, " ")
	cmap.NodeArray[nodeIndex].IsVisited = true

	var vector []int
	vector = append(vector, nodeIndex)

	cmap.BreadthFirstTraverseImpl(vector)
}

// BreadthFirstTraverseImpl .
func (cmap *CMap) BreadthFirstTraverseImpl(preVector []int) {
	var vector []int
	for j := 0; j < len(preVector); j++ {
		for i := 0; i < cmap.Capacity; i++ {
			value := cmap.GetWeightValueFromMatrix(preVector[j], i)
			if value != 0 {
				if !cmap.NodeArray[i].IsVisited {
					fmt.Print(string(cmap.NodeArray[i].Data), " ")
					cmap.NodeArray[i].IsVisited = true
					vector = append(vector, i)
				}
			}
		}
	}

	if len(vector) > 0 {
		cmap.BreadthFirstTraverseImpl(vector)
	}
}

// PrimTree (最小生成树 - 普里姆).
// 1. 选择一个顶点，放入已选顶点集合
// 2. 找到顶点对应的边集合，放入待选择集合
// 3. 找到最小权重的边，放入已选边集合
// 4. 找到最小权重边的另外一个顶点B，放入已选顶点集合
// 5. 找到顶点B对应的边集合，放入待选择集合
// 6. 找到最小权重的边，放入已选边集合
// 7. ...
func (cmap *CMap) PrimTree(nodeIndex int) {
	value := 0
	edgeCount := 0
	var nodes []int
	var edges []Edge
	nodes = append(nodes, nodeIndex)
	cmap.NodeArray[nodeIndex].IsVisited = true

	fmt.Println(string(cmap.NodeArray[nodeIndex].Data))

	for edgeCount < cmap.Capacity-1 {

		temp := nodes[len(nodes)-1]
		nodes = nodes[:len(nodes)-1]

		// 1. 找到所有与顶点temp对应的边
		for i := 0; i < cmap.Capacity; i++ {
			value = cmap.GetWeightValueFromMatrix(temp, i)
			if value != 0 {
				if !cmap.NodeArray[i].IsVisited {
					edge := Edge{
						NodeIndexA:  temp,
						NodeIndexB:  i,
						WeightValue: value,
					}
					edges = append(edges, edge)
				}
			}
		}

		// 2. 从可选边集合找到最小的边
		minEdgeIndex := getMinEdge(edges)
		edges[minEdgeIndex].IsVisited = true
		cmap.Edge[edgeCount] = edges[minEdgeIndex]
		edgeCount++

		fmt.Print(edges[minEdgeIndex].NodeIndexA, "---", edges[minEdgeIndex].NodeIndexB, " ")
		fmt.Println(edges[minEdgeIndex].WeightValue)

		// 3. 找出下一个顶点并放入集合
		nextNodeIndex := edges[minEdgeIndex].NodeIndexB
		nodes = append(nodes, nextNodeIndex)
		cmap.NodeArray[nextNodeIndex].IsVisited = true

		fmt.Println(string(cmap.NodeArray[nextNodeIndex].Data))
	}

}

// KruskalTree （最小生成树 - 克鲁斯卡尔）
// 1. 找到所有的边，放入集合SetA
// 2. 选择权重最小的边，并将边放入数组
// 3. 查找权重最小边涉及的顶点(顶点a-b)，并将顶点放入数组
// 4. 查找顶点a和b所在的集合
// 5. 根据顶点a和b所在的集合进行如下逻辑处理：
//		1). 如顶点a和b在都不在集合中，则新建集合set，并将顶点a和b放入set集合
//		2). 如顶点a(b)在集合set中，b(a)不在集合中, 则将b(a)放入集合a(b)中
// 		3). 如顶点a和b在不同的集合，则将b集合合并到a集合
//		4). 如顶点a和b在同一集合，则产生回路，不做处理
// 6. 循环步骤2-5【当边未搜索完时】
func (cmap *CMap) KruskalTree() {

	var edgeCount int

	// 定义存放节点集合的数组
	var nodeSets [][]int

	// 一、取出所有的边
	var edges []Edge
	for i := 0; i < cmap.Capacity; i++ {
		for k := i + 1; k < cmap.Capacity; k++ {
			value := cmap.GetWeightValueFromMatrix(i, k)
			if value != 0 {
				edge := Edge{
					NodeIndexA:  i,
					NodeIndexB:  k,
					WeightValue: value,
				}
				edges = append(edges, edge)
			}
		}
	}

	// 二、从所有边去除组成最小生成树的边
	// 1. 找到算法的结束条件
	for edgeCount < cmap.Capacity-1 {
		// 2. 从边集合找出最小边
		minEdgeIndex := getMinEdge(edges)
		edges[minEdgeIndex].IsVisited = true

		// 3. 找出最小边连接的点
		nodeAIndex := edges[minEdgeIndex].NodeIndexA
		nodeBIndex := edges[minEdgeIndex].NodeIndexB

		nodeAIsInSet := false
		nodeBIsInSet := false

		nodeAInSetLabel := -1
		nodeBInSetLabel := -1

		// 4. 找出A点所在的集合
		for i := 0; i < len(nodeSets); i++ {
			nodeAIsInSet = isInSet(nodeSets[i], nodeAIndex)
			if nodeAIsInSet {
				nodeAInSetLabel = i
			}
		}

		// 找出B点所在的集合
		for i := 0; i < len(nodeSets); i++ {
			nodeBIsInSet = isInSet(nodeSets[i], nodeBIndex)
			if nodeBIsInSet {
				nodeBInSetLabel = i
			}
		}

		// 5. 根据点所在集合的不同做出不同的处理
		if nodeAInSetLabel == -1 && nodeBInSetLabel == -1 {
			var newEdges []int
			newEdges = append(newEdges, nodeAIndex, nodeBIndex)
			nodeSets = append(nodeSets, newEdges)
		} else if nodeAInSetLabel == -1 && nodeBInSetLabel != -1 {
			nodeSets[nodeBInSetLabel] = append(nodeSets[nodeBInSetLabel], nodeAIndex)
		} else if nodeAInSetLabel != -1 && nodeBInSetLabel == -1 {
			nodeSets[nodeAInSetLabel] = append(nodeSets[nodeAInSetLabel], nodeBIndex)
		} else if nodeAInSetLabel != -1 && nodeBInSetLabel != -1 {
			mergeNodeSet(&nodeSets[nodeAInSetLabel], nodeSets[nodeBInSetLabel])
			nodeSets = append(nodeSets[:nodeBInSetLabel], nodeSets[nodeBInSetLabel+1:]...)
		} else if nodeAInSetLabel != -1 && nodeBInSetLabel != -1 && nodeAInSetLabel == nodeBInSetLabel {
			continue
		}

		cmap.Edge[edgeCount] = edges[minEdgeIndex]
		edgeCount++

		fmt.Print(edges[minEdgeIndex].NodeIndexA, "--", edges[minEdgeIndex].NodeIndexB, "  ")
		fmt.Println(string(edges[minEdgeIndex].WeightValue))
	}

}

// 获取最小的边索引
func getMinEdge(edges []Edge) int {
	minWeight := 0
	edgeIndex := 0
	i := 0

	for ; i < len(edges); i++ {
		if !edges[i].IsVisited {
			minWeight = edges[i].WeightValue
			edgeIndex = i
			break
		}
	}

	if minWeight == 0 {
		return -1
	}

	for ; i < len(edges); i++ {
		if !edges[i].IsVisited {
			if edges[i].WeightValue < minWeight {
				minWeight = edges[i].WeightValue
				edgeIndex = i
			}
		}
	}

	return edgeIndex
}

// 是否在集合中
func isInSet(sets []int, target int) bool {
	for i := 0; i < len(sets); i++ {
		if sets[i] == target {
			return true
		}
	}

	return false
}

// 合并node
func mergeNodeSet(nodeSetA *[]int, nodeSetB []int) {
	*nodeSetA = append(*nodeSetA, nodeSetB...)
}

graph_test.go

package maps

import "testing"

func TestCMap(t *testing.T) {
	cmap := CreateCMap(8)

	nodeA := &Node{Data: 'A'}
	nodeB := &Node{Data: 'B'}
	nodeC := &Node{Data: 'C'}
	nodeD := &Node{Data: 'D'}
	nodeE := &Node{Data: 'E'}
	nodeF := &Node{Data: 'F'}

	cmap.AddNode(nodeA)
	cmap.AddNode(nodeB)
	cmap.AddNode(nodeC)
	cmap.AddNode(nodeD)
	cmap.AddNode(nodeE)
	cmap.AddNode(nodeF)

	cmap.SetValueToMatrixForUnDirectedGraph(0, 1, 6)
	cmap.SetValueToMatrixForUnDirectedGraph(0, 4, 5)
	cmap.SetValueToMatrixForUnDirectedGraph(0, 5, 1)
	cmap.SetValueToMatrixForUnDirectedGraph(1, 2, 3)
	cmap.SetValueToMatrixForUnDirectedGraph(1, 5, 2)
	cmap.SetValueToMatrixForUnDirectedGraph(2, 5, 8)
	cmap.SetValueToMatrixForUnDirectedGraph(2, 3, 7)
	cmap.SetValueToMatrixForUnDirectedGraph(3, 5, 4)

	// cmap.PrinMatrix()
	// cmap.DepthFirstTraverse(0)
	// cmap.BreadthFirstTraverse(0)
	// cmap.KruskalTree()
	cmap.PrimTree(0)
}

转载于:https://my.oschina.net/997155658/blog/3041710