A*（A星）算法Go lang实现

之前发表一个A*的python实现，连接：点击打开链接

最近正在学习Go语言，基本的语法等东西已经掌握了。但是纸上得来终觉浅，绝知此事要躬行嘛。必要的练手是一定要做的。正好离写python版的A*不那么久远。这个例子复杂度中等。还可以把之前用python实现是没有考虑的部分整理一下。

这一版的GO实现更加模块化了，同时用二叉堆来保证了openlist的查找性能。可以说离应用到实现工程中的要求差距不太远了。

  1. package main
  3. import (
  4. 	"container/heap"
  5. 	"fmt"
  6. 	"math"
  7. 	"strings"
  8. )
  9. import "strconv"
  12. type _Point struct {
  13. 	x    int
  14. 	y    int
  15. 	view string
  16. }
  18. //========================================================================================
  20. // 保存地图的基本信息
  21. type Map struct {
  22. 	points [][]_Point
  23. 	blocks map[string]*_Point
  24. 	maxX   int
  25. 	maxY   int
  26. }
  28. func NewMap(charMap []string) (m Map) {
  29. 	m.points = make([][]_Point, len(charMap))
  30. 	m.blocks = make(map[string]*_Point, len(charMap)*2)
  31. 	for x, row := range charMap {
  32. 		cols := strings.Split(row, " ")
  33. 		m.points[x] = make([]_Point, len(cols))
  34. 		for y, view := range cols {
  35. 			m.points[x][y] = _Point{x, y, view}
  36. 			if view == "X" {
  37. 				m.blocks[pointAsKey(x, y)] = &m.points[x][y]
  38. 			}
  39. 		} // end of cols
  40. 	} // end of row
  42. 	m.maxX = len(m.points)
  43. 	m.maxY = len(m.points[0])
  45. 	return m
  46. }
  48. func (this *Map) getAdjacentPoint(curPoint *_Point) (adjacents []*_Point) {
  49. 	if x, y := curPoint.x, curPoint.y-1; x >= 0 && x < this.maxX && y >= 0 && y < this.maxY {
  50. 		adjacents = append(adjacents, &this.points[x][y])
  51. 	}
  52. 	if x, y := curPoint.x+1, curPoint.y-1; x >= 0 && x < this.maxX && y >= 0 && y < this.maxY {
  53. 		adjacents = append(adjacents, &this.points[x][y])
  54. 	}
  55. 	if x, y := curPoint.x+1, curPoint.y; x >= 0 && x < this.maxX && y >= 0 && y < this.maxY {
  56. 		adjacents = append(adjacents, &this.points[x][y])
  57. 	}
  58. 	if x, y := curPoint.x+1, curPoint.y+1; x >= 0 && x < this.maxX && y >= 0 && y < this.maxY {
  59. 		adjacents = append(adjacents, &this.points[x][y])
  60. 	}
  61. 	if x, y := curPoint.x, curPoint.y+1; x >= 0 && x < this.maxX && y >= 0 && y < this.maxY {
  62. 		adjacents = append(adjacents, &this.points[x][y])
  63. 	}
  64. 	if x, y := curPoint.x-1, curPoint.y+1; x >= 0 && x < this.maxX && y >= 0 && y < this.maxY {
  65. 		adjacents = append(adjacents, &this.points[x][y])
  66. 	}
  67. 	if x, y := curPoint.x-1, curPoint.y; x >= 0 && x < this.maxX && y >= 0 && y < this.maxY {
  68. 		adjacents = append(adjacents, &this.points[x][y])
  69. 	}
  70. 	if x, y := curPoint.x-1, curPoint.y-1; x >= 0 && x < this.maxX && y >= 0 && y < this.maxY {
  71. 		adjacents = append(adjacents, &this.points[x][y])
  72. 	}
  73. 	return adjacents
  74. }
  76. func (this *Map) PrintMap(path *SearchRoad) {
  77. 	fmt.Println("map's border:", this.maxX, this.maxY)
  78. 	for x := 0; x < this.maxX; x++ {
  79. 		for y := 0; y < this.maxY; y++ {
  80. 			if path != nil {
  81. 				if x == path.start.x && y == path.start.y {
  82. 					fmt.Print("S")
  83. 					goto NEXT
  84. 				}
  85. 				if x == path.end.x && y == path.end.y {
  86. 					fmt.Print("E")
  87. 					goto NEXT
  88. 				}
  89. 				for i := 0; i < len(path.TheRoad); i++ {
  90. 					if path.TheRoad[i].x == x && path.TheRoad[i].y == y {
  91. 						fmt.Print("*")
  92. 						goto NEXT
  93. 					}
  94. 				}
  95. 			}
  96. 			fmt.Print(this.points[x][y].view)
  97. 		NEXT:
  98. 		}
  99. 		fmt.Println()
  100. 	}
  101. }
  103. func pointAsKey(x, y int) (key string) {
  104. 	key = strconv.Itoa(x) + "," + strconv.Itoa(y)
  105. 	return key
  106. }
  108. //========================================================================================
  110. type _AstarPoint struct {
  111. 	_Point
  112. 	father *_AstarPoint
  113. 	gVal   int
  114. 	hVal   int
  115. 	fVal   int
  116. }
  118. func NewAstarPoint(p *_Point, father *_AstarPoint, end *_AstarPoint) (ap *_AstarPoint) {
  119. 	ap = &_AstarPoint{*p, father, 0, 0, 0}
  120. 	if end != nil {
  121. 		ap.calcFVal(end)
  122. 	}
  123. 	return ap
  124. }
  126. func (this *_AstarPoint) calcGVal() int {
  127. 	if this.father != nil {
  128. 		deltaX := math.Abs(float64(this.father.x - this.x))
  129. 		deltaY := math.Abs(float64(this.father.y - this.y))
  130. 		if deltaX == 1 && deltaY == 0 {
  131. 			this.gVal = this.father.gVal + 10
  132. 		} else if deltaX == 0 && deltaY == 1 {
  133. 			this.gVal = this.father.gVal + 10
  134. 		} else if deltaX == 1 && deltaY == 1 {
  135. 			this.gVal = this.father.gVal + 14
  136. 		} else {
  137. 			panic("father point is invalid!")
  138. 		}
  139. 	}
  140. 	return this.gVal
  141. }
  143. func (this *_AstarPoint) calcHVal(end *_AstarPoint) int {
  144. 	this.hVal = int(math.Abs(float64(end.x-this.x)) + math.Abs(float64(end.y-this.y)))
  145. 	return this.hVal
  146. }
  148. func (this *_AstarPoint) calcFVal(end *_AstarPoint) int {
  149. 	this.fVal = this.calcGVal() + this.calcHVal(end)
  150. 	return this.fVal
  151. }
  153. //========================================================================================
  154. type OpenList []*_AstarPoint
  156. func (self OpenList) Len() int           { return len(self) }
  157. func (self OpenList) Less(i, j int) bool { return self[i].fVal < self[j].fVal }
  158. func (self OpenList) Swap(i, j int)      { self[i], self[j] = self[j], self[i] }
  160. func (this *OpenList) Push(x interface{}) {
  161. 	// Push and Pop use pointer receivers because they modify the slice's length,
  162. 	// not just its contents.
  163. 	*this = append(*this, x.(*_AstarPoint))
  164. }
  166. func (this *OpenList) Pop() interface{} {
  167. 	old := *this
  168. 	n := len(old)
  169. 	x := old[n-1]
  170. 	*this = old[0 : n-1]
  171. 	return x
  172. }
  174. //========================================================================================
  176. type SearchRoad struct {
  177. 	theMap  *Map
  178. 	start   _AstarPoint
  179. 	end     _AstarPoint
  180. 	closeLi map[string]*_AstarPoint
  181. 	openLi  OpenList
  182. 	openSet map[string]*_AstarPoint
  183. 	TheRoad []*_AstarPoint
  184. }
  186. func NewSearchRoad(startx, starty, endx, endy int, m *Map) *SearchRoad {
  187. 	sr := &SearchRoad{}
  188. 	sr.theMap = m
  189. 	sr.start = *NewAstarPoint(&_Point{startx, starty, "S"}, nil, nil)
  190. 	sr.end = *NewAstarPoint(&_Point{endx, endy, "E"}, nil, nil)
  191. 	sr.TheRoad = make([]*_AstarPoint, 0)
  192. 	sr.openSet = make(map[string]*_AstarPoint, m.maxX+m.maxY)
  193. 	sr.closeLi = make(map[string]*_AstarPoint, m.maxX+m.maxY)
  195. 	heap.Init(&sr.openLi)
  196. 	heap.Push(&sr.openLi, &sr.start) // 首先把起点加入开放列表
  197. 	sr.openSet[pointAsKey(sr.start.x, sr.start.y)] = &sr.start
  198. 	// 将障碍点放入关闭列表
  199. 	for k, v := range m.blocks {
  200. 		sr.closeLi[k] = NewAstarPoint(v, nil, nil)
  201. 	}
  203. 	return sr
  204. }
  206. func (this *SearchRoad) FindoutRoad() bool {
  207. 	for len(this.openLi) > 0 {
  208. 		// 将节点从开放列表移到关闭列表当中。
  209. 		x := heap.Pop(&this.openLi)
  210. 		curPoint := x.(*_AstarPoint)
  211. 		delete(this.openSet, pointAsKey(curPoint.x, curPoint.y))
  212. 		this.closeLi[pointAsKey(curPoint.x, curPoint.y)] = curPoint
  214. 		//fmt.Println("curPoint :", curPoint.x, curPoint.y)
  215. 		adjacs := this.theMap.getAdjacentPoint(&curPoint._Point)
  216. 		for _, p := range adjacs {
  217. 			//fmt.Println("\t adjact :", p.x, p.y)
  218. 			theAP := NewAstarPoint(p, curPoint, &this.end)
  219. 			if pointAsKey(theAP.x, theAP.y) == pointAsKey(this.end.x, this.end.y) {
  220. 				// 找出路径了, 标记路径
  221. 				for theAP.father != nil {
  222. 					this.TheRoad = append(this.TheRoad, theAP)
  223. 					theAP.view = "*"
  224. 					theAP = theAP.father
  225. 				}
  226. 				return true
  227. 			}
  229. 			_, ok := this.closeLi[pointAsKey(p.x, p.y)]
  230. 			if ok {
  231. 				continue
  232. 			}
  234. 			existAP, ok := this.openSet[pointAsKey(p.x, p.y)]
  235. 			if !ok {
  236. 				heap.Push(&this.openLi, theAP)
  237. 				this.openSet[pointAsKey(theAP.x, theAP.y)] = theAP
  238. 			} else {
  239. 				oldGVal, oldFather := existAP.gVal, existAP.father
  240. 				existAP.father = curPoint
  241. 				existAP.calcGVal()
  242. 				// 如果新的节点的G值还不如老的节点就恢复老的节点
  243. 				if existAP.gVal > oldGVal {
  244. 					// restore father
  245. 					existAP.father = oldFather
  246. 					existAP.gVal = oldGVal
  247. 				}
  248. 			}
  250. 		}
  251. 	}
  253. 	return false
  254. }
  256. //========================================================================================
  258. func main() {
  259. 	presetMap := []string{
  260. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  261. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  262. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  263. 		"X . X X X X X X X X X X X X X X X X X X X X X X X X X",
  264. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  265. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  266. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  267. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  268. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  269. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  270. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  271. 		"X X X X X X X X X X X X X X X X X X X X X X X X . X X",
  272. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  273. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  274. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  275. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  276. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  277. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  278. 		". . . . . . . . . . . . . . . . . . . . . . . . . . .",
  279. 	}
  280. 	m := NewMap(presetMap)
  281. 	m.PrintMap(nil)
  283. 	searchRoad := NewSearchRoad(0, 0, 18, 10, &m)
  284. 	if searchRoad.FindoutRoad() {
  285. 		fmt.Println("找到了， 你看！")
  286. 		m.PrintMap(searchRoad)
  287. 	} else {
  288. 		fmt.Println("找不到路径！")
  289. 	}
  290. }





posted on 2015-05-13 14:06  绝知此事要躬行  阅读(525)  评论(0)  编辑  收藏  举报

导航