Golang——数据结构图部分简单实现

最近在复习数据结构图的部分，又在学习golang，因此我使用Golang将图的一些基本操作实现了一下。
包结构：
package mapTest
		AdjacencyList.go
		adjacencyMatrix.go
邻接表的创建：

package main

//以邻接表的方式创建图
import (
	. "fmt"
)


const MAXVEX1 = 20

type ArcNode struct {
	adjvex int
	weight int
	next *ArcNode
}
type VertexNode struct {
	vexdata int
	head *ArcNode
}
type AdjList struct {
	vertex [MAXVEX1]VertexNode
	vexnum int
	arcnum int
}

func CreateAdjList(G *AdjList) {
	var p *ArcNode
	var vex1 int
	var vex2 int
	weight := 0
	Println("请输入有向网中的顶点数和边数：")
	_, _ = Scanf("%d %d", &G.vexnum,&G.arcnum)
	Printf("请输入有向网中的%d个顶点\n",G.vexnum)
	for i := 1; i <= G.vexnum; i++ {
		G.vertex[i].head = nil
	}
	for i := 1; i <= G.vexnum; i++ {
		Printf("第%d个顶点:\n",i)
		Scanf("%d", &G.vertex[i].vexdata)
	}
	Printf("请输入有向网中的%d条边\n",G.arcnum)
	for i := 0; i < G.arcnum; i++ {
		Printf("第%d条边: 顶点V1\n",i+1)
		Scanf("%d",&vex1)
		Println("<——>顶点V2")
		Scanf("%d",&vex2)
		Println("权值:")
		Scanf("%d",&weight)
		I := LocateVexAdjList(G,vex1)
		J := LocateVexAdjList(G,vex2)
		Head1 := ArcNode{J,weight,nil}
		hhead1 := &Head1
		p = G.vertex[I].head
		if p == nil {
			G.vertex[I].head = hhead1
		}else {
			Aappend(G.vertex[I].head,hhead1)
		}
	}
}

func Aappend(g,m *ArcNode,)  {
	for g.next != nil {
		g = g.next
	}
	g.next = m
}
func LocateVexAdjList(G *AdjList,vex int) int{
	for i := 1; i <= G.vexnum; i++ {
		if G.vertex[i].vexdata == vex {
			return i
		}
	}
	return 0
}

func VisitAdjList(G *AdjList)  {
	for i := 1; i <= G.vexnum; i++ {
		Printf(string(rune(G.vertex[i].vexdata))+ " ")
	}
	Println()
	for i := 1; i <= G.vexnum; i++ {
		Println(string(rune(G.vertex[i].vexdata)))
		var p *ArcNode
		p = G.vertex[i].head
		for p != nil {
			Println("->",string(rune(G.vertex[p.adjvex].vexdata)),"(",p.weight,")")
			p = p.next
		}
	}
}

func main() {
	var g1 = AdjList{}
	var G1 = &g1
	CreateAdjList(G1)
	VisitAdjList(G1)
}

邻接矩阵的创建及深度优先搜索、广度优先搜索：

package main

//邻接矩阵
import ."fmt"

const MAXVEX = 20
const INFINITY = 32767

type AdjMatrix struct {
	ares[MAXVEX][MAXVEX] int	//边的信息
	vex[MAXVEX] int	//顶点信息
	vexnum int	//顶点数目
	arcnum int	//边的数目
}

//邻接矩阵的建立
func Create(G *AdjMatrix)  {
	var vex1 int
	var vex2 int
	weight := 0
	//输入无向网中的顶点数和边数
	Println("请输入无向网中的顶点数和边数：")
	_, _ = Scanf("%d %d", &G.vexnum,&G.arcnum)
	//初始化图中边的信息
	for i := 1; i <= G.vexnum; i++{
		for j := 1; j <= G.vexnum; j++ {
			G.ares[i][j] = INFINITY
		}
	}
	Printf("请输入无向网中的%d个顶点\n",G.vexnum)
	for i := 1; i <= G.vexnum; i++ {
		Printf("第%d个顶点:\n",i)
		Scanf("%d",&G.vex[i])
	}
	Printf("请输入无向网中的%d条边\n",G.arcnum)
	for i := 0; i < G.arcnum; i++ {
		Printf("第%d条边: 顶点V1\n",i+1)
		Scanf("%d",&vex1)
		Println("<——>顶点V2")
		Scanf("%d",&vex2)
		Println("权值:")
		Scanf("%d",&weight)
		I := LocateVex(G,vex1)
		J := LocateVex(G,vex2)
		G.ares[I][J] = weight
		G.ares[J][I] = weight
	}
}

//找到某顶点在矩阵中的下标
func LocateVex(G *AdjMatrix,vex int) int{
	for i := 1; i <= G.vexnum; i++ {
		if G.vex[i] == vex {
			return i
		}
	}
	return 0
}

//遍历打印整个邻接矩阵
func Visit(G *AdjMatrix)  {
	for i := 1; i <= G.vexnum; i++ {
		Printf(string(rune(G.vex[i]))+ " ")
	}
	for i := 1; i <= G.vexnum; i++{
		for j := 1; j <= G.vexnum; j++ {
			Println(string(rune(G.vex[i])),"<-->",string(rune(G.vex[j])),G.ares[i][j] )
		}
	}
}

//打印单个节点
func visit(v0 int)  {
	Println(string(rune(v0)))
}

//寻找v0第一个邻接点
func FirstAdjVex(G *AdjMatrix,v0 int,visited []int)  int{
	I := LocateVex(G,v0)
	for i := 1; i <= G.vexnum; i++ {
		J := LocateVex(G,G.vex[i])
		if G.ares[I][J] != INFINITY  && visited[G.vex[i]] == 0{
			return G.vex[i]
		}
	}
	return 0
}
//递归深度优先搜索
func DFSByRecursion(G *AdjMatrix,v0 int,visited []int)  {
	 visit(v0)
	 visited[v0] = 1
	 w := FirstAdjVex(G,v0,visited)
	for w > 0 {
		if visited[w] == 0 {
			DFSByRecursion(G,w,visited)
		}
		w = FirstAdjVex(G,w,visited)
	}
}

//广度优先搜索邻接矩阵
func BFSByRecursion(G *AdjMatrix,v0 int,visited []int)  {
	visit(v0)
	visited[v0] = 1
	var Queue []int
	Queue  = append(Queue, v0)
	for len(Queue) != 0 {
		Queue = Queue[1:len(Queue)]
		w := FirstAdjVex(G,v0,visited)
		for w > 0{
			 visit(w)
			 visited[w] = 1
			 Queue = append(Queue,w)
			 w = FirstAdjVex(G,w,visited)
		}
	}
}
func main() {
	var g = AdjMatrix{}
	var G = &g
	visited1 := make([]int,MAXVEX * 10)
	visited2 := make([]int,MAXVEX * 10)
	Create(G)
	Println("邻接矩阵的遍历打印：")
	Visit(G)
	Println("邻接矩阵的深度优先搜索打印：")
	DFSByRecursion(G,102,visited1)
	Println("邻接矩阵的广度优先搜索打印：")
	BFSByRecursion(G,102,visited2)
}