常见数据结构(go 简易实现)

已于 2022-05-29 11:22:55 修改
阅读量526 收藏 4
点赞数
分类专栏： go # 数据结构与算法 文章标签： 数据结构 golang
于 2022-05-26 22:33:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22211217/article/details/124994155
版权

文章目录

前言

  1. 本文以最粗糙方式实现各种数据结构，一定有更优方式，读者可以自行扩展
  2. 如有错误之处欢迎批评指正

线性结构

数组

内存中顺序存储有序元素

特性:

  1. 随机访问高效，适合读多写少
  2. 插入删除需要移动元素，可能遇到扩容操作
操作描述时间复杂度
查询下标访问，随机读取O(1)
更新下标访问，随机读取，赋值O(1)
插入尾部插入
中间插入，后面元素右移
超范围插入,触发扩容copy		综合O(N)
O(1)
O(N)
O(N)
删除尾部删除
中间删除，后面元素左移		综合O(N)
O(1)
O(N)

链表

内存中非连续非顺序随机存储

特性:

  1. 修改操作时间复杂度低，适合写多读少

  2. 不支持下标访问，查询最坏情况O(N)，理论容量无限

操作描述时间复杂度
查询链式递归查找O(N)
更新链式递归查找，赋值不考虑查找
O(1)
插入头部插入
中间插入
尾部插入		不考虑查找
O(1)
O(1)
O(1)
删除头部删除
中间删除
尾部删除		不考虑查找
O(1)
O(1)
O(1)

逻辑结构

基于数组和链表结构派生线性存储结构

栈

特性

维护一个先入后出FILO的顺序线性结构，最早元素栈底，最新元素栈底

实现出栈入栈
数组+index查询尾O(1)
尾删O(1)
index–		查询尾O(1)
尾插O(1)
index++
链表+尾指针查询尾O(1)
尾删O(1)
尾指针更新		查询尾O(1)
尾插O(1)
尾指针更新
应用

代替递归

简易实现

数组

type arrayStack struct {
	data []interface{}
	index int
}

func NewArrayStack() *arrayStack {
	return &arrayStack{
		data:  make([]interface{},0),
		index: -1,
	}
}

func (a *arrayStack)Push(data interface{})  {
	a.data = append(a.data, data)
	a.index++
}

func (a *arrayStack)Pop() interface{} {
	if len(a.data)==0{
		return nil
	}
	r:=a.data[a.index]
	if a.index == 0 {
		a.data=make([]interface{},0)
	}else {
		a.data=a.data[:a.index]
	}
	a.index--
	return r
}


func TestArrayStack(t *testing.T) {

	node:=NewArrayStack()
	for i:=0;i<10;i++{
		node.Push(i)
	}
	for i:=0;i<11;i++{
		fmt.Printf("%v \n",node.Pop())
	}

}

/*
=== RUN   TestArrayStack
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
<nil> 
--- PASS: TestArrayStack (0.00s)
PASS

Process finished with exit code 0
*/

链表

type singleNode struct {
	data interface{}
	pre *singleNode
}

type linkStack struct {
	data *singleNode
	head *singleNode
}

func NewLinkStack() *linkStack {
	return &linkStack{}
}

func (a *linkStack)Push(data interface{})  {
	if a.data==nil{
		a.data = &singleNode{
			data: data,
			pre: nil,
		}
		a.head = a.data
	}else{
		a.head = &singleNode{
			data: data,
			pre: a.head,
		}
	}
}

func (a *linkStack)Pop() interface{} {
	if a.head==nil{
		return nil
	}
	var r interface{}
	r = a.head.data
	if a.head.pre!=nil {
		a.head = a.head.pre
	}else{
		a.head = nil
	}
	return r
}

func TestLinkStack(t *testing.T) {

	node:=NewLinkStack()
	for i:=0;i<10;i++{
		node.Push(i)
	}
	for i:=0;i<11;i++{
		fmt.Printf("%v \n",node.Pop())
	}

}
/*
=== RUN   TestLinkStack
9 
8 
7 
6 
5 
4 
3 
2 
1 
0 
<nil> 
--- PASS: TestLinkStack (0.00s)
PASS

Process finished with exit code 0
*/

队列

特性

维护一个先入先出FIFO的顺序线性结构，最早元素队头，最新元素队尾

实现出队入队
环形数组+队头index+队尾index查询队头O(1)
队头index–		查询队尾O(1)
队尾index++
链表+头指针+尾指针查询头O(1)
头删O(1)
头指针更新		查询尾O(1)
尾插O(1)
尾指针更新
应用

双端队列，结合栈和队列特性

优先队列，基于二叉堆实现

简易实现

数组

type arrayQueue struct {
	data []interface{}
	pre  int
	next int
}

func NewArrayQueue() *arrayQueue {
	return &arrayQueue{
		data:  make([]interface{},1024),
		pre: -1,
		next:-1,
	}
}

func (a *arrayQueue)Push(data interface{})  {
	a.next = (a.next + 1) % 1024
	a.data[a.next] = data
}

func (a *arrayQueue)Pop() interface{} {
	if a.pre == a.next{
		return  nil
	}
	a.pre = (a.pre + 1) % 1024
	return a.data[a.pre]
}

func TestNewArrayQueue(t *testing.T)  {
	m:=NewArrayQueue()
	for i:=0;i<10;i++{
		m.Push(i)
	}

	for i:=0;i<11;i++{
		fmt.Printf("%v \n",m.Pop())
	}
}
/*
=== RUN   TestNewArrayQueue
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
<nil> 
--- PASS: TestNewArrayQueue (0.00s)
PASS

Process finished with exit code 0
*/

链表

type linkQueue struct {
	data *singleNode
	tail *singleNode
}


func NewLinkQueue() *linkQueue {
	return &linkQueue{}
}

func (a *linkQueue)Push(data interface{})  {
	if a.data==nil{
		a.data = &singleNode{
			data: data,
			next: nil,
		}
		a.tail = a.data
	}else{
		a.tail.next =  &singleNode{
			data: data,
			next: nil,
		}
		a.tail = a.tail.next
	}

}

func (a *linkQueue)Pop() interface{} {
	if a.data==nil {
		return nil
	}
	var r interface{}
	r = a.data.data
	if a.data.next!=nil {
		a.data = a.data.next
	}else {
		a.data = nil
		a.tail = nil
	}
	return r
}

func TestNewLinkQueue(t *testing.T)  {
	m:=NewLinkQueue()
	for i:=0;i<10;i++{
		m.Push(i)
	}

	for i:=0;i<11;i++{
		fmt.Printf("%v \n",m.Pop())
	}
}
/*
=== RUN   TestNewLinkQueue
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
<nil> 
--- PASS: TestNewLinkQueue (0.00s)
PASS

Process finished with exit code 0
*/

哈希表

维护一个键（Key）与值（Value）映射关系存储结构，也叫做散列表

  • Capacity，当前hash表容量
  • LoadFactor，当前负载因子默认0.75，衡量hash冲突概率的经验值
  • Size，当前元素个数
底层是数组+链表结构，key进行hash，定位到数组下标。
- 如果hash冲突:
1.拉链法将key当前下标链式存储。
2.开放地址法将key往后寻找合适位置存储。
- 如果size>=Capacity*LoadFactor:
1.扩容底层数组
2.rehash重新放置key
操作描述时间复杂度
查询hashkey，锁定数组index，有限长的链表查询接近O(1)
更新查询，赋值不考虑查找
接近O(1)
插入hashkey，锁定数组index，链表尾插，可能触发扩容不考虑扩容
接近O(1)
删除hashkey，锁定数组index，有限长的链表查询，链表删除不考虑查找
接近O(1)
简易实现
type bucket struct {
	key   int
	value interface{}
	next  *bucket
}

type m struct {
	buckets []*bucket
}

func NewMap() *m {
	return &m{buckets: make([]*bucket, 1024)}

}

func (m *m) Put(key int, v interface{}) {
	index := key % 1024
	if f := m.buckets[index]; f != nil {
		p := f.next
		for ; p != nil; p = p.next {
			if p.key == key {
				p.value = v
				break
			}
		}
		p.next = &bucket{
			key:   key,
			value: v,
			next:  nil,
		}
	} else {
		m.buckets[index] = &bucket{
			key:   key,
			value: v,
			next:  nil,
		}
	}
}

func (m *m) Get(key int) interface{} {
	index := key % 1024
	if f := m.buckets[index]; f != nil {
		if f.key == key {
			return f.value
		}
		p := f.next
		for ; p != nil; p = p.next {
			if p.key == key {
				return p.value
			}
		}
	}
	return nil
}


func TestNewMap(t *testing.T)  {
	m:=NewMap()
	for i:=0;i<10240;i+=1000{
		m.Put(i,i)
	}

	for i:=0;i<20000;i+=1000{
		fmt.Printf("%v \n",m.Get(i))
	}
}
/*
=== RUN   TestNewMap
0 
1000 
2000 
3000 
4000 
5000 
6000 
7000 
8000 
9000 
10000 
<nil> 
<nil> 
<nil> 
<nil> 
<nil> 
<nil> 
<nil> 
<nil> 
<nil> 
--- PASS: TestNewMap (0.00s)
PASS

Process finished with exit code 0
*/

非线形结构

树

树是n(n>=0)个节点的有限集。
n = 0, 空树
1. 根节点:有且只有一个
2. 子树: n>2,根节点外其余节点可以划分m(m>0)个有限集，每个有限集又是一个树结构
3. 叶子节点:没有子树的节点
4. 父节点: 上一级节点
5. 子节点: 下一级节点
6. 兄弟节点: 同父节点的节点

二叉树

每个节点只有两个子节点的树,左边为左孩子，右边为右孩子，左边有限集为左子树，右边有限集为右子树

分类

  • 满二叉树：所有非叶子节点都有左右孩子，所有叶子节点都在同一层级上。
  • 完全二叉树：叶子节点层级上缺少右侧节点的满二叉树
  • 稀疏二叉树：非上面两种二叉树，不适合用数组实现，浪费空间。
  • 二叉搜索树（二叉排序树）：左子树所有节点小于根节点，右子树所有节点大于根节点，左右子树也是二叉搜索树。
    • 均匀 O(logN)
    • 不均匀O(N),需要自平衡

遍历

  1. 前序遍历（深度优先）：根->左->右
  2. 中序遍历（深度优先）：左->根->右
  3. 后序遍历（深度优先）：左->右->根
  4. 层序遍历（广度优先）：层1->左->右->…->层n，前序+队列可以实现
// 遍历框架
func traverse(node){
  if node == nil{
    return
  }
  //前序位置
  traverse(node.left)
  //中序位置
  traverse(node.rigtht)
  //后序位置
}

// 层序遍历框架
func traverse(node){
  queue:=newQueue()
  queue.put(node)
  for ;len(queue)!=nil;{
    node = queue.pop()
    // 层序遍历位置
    if node.left!=nil {
      queue.put(node.left)
    }
    if node.rigtht!=nil {
      queue.put(node.rigtht)
    }
  }
}
简易实现

数组

package test

import "fmt"

type arrayTree []interface{}

func NewArrayTree(data []interface{}) *arrayTree {
	a := &arrayTree{}
	*a = append(*a, data...)
	return a
}

func (a *arrayTree) traverse(index int)  {
	if index >len(*a)-1{
		return
	}
	fmt.Printf("前序 %v \n",(*a)[index])
	// 左节点
	a.traverse(2*index+1)
	fmt.Printf("中序 %v \n",(*a)[index])
	// 右节点
	a.traverse(2*index+2)
	fmt.Printf("后序 %v \n",(*a)[index])
}

func (a *arrayTree) traverse2(index int)  {
	if index >len(*a)-1{
		return
	}
	m:=NewLinkQueue()
	m.Push(index)
	for ;m.data!=nil;{
		if v ,ok:=m.Pop().(int);ok{
			fmt.Printf("层序遍历 %v \n",(*a)[v])
			if v*2+1<len(*a){
				m.Push(v*2+1)
			}
			if v*2+2<len(*a){
				m.Push(v*2+2)
			}
		}
	}
}


func TestNewArrayTree(t *testing.T) {
	tree :=NewArrayTree([]interface{}{1,2,3,4,5,6,7,8,9})
	tree.traverse(0)
  tree.traverse2(0)
}

/*
=== RUN   TestNewArrayTree
前序 1
前序 2
前序 4
前序 8
前序 9
前序 5
前序 3
前序 6
前序 7
--- PASS: TestNewArrayTree (0.00s)
PASS

Process finished with exit code 0

=== RUN   TestNewArrayTree
中序 8
中序 4
中序 9
中序 2
中序 5
中序 1
中序 6
中序 3
中序 7
--- PASS: TestNewArrayTree (0.00s)
PASS

Process finished with exit code 0

=== RUN   TestNewArrayTree
后序 8
后序 9
后序 4
后序 5
后序 2
后序 6
后序 7
后序 3
后序 1
--- PASS: TestNewArrayTree (0.00s)
PASS

Process finished with exit code 0

=== RUN   TestNewArrayTree
层序遍历 1 
层序遍历 2 
层序遍历 3 
层序遍历 4 
层序遍历 5 
层序遍历 6 
层序遍历 7 
层序遍历 8 
层序遍历 9 
--- PASS: TestNewArrayTree (0.00s)
PASS

Process finished with exit code 0
*/

链表

type LinkTree struct {
	data interface{}
	left *LinkTree
	right *LinkTree
}

func NewLinkTree(data []interface{},index int) *LinkTree {
	if len(data)==0 || index > len(data)-1{
		return nil
	}
	node := &LinkTree{
		data:  data[index],
		left:  nil,
		right: nil,
	}
	node.left = NewLinkTree(data,index*2+1)
	node.right = NewLinkTree(data,index*2+2)
	return node
}

func (a *LinkTree) traverse(node *LinkTree)  {
	if node == nil{
		return
	}
	//fmt.Printf("前序 %v \n",node.data)
	// 左节点
	a.traverse(node.left)
	//fmt.Printf("中序 %v \n",node.data)
	// 右节点
	a.traverse(node.right)
	fmt.Printf("后序 %v \n",node.data)
}

func (a *LinkTree) traverse2(node *LinkTree)  {
	if node == nil{
		return
	}
	m:=NewLinkQueue()
	m.Push(node)
	for ;m.data!=nil;{
		if v ,ok:=m.Pop().(*LinkTree);ok{
			fmt.Printf("层序遍历 %v \n",v.data)
			if v.left!=nil{
				m.Push(v.left)
			}
			if v.right!=nil{
				m.Push(v.right)
			}
		}
	}
}

func TestNewLinkTree(t *testing.T) {
	tree :=NewLinkTree([]interface{}{1,2,3,4,5,6,7,8,9},0)
	tree.traverse(tree)
  tree.traverse2(tree)
}

/*
=== RUN   TestNewLinkTree
前序 1
前序 2
前序 4
前序 8
前序 9
前序 5
前序 3
前序 6
前序 7
--- PASS: TestNewLinkTree (0.00s)
PASS

Process finished with exit code 0
*/

/*
=== RUN   TestNewLinkTree
中序 8
中序 4
中序 9
中序 2
中序 5
中序 1
中序 6
中序 3
中序 7
--- PASS: TestNewLinkTree (0.00s)
PASS

Process finished with exit code 0
*/

/*
=== RUN   TestNewLinkTree
后序 8
后序 9
后序 4
后序 5
后序 2
后序 6
后序 7
后序 3
后序 1
--- PASS: TestNewLinkTree (0.00s)
PASS

Process finished with exit code 0

=== RUN   TestNewLinkTree
层序遍历 1 
层序遍历 2 
层序遍历 3 
层序遍历 4 
层序遍历 5 
层序遍历 6 
层序遍历 7 
层序遍历 8 
层序遍历 9 
--- PASS: TestNewLinkTree (0.00s)
PASS
*/

二叉堆

本质上是完全二叉树，根节点是堆顶，根节点为最大值最大堆，反之最小堆。
操作描述时间复杂度
插入从最后位置插入，上浮(平均是层数一半)O(log(N))
删除从堆顶删除，下沉(平均是层数一半)O(log(N))
构建所有非叶子节点下沉O(N)
简易实现

数组

package test

type arrayHeap []int

func NewArrayHeap(arr []int) *arrayHeap {
	h := arrayHeap(arr)
	for i := (len(arr) - 2) / 2; i >= 0; i-- {
		h.adjustDown(i, len(arr))
	}
	return &h
}

func (h *arrayHeap) Push(v int) {
	*h = append(*h, v)
	h.adjustUp()
}

func (h *arrayHeap) Pop() int {
	l := len([]int(*h))
	r := (*h)[0]
	if l > 1 {
		(*h)[l-1], (*h)[0] = (*h)[0], (*h)[l-1]
		*h = (*h)[:l-1]
		h.adjustDown(0, l-1)
	} else {
		*h = make([]int, 0)
	}
	return r
}

func (h *arrayHeap) adjustUp() {
	childIndex := len([]int(*h)) - 1
	parentIndex := (childIndex - 1) / 2
	for childIndex > 0 && (*h)[childIndex] < (*h)[parentIndex] {
		(*h)[childIndex], (*h)[parentIndex] = (*h)[parentIndex], (*h)[childIndex]
		childIndex = parentIndex
		parentIndex = (childIndex - 1) / 2
	}
}

func (h *arrayHeap) adjustDown(parentIndex int, l int) {
	childIndex := 2*parentIndex + 1
	for childIndex < l {
		if childIndex+1 < l && (*h)[childIndex+1] < (*h)[childIndex] {
			childIndex++
		}
		if (*h)[parentIndex] < (*h)[childIndex] {
			break
		}
		(*h)[childIndex], (*h)[parentIndex] = (*h)[parentIndex], (*h)[childIndex]
		parentIndex = childIndex
		childIndex = 2*parentIndex + 1
	}
}

func TestNewArrayHeap(t *testing.T) {
	h := NewArrayHeap([]int{9,3,7,4,5,2,8,6,1})
	fmt.Printf("%v \n",h)
	i:=h.Pop()
	fmt.Printf("%v \n",h)
	h.Push(i)
	fmt.Printf("%v \n",h)
}

/*
=== RUN   TestNewArrayHeap
&[1 3 2 4 5 7 8 6 9] 
&[2 3 7 4 5 9 8 6] 
&[1 2 7 3 5 9 8 6 4] 
--- PASS: TestNewArrayHeap (0.00s)
PASS

Process finished with exit code 0
*/

优先队列

最大堆/最小堆结合队列FIFO特性，保证出队列的都是最大值/最小值

图

图由有限顶点(vertex),有限边(edge)集合组成
1.有向图      边存在方向。 入节点数目 入度;出节点数目 出度
2.无向图      边不存在方向
3.带权图      边存在权重
4.稀疏/稠密图  e<nlog2n
实现优点缺点
邻接矩阵边和顶点兼顾，可以使用矩阵运算浪费空间
邻接表存储空间更优，更接近树结构无法兼顾不存在边

遍历

  1. 深度优先遍历：首节点->相邻节点
  2. 广度优先遍历：首节点->所有相邻节点-> 下一层所有相邻节点 。深度遍历+队列实现
// 遍历框架
func DFS(*graph){
  visited := make(map[*graph]bool)
  dfs(*graph,visited)
}

// 深度优遍历
func dfs(*gragh,visited){
  if gragh == nil{
    return
  }
  visited[*graph] = true
  // dfs遍历位置
  for edge:=range graph.edges{
    if !visited[*edge]{
      dfs(*edge)
    }
  }
}


// 遍历框架
func BFS(*graph){
  visited := make(map[*graph]bool)
  bfs(*graph,visited)
}

// 广度优先遍历
func bfs(*graph,visited){
  if gragh == nil{
    return
  }
  visited[*graph] = true
  queue:=newQueue()
  queue.put(gragh)
  for queue.isEmpty() {
    node = queue.pop()
    // bfs遍历位置
    for edge:=range node.edges{
      if !visited[*edge]{
          visited[*edge] = true
          queue.put(edge)
      }
 		}
  }
}

简易实现

邻接表

package test

import "fmt"

type graph struct {
	key string
	edges map[string]*graph
}


func NewGraph(ns []string,edges [][2]string) *graph {
	g:=&graph{edges:make(map[string]*graph)}
	for _,n :=range ns{
		if _,ok:=g.edges[n];!ok{
			g.edges[n] = &graph{
				key:   n,
				edges: make(map[string]*graph),
			}
		}
	}
	for _,edge:=range edges{
		g.edges[edge[0]].edges[edge[1]]=g.edges[edge[1]]
	}
	return g
}

// 遍历框架
func DFS(g *graph){
	visited := make(map[*graph]bool)
	g.dfs(visited)
}

// 深度优遍历
func (g *graph)dfs(visited map[*graph]bool){
	if g == nil{
		return
	}
	visited[g] = true
	// dfs遍历位置
	fmt.Printf("dfs %v \n",g.key)
	for _,edge:=range g.edges{
		if !visited[edge]{
			edge.dfs(visited)
		}
	}
}


// 遍历框架
func BFS(g *graph){
	visited := make(map[*graph]bool)
	g.bfs(visited)
}

// 广度优先遍历
func (g *graph)bfs(visited map[*graph]bool){
	if g == nil{
		return
	}
	visited[g] = true
	queue:=NewArrayQueue()
	queue.Push(g)
	for len(queue.data)!=0 {
		if node,ok := queue.Pop().(*graph);ok{
			// bfs遍历位置
			fmt.Printf("bfs %v \n",node.key)
			for _,edge:=range node.edges{
				if !visited[edge]{
					visited[edge] = true
					queue.Push(edge)
				}
			}
		}else{
			break
		}

	}
}

func (g *graph)Print(m map[*graph]bool)  {
	if g.key !=""{
		fmt.Printf("%v->",g.key)
	}
	for _, e := range g.edges {
		if _,ok:=m[e];!ok{
            e.Print(m)
            m[e]=true
		}
		if g.key !=""{
			fmt.Printf("%v->",e.key)
		}
	}
	fmt.Printf("\n")
}

func TestNewGraph(t *testing.T) {
	g:=NewGraph([]string{"1","2","3","4","5","6"},[][2]string{[2]string{"1","2"},[2]string{"1","3"},[2]string{"2","4"},[2]string{"2","5"}})
	g.Print(make(map[*graph]bool))
	DFS(g)
	BFS(g)
}

/*
=== RUN   TestNewGraph
5->
6->
1->2->4->
4->5->
2->3->
3->

dfs  
dfs 2 
dfs 4 
dfs 5 
dfs 3 
dfs 6 
dfs 1 
bfs  
bfs 1 
bfs 2 
bfs 3 
bfs 4 
bfs 5 
bfs 6 
--- PASS: TestNewGraph (0.00s)
PASS

Process finished with exit code 0
*/

邻接矩阵

type graph2 struct {
	data map[string]map[string]bool
}

func NewGraph2(ns []string,edges [][2]string) *graph2 {
	g:=&graph2{data:make(map[string]map[string]bool)}
	for _,n :=range ns{
		g.data[n]=make(map[string]bool)
	}
	for _,edge:=range edges{
		g.data[edge[0]][edge[1]]=true
	}
	return g
}

// 遍历框架
func DFS2(g *graph2){
	visited := make(map[string]bool)
	for node, edges := range g.data {
		if !visited[node] {
			g.dfs(node, edges, visited)
		}
	}
}

// 深度优遍历
func (g *graph2)dfs(key string,edges map[string]bool,visited map[string]bool){
	visited[key] = true
	// dfs遍历位置
	fmt.Printf("dfs %v \n",key)
	for k,f:=range edges{
		if !visited[k]&&f{
			g.dfs(k,g.data[k],visited)
		}
	}
}


// 遍历框架
func BFS2(g *graph2){
	visited := make(map[string]bool)
	for node, _ := range g.data {
		if !visited[node] {
			g.bfs(node, visited)
		}
	}
}

// 广度优先遍历
func (g *graph2)bfs(key string,visited map[string]bool){
	queue:=NewArrayQueue()
	visited[key] = true
	queue.Push(key)
	for len(queue.data)!=0 {
		if node,ok := queue.Pop().(string);ok{
			// bfs遍历位置
			fmt.Printf("bfs %v \n",node)
			for k,f:=range g.data[key]{
				if !visited[k]&&f{
					visited[k] = true
					queue.Push(k)
				}
			}
		}else{
			break
		}

	}
}


func (g *graph2)Print(m map[string]bool)  {
	for key, edges := range g.data {
		fmt.Printf("%v: \n",key)
		for e, f := range edges {
			if _,ok:=m[e];!ok&&f{
				fmt.Printf("%v - >%v \n",key,e)
				m[e]=true
			}
		}
		fmt.Printf("\n")
	}

}

func TestNewGraph(t *testing.T) {
	g:=NewGraph2([]string{"1","2","3","4","5","6"},[][2]string{[2]string{"1","2"},[2]string{"1","3"},[2]string{"2","4"},[2]string{"2","5"}})
	g.Print(make(map[string]bool))
	DFS2(g)
	BFS2(g)
}

/*
=== RUN   TestNewGraph
6: 

1: 
1 - >2 
1 - >3 

2: 
2 - >4 
2 - >5 

3: 

4: 

5: 
dfs 4 
dfs 5 
dfs 6 
dfs 1 
dfs 2 
dfs 3 
bfs 3 
bfs 4 
bfs 5 
bfs 6 
bfs 1 
bfs 2 
--- PASS: TestNewGraph (0.00s)
PASS

Process finished with exit code 0
*/
Mars'Ares
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构概论(一)
IvoryTower152的博客
09-16 158
1.1 数据结构的概念 1.1.2 数据与数据结构 数据是信息的载体，是描述客观事物的数、字符以及所有能输入到计算机中并被计算机程序识别和处理的符号的集合。 数据大致可以分为两类，一类是**数值性数据，包括整数、浮点数、复数、双精度数等，主要用于工程和科学计算，以及商业事务处理，另一类是非数值数据**，主要包括字符和字符串，以及文字、图形、图像、语音等数据 C++数据类型 进行编程语言编程时，需要用到各种变量来存储各种信息，C++为程序员提供了种类丰富的内置数据类型和用户自定义的数据类型 整型：int，-
go-test-server
03-13
Go 标准库中的 `encoding/json` 包提供了将数据结构序列化为 JSON 字符串，以及将 JSON 字符串反序列化为 Go 结构体的功能。 6. **错误处理**：在 Go 中，错误处理是通过返回错误值完成的。服务器可能会对各种错误...
Go基础：数据结构（定义和go语言实现）
林钟一的博客
03-16 1548
最近在刷leetcode的每日一题的，总会碰到一些问题，因为竞赛时用惯了c++的STL库，有数据结构的实现，可以直接使用，到现在用go总会遇到头疼的事情就是用到数据结构的时候需要自己定义结构并且实现方法，刚好这几天笔试里面也有关于数据结构的题目，所以这一篇主要来讲一下数据结构。
go数据结构
止语的博客
09-05 2108
go语言中提供了包括数组，结构体，映射，切片等数据结构，当然指针也可以作为一种数据类型来学习和沉淀。Ken Thompson(肯·汤普森)和Rob Pike(罗布·派克)创建go语言时，吸取了目前现有主流语言的一些特点，因为Ken Thompson是C语言的主要创造者之一，因此可能从其角度理解，指针和结构体是很好的一种数据类型，因此go语言中也有该数据结构。 虽然这里是介绍go的主要数据结构，但是先普及一点Go诞生的小知识： 计算机硬件技术更新频繁，性能提高很快。目前主流的编程语言发展明...
Go数据结构的底层原理（图文详解）
最新发布
一枚coder的精进（荆棘）之路
04-07 1015
Go程序开发进阶保姆级教程，图文详解Go数据结构（字符串、数组、切片、map、结构体、接口）的底层原理及应用
go语言实现图的广度优先与深度优先搜索
微小冷的学习笔记
01-05 3893
通过go语言完成无向图的实现，并实现其深度优先搜索算法(DFS)与广度优先搜索算法(BFS)。
图算法 广度优先、深度优先递归与非递归golang实现
qq_31220203的博客
07-23 325
图算法 广度优先和深度优先递归与非递归
广度遍历算法：用go语言实现走迷宫
坚持硬核
01-06 216
大体思路： 迷宫在逻辑上就是一个四叉树，广度优先算法走迷宫，就是用广度优先算法遍历四叉树 即先把1步能走到的点遍历一下，看看这些点种有没有终点，然后把两步能走到的点遍历一下... 问题关键其实是确保访问顺序，如何确保顺序呢？ 因为由很多个点要依次访问，所以我们必须用一个队列或者用一个栈来存放这些待访问的点 如果用队列（先进先出）来依次访问这些点，就是广度优先算法， 如果用栈（先进后出）来依次访问这些点，就是深度优先算法 即从起始点（0步点）得到所有1步能走到的点，然后把所有1步能走到的点入队列
SimpleWebServer:Go-lang测试项目
03-29
"SimpleWebServer:Go-lang测试项目" 这个标题表明这是一个使用Go语言（也称为Golang）编写的简易Web服务器项目，主要目的是进行测试和实践。Go语言是Google公司开发的一种静态类型、编译型、并发型且具有垃圾回收...
gohttp-todo-example:简单的一切应用
05-24
2. **models**目录：可能包含定义任务数据结构的文件，如`todo.go`。 3. **handlers**目录：存放处理HTTP请求的函数，如添加任务、删除任务、更新任务状态等。 4. **routes**文件：定义了URL路由和对应的处理函数。 ...
智商简易测试源代码 -ASP源码.zip
12-16
标题中的“智商简易测试源代码 - ASP源码.zip”表明这是一个使用ASP（Active Server Pages）编程语言编写的智商测试应用程序的源代码包。ASP是一种由微软开发的服务器端脚本环境，用于创建动态网页和Web应用程序。源...
Go-Go基础数据结构和算法实现
08-14
Go基础数据结构和算法实现
简易浏览器
06-29
这可以通过自定义数据结构，如链表或栈来实现。 3. **页面加载进度显示**：可以监听WebBrowser控件的DocumentCompleted事件，结合ProgressChanged事件更新进度条状态。 4. **安全和隐私策略**：考虑到浏览器可能访问...
Go分布式爬虫笔记(十九) 4月Day3
成长之路
04-05 982
以下图中的拓扑结构为例，节点 A 标识的是爬取的初始网站，在网站 A 中，有 B、C 两个链接需要爬取，以此类推。查找完之后，再是 C、F，最后是 G。如果我们现在只知道每门课程的前序课程，不清楚完整的学习路径，我们要怎么设计这一系列课程学习的顺序，确保我们在学习任意一门课程的时候，都已经学完了它的前序课程呢？查看 HTML 文本的规则会发现，正本包含在xxxx当中，所以我们可以用正则表达式这样书写规则函数，意思是当发现正文中有对应的文字，就将当前帖子的 URL 写入到 Items 当中。
Golang 二叉树系列【二叉树深度】
jackl
10-24 1448
题目 输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。 题目示例 例如： 给定二叉树 [3,9,20,null,null,15,7] 3 / \ 9 20 / \ 15 7 返回它的最大深度3 解题思路 可以利用深度优先搜索（DFS）、广度优先搜索（BFS） 常见的 DFS（Deep First Search） 先序遍历（根左右）、中序遍历（左根右）、后序遍历（..
day21 Go 实现的深度优先搜索实现迷宫算法
weixin_30556161的博客
11-21 98
#Go 实现的深度优先搜索实现迷宫算法 package main import ( "errors" "fmt" "os" ) // 读取文件中的数据，使用循环生成迷宫图 func readMazeFile(filename string) [][]int { file, err := os.Open(filename) defer ...
Golang基本数据结构
追求幸福，探索未知的博客
06-18 1376
golang 基于数据结构
常见数据结构和算法(golang)
poqweur的博客
04-22 874
go实现数据结构和算法
go语言实现数据结构
10-20
Go语言是一种开源的编程语言，它支持面向对象编程、并发编程和函数式编程等多种编程范式。在Go语言中，数据结构的实现...同时，Go语言还提供了一些第三方库，如container包、heap包等，可以方便地实现常见的数据结构。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Mars'Ares

请我喝杯咖啡吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值