GoDS简单使用

嘻嘻 发现一个好东西：https://github.com/emirpasic/gods 

类似于C++的STL容器，使用GO语言封装了多种基础的数据结构，包括set/tree/list/map/stack，以及迭代器等，

 接下来挑几个常用的进行使用示范，最全的文档还是来自官网readme

arraylist

arraylist的数据结构非常简单，使用interface类型接收所有类型的value，并且会返回interface类型：

type List struct {
    elements []interface{}
    size     int
}

package GoDS

import (
	"fmt"
	"github.com/emirpasic/gods/lists/arraylist"
)

func TestList(){
	//创建
	mylist1 := arraylist.List{}  //可以指定类型进行创建
	mylist2 := arraylist.New()  //也可以调用new方法进行创建  推荐这种

	//插入
	for i :=0;i<10;i++{
		mylist1.Add(i)  //在列表尾进行插入
		mylist2.Insert(i,'a'+i)  //在指定位置进行插入
	}
	mylist1.Add(50,51,52,53,54) //也可以一次性插入多个

	//删除
	mylist1.Remove(3) //根据下标进行删除
	mylist2.Remove(mylist2.IndexOf(int('f')))   //根据值获取下标后  进行下标删除
	mylist2.Clear()   //全部删除

	//查询
	_,_ = mylist1.Get(0)  // 传入下标进行查询 返回两个值 value和bool是否存在
	_ = mylist1.Contains(4,5,6)  // 传入value进行查询，可传入多个，返回是否存在，任一不存在则为false
	_ = mylist1.Empty() //是否为空
	_ = mylist1.Size()
	mylist1.String() //返回string形式的全部元素
	mylist1.Values() //返回[]形式的全部元素
	
	//遍历
	//初始化迭代器
	it:= mylist1.Iterator()
	for it.Next(){
		fmt.Println(it.Index(),it.Value())
	} 
	//迭代器的移动操作 在之后迭代器小结中进行介绍
}

 hashset

set的特点是无序，唯一，底层使用的是go的map,其方法跟arraylist的差不多，但是没有根据下标进行操作的insert/get/interator等操作

type Set struct {
	items map[interface{}]struct{}
}

package GoDS

import (
	"fmt"
	"github.com/emirpasic/gods/sets/hashset"
)

func TestHashSet(){
	//创建
	myset1 := hashset.New()  //调用new方法进行创建

	//插入
	myset1.Add(0,1,1,3,4) //可以一次性插入1~N个
	//无序， 唯一
	
	//查询
	myset1.Contains(4,5,6)  // 传入value进行查询，可传入多个，返回是否存在，任一不存在则为false
	myset1.String() //返回string形式的全部元素
	myset1.Values() //返回[]形式的全部元素
	myset1.Empty() //是否为空
	myset1.Size()
	
	//遍历
	for _, c := range myset1.Values(){
		fmt.Println(c)
	}

	//删除
	myset1.Remove(1) //根据值进行删除
	myset1.Clear()   //全部删除
}

Stack

stack有两种，底层为 linklist /array，两种的暴露的方法一样，包括push/pop/peek等栈操作， 都是先进后出

package GoDS

import (
	"fmt"
	"github.com/emirpasic/gods/stacks/arraystack"
	"github.com/emirpasic/gods/stacks/linkedliststack"
)

func TestStack(){
	//创建
	mystack1 := linkedliststack.New()  //调用new方法进行创建
	//mystack2 := arraystack.New()

	//入栈
	for i :=0;i<10;i++{
		mystack1.Push(i)  //只能一次push一个元素 到栈顶
	}

	//查询
	_,_ = mystack1.Peek()  // 查询栈顶元素
	_ = mystack1.Empty() //是否为空
	_ = mystack1.Size()
	mystack1.String() //返回string形式的全部元素
	mystack1.Values() //返回[]形式的全部元素

	//遍历
	//初始化迭代器
	it:= mystack1.Iterator()
	for it.Next(){ //是从栈顶往栈底遍历 ,但是元素不出栈
		fmt.Println(it.Index(),it.Value())
	}
	//迭代器的移动操作 在之后迭代器小结中进行介绍

	//出栈
	_, _ = mystack1.Pop() //只能一次pop栈顶元素
	mystack1.Clear()   //全部出栈
}

Map

map存储键值对，底层使用的go的map,无法使用迭代器，只能根据key查询和删除

type Map struct {
    m map[interface{}]interface{}
}

package GoDS

import (
	"fmt"
	"github.com/emirpasic/gods/maps/hashmap"
)

func TestMap() {
	//创建
	mymap := hashmap.New() // empty

	//插入
	mymap.Put(1, "x")      // 1->x 插入键值对
	mymap.Put(2, "b")      // 2->b, 1->x (random order)
	mymap.Put(1, "a")      // 2->b, 1->a (random order)
	//查询
	_, _ = mymap.Get(1)    // b, true 根据key值进行查询
	_, _ = mymap.Get(3)    // nil, false
	_ = mymap.Values()     // 返回[]形式的所有value []interface {}{"b", "a"} (random order)
	_ = mymap.Keys()       // 返回[]形式的所有key[]interface {}{1, 2} (random order)
	mymap.Empty()          // true
	mymap.Size()           // 0

	//遍历
	for _,k := range mymap.Keys(){
		v, _ :=mymap.Get(k)
		fmt.Println(k,v)
	}
	//删除
	mymap.Remove(1)        // 2->b
	mymap.Clear()          // empty
}

Iterator

迭代器来啦  一看就会  一用就废（不是

func TestIterator(){
	//创建
	mylist1 := arraylist.New()
	mylist1.Add(50,51,52,53,54) //也可以一次性插入多个
	//遍历
	//初始化迭代器
	it:= mylist1.Iterator()
	for it.Begin();it.Next();{  //it.Begin()使it指到最开始的位置  it.Next()后移一个单元
		fmt.Println(it.Index(),it.Value())
		//it.Index() 返回it的下标    it.Value()返回下标初的值
	}
	it.Begin()  //移动到初始  无返回值
	it.End()  //移动到最后 无返回值
	it.Next() //往后移动一个
	it.Prev() //往前移动一个
	it.First() //移动到最前  这个有返回值
	it.Last() //移动到最后  这个有返回值
	//迭代器的移动操作 在之后迭代器小结中进行介绍
}

先这样 以后再补充