集合和映射 Set and Map

1. 集合 Set

    1.1 定义

                集合是具有某种相似特性的事物的全体。它的重要特点是其中的数据元素无序且不重复，这也就是判断是否使用该容器的依据。

    1.2.1 利用二分搜索树实现集合

        利用我之前的树的定义和实现中的bst.go函数来调用而实现的

package arr

type Set struct{
	root Root_tree
}

/**
 * 利用二分搜索树来实现结合的curd
 */
//添加元素到集合中
func (set *Set) Addset(E int) {
	set.root.Add(E)
}

//遍历集合
func (set *Set) Forset() {
	set.root.Inorder()
}

//判断指定元素是否存在于集合内
func (set *Set) Emptyset(E int) bool {
	return set.root.Empty(E)
}

     1.2.2 利用链表实现集合

package arr

import (
	"container/list"
	"fmt"
)

type Set_list struct{}

var sl = list.New()

/**
 * 在集合中查询是否包含指定元素
 */
func (set *Set_list) Find(E int) bool {
	for e := sl.Front(); e != nil; e = e.Next() {
		if E == e.Value {
			return true
		}
	}
	return false
}

/**
 * 循环遍历集合
 */
func (set *Set_list) Foreach() {
	for e := sl.Front(); e != nil; e = e.Next() {
		fmt.Println(e.Value)
	}
}

/**
 * 在集合中添加指定元素
 */
func (set *Set_list) Add(E int) {
	if set.Find(E) != true {
		sl.PushBack(E)
	}
}

     1.2.3 两种时间复杂度的分析

                  

  

                

     1.2.4 leetcode 804号问题

           

package main

import (
	"container/list"
	"fmt"
)

func uniqueMorseRepresentations(words []string) int {
	var dan string
	var duo []string
	mosi := []string{".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."}
	zf := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"}
	//循环输入slice
	for _, v := range words {
		//循环单词
		for _, vv := range v {
			//循环字母
			for kkk, vvv := range zf {
				if string(vvv) == string(vv) {
					//单词中字符等于字母,绑定摩斯密码
					dan += mosi[kkk]
				}
			}
		}
		//循环完一个字符以后,插入新的slice
		//fmt.Println("出来:",dan)
		duo = append(duo, dan)
		Add(dan)
		dan = ""
	}
	return sl.Len()
}

var sl = list.New()

func Add(E string) {
	if Find(E) != true {
		sl.PushBack(E)
	}
}

func Find(E string) bool {
	for e := sl.Front(); e != nil; e = e.Next() {
		if E == e.Value {
			return true
		}
	}
	return false
}

func main() {
	q := []string{"gin", "zen", "gig", "msg"}
	fmt.Println(uniqueMorseRepresentations(q))

}

/**        10
 *        /  \
		7     15
 *     / \    /
      2   8  11
 *     \   \  \
        3   9  12
 */

 

     1.2.5 集合的其他运用

                               

 

2. 映射 Map

     2.1 定义

            Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value，key和value都可以是任何引用类型的数据。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较总是返回false。

                        

利用二分搜索树或链表都可以简单的去实现映射:

                             

 

     2.2 基于链表实现映射关系

package arr

//用链表来实现映射
type Map_list struct {
	K    interface{}
	V    interface{}
	Next *Map_list
}

var List_map *Map_list = nil
/**
 * Get获取映射的值
 *
 */
func (List_map *Map_list) Get(k interface{}) *Map_list {
	for List_map != nil {
		if List_map.K == k {
			return List_map
		}
		List_map = List_map.Next
	}
	return nil
}

/**
 * Add添加(修改)映射
 *
 */
func (List_map *Map_list) Add(k, v interface{}) {
	mapl := List_map.Get(k)
	if mapl == nil {
		//不存在,直接添加
		List_map.Next = &Map_list{k, v, List_map.Next}
	} else {
		mapl.V = v
	}
}

/**
 * remove删除
 */
func (List_map *Map_list) Remove(k interface{}) {
	prev := List_map
	for prev.Next != nil {
		if prev.Next.K == k {
			prev.Next = prev.Next.Next
		}else {
			prev = prev.Next
		}
	}
}

     

    2.3 基于二分搜索树实现链表

package arr

//利用二分搜索树实现map
type Map_bst struct {
	K     int
	V     interface{}
	Left  *Map_bst
	Right *Map_bst
}

var mapbst *Map_bst = nil

/**
 *Add添加操作
 */
func (mapbst *Map_bst) Add(k int, v interface{}) {
	map_add(mapbst, k, v)
}

/**
 * Get查询
 */
func (mapbst *Map_bst) Get(k int) *Map_bst {
	return map_get(mapbst, k)
}

//get方法
func map_get(tree *Map_bst, k int) *Map_bst {
	if tree == nil {
		return tree
	}
	if k < tree.K {
		return map_get(tree.Left, k)
	} else if k > tree.K {
		return map_get(tree.Right, k)
	}
	return tree
}

//add 递归添加
func map_add(tree *Map_bst, k int, v interface{}) *Map_bst {
	//判断是否是根
	if tree == nil {
		tree = &Map_bst{k, v, nil, nil}
		return tree
	}

	//递归转化更小问题
	if k < tree.K {
		tree.Left = map_add(tree.Left, k, v)
	} else if k > tree.K {
		tree.Right = map_add(tree.Right, k, v)
	} else {
		tree.V = v
	}
	return tree
}

 

       2.4 时间复杂度分析

                             

 

3. leecode的问题解答

    3.1 leecode349号问题

               

    常规解答

                  其中利用集合和映射的基本逻辑一样,只要在存储数据的时候替换即可

package main

import "fmt"

func intersection(nums1 []int, nums2 []int) (arr []int) {
	array := make(map[int]int)
	for _, v := range nums1 {
		for _, vv := range nums2 {
			if v == vv {
				if array[v] == 0 {
					array[v] = 1111
				}
			}
		}
	}
	for k, _ := range array {
		arr = append(arr, k)
	}
	return arr
}

func main() {
	a:=[]int{1,1,2,1}
	b:=[]int{2,2}
	fmt.Println(intersection(a,b))
}