1.集合
1.1二叉搜索树实现集合
package main
type Node struct {
e int
left *Node
right *Node
}
type tree struct {
size int
root *Node
}
func NewTree() *tree {
return &tree{}
}
func (t *tree) getSize() int{
return t.size
}
func (t *tree) isEmpty() bool{
return t.size==0
}
func (t *tree) add(e int) {
t.root = t.addR(t.root, e)
}
func (t *tree) addR(node *Node, e int) *Node {
if node == nil {
t.size++
return &Node{e: e}
} else if node.e > e {
node.left = t.addR(node.left, e)
} else {
node.right = t.addR(node.right, e)
}
return node
}
func (t *tree) contains(e int) bool {
return t.containsR(t.root, e)
}
func (t *tree) containsR(node *Node, e int) bool {
if node == nil {
return false
}
if node.e == e {
return true
} else if node.e > e {
return t.containsR(node.left, e)
} else {
return t.containsR(node.right, e)
}
}
func (t *tree) min() *Node {
return t.minR(t.root)
}
func (t *tree) minR(node *Node) *Node {
if node == nil {
return nil
}
if node.left == nil {
return node
}
return t.minR(node.left)
}
func (t *tree) removeMin() *Node {
t.root = t.removeMinR(t.root)
return t.min()
}
func (t *tree) removeMinR(node *Node) *Node {
if node.left == nil {
t.size--
rightNode := node.right
node.right = nil
return rightNode
}
node.left = t.removeMinR(node.left)
return node
}
func (t *tree) max() *Node {
return t.minR(t.root)
}
func (t *tree) maxR(node *Node) *Node {
if node == nil {
return nil
}
if node.right == nil {
return node
}
return t.maxR(node.right)
}
func (t *tree) removeMax() *Node {
t.root = t.removeMaxR(t.root)
return t.max()
}
func (t *tree) removeMaxR(node *Node) *Node {
if node.right == nil {
t.size--
leftNode := node.left
node.left = nil
return leftNode
}
node.right = t.removeMaxR(node.right)
return node
}
func (t *tree) remove(e int) {
t.root = t.removeR(t.root, e)
}
func (t *tree) removeR(node *Node, e int) *Node {
if node == nil {
return nil
}
if node.e > e {
node.left = t.removeR(node.left, e)
return node
} else if node.e < e {
node.right = t.removeR(node.right, e)
return node
} else { //e == node.e
//没有左子树
if node.left == nil {
t.size--
rightNode := node.right
node.right = nil
return rightNode
}
//没有右子树
if node.right == nil {
t.size--
leftNode := node.left
node.left = nil
return leftNode
}
//待删除节点左右子树都不为空
//找到比待删除节点大的最小节点，即待删除节点右子树的最小节点
//用这个节点顶替待删除的节点
//由于在removeMinR中进行过一次size--，实际那个节点没有被删除，所以这里不需要再多进行一次size--了
successor := t.minR(node.right)
//这个要写在前面，先把successor从右子树中移除，然后在进行赋值操作
successor.right = t.removeMinR(node.right)
successor.left = node.left
node.left = nil
node.right = nil
return successor
}
}
type BSTSet struct {
BST *tree
}
func New() *BSTSet {
return &BSTSet{
BST: NewTree(),
}
}
func (bs *BSTSet) Add(e int) {
bs.BST.add(e)
}
func (bs *BSTSet) Remove(e int) {
bs.BST.remove(e)
}
func (bs *BSTSet) Contains(e int) bool {
return bs.BST.contains(e)
}
func (bs *BSTSet) GetSize() int {
return bs.BST.getSize()
}
func (bs *BSTSet) IsEmpty() bool {
return bs.BST.isEmpty()
}
1.2链表实现集合
package main
import "fmt"
type Node struct {
e interface{}
next *Node
}
type LinkList struct {
dummyHead *Node
size int
}
func NewLinkList() *LinkList {
return &LinkList{
dummyHead: &Node{},
size: 0,
}
}
func (l *LinkList) getSize() int{
return l.size
}
func (l *LinkList) isEmpty() bool{
return l.size==0
}
func (l *LinkList) verifyIndex(index int) error {
if index < 0 || index > l.size {
return fmt.Errorf("index out of range")
}
return nil
}
func (l *LinkList) add(index int, e interface{}) {
err := l.verifyIndex(index)
if err != nil {
panic(err)
}
pre := l.dummyHead
for i := 0; i < index; i++ {
pre = pre.next
}
pre.next = &Node{e: e, next: pre.next}
l.size++
}
func (l *LinkList) AddFirst(e interface{}) {
l.add(0, e)
}
func (l *LinkList) AddLast(e interface{}) {
l.add(l.size, e)
}
func (l *LinkList) get(index int) interface{} {
err := l.verifyIndex(index)
if err != nil {
panic(err)
}
cur := l.dummyHead.next
for i := 0; i < index; i++ {
cur = cur.next
}
return cur.e
}
func (l *LinkList) GetFirst() interface{} {
return l.get(0)
}
func (l *LinkList) GetLast() interface{} {
return l.get(l.size)
}
func (l *LinkList) Contains(e interface{}) bool {
cur := l.dummyHead.next
for {
if cur == nil {
break
}
if e == cur.e {
return true
}
cur = cur.next
}
return false
}
func (l *LinkList) ToString() string {
cur := l.dummyHead.next
str := ""
for cur != nil {
str += fmt.Sprintf("%d-->", cur.e.(int))
cur = cur.next
}
return str
}
func (l *LinkList) update(index int, e interface{}) {
err := l.verifyIndex(index)
if err != nil {
panic(err)
}
cur := l.dummyHead.next
for i := 0; i < index; i++ {
cur = cur.next
}
cur.e = e
}
func (l *LinkList) UpdateFirst(e interface{}) {
l.update(0, e)
}
func (l *LinkList) UpdateLast(e interface{}) {
l.update(l.size, e)
}
func (l *LinkList) remove(index int) {
err := l.verifyIndex(index)
if err != nil {
panic(err)
}
pre := l.dummyHead
for i := 0; i < index; i++ {
pre = pre.next
}
delNode := pre.next
pre.next = delNode.next
delNode.next = nil
l.size--
}
// 从链表中删除元素e
func (l *LinkList) RemoveElement(e int) {
prev := l.dummyHead
for prev.next != nil {
if prev.next.e == e {
delNode := prev.next
prev.next = delNode.next
delNode.next = nil
l.size--
break
}
prev = prev.next
}
}
type LinkedListSet struct {
LinkedList *LinkList
}
func New() *LinkedListSet {
return &LinkedListSet{
LinkedList: NewLinkList(),
}
}
func (ls *LinkedListSet) Add(e interface{}) {
if !ls.LinkedList.Contains(e) {
ls.LinkedList.AddFirst(e)
}
}
func (ls *LinkedListSet) Remove(e int) {
ls.LinkedList.RemoveElement(e)
}
func (ls *LinkedListSet) Contains(e interface{}) bool {
return ls.LinkedList.Contains(e)
}
func (ls *LinkedListSet) GetSize() int {
return ls.LinkedList.getSize()
}
func (ls *LinkedListSet) IsEmpty() bool {
return ls.LinkedList.isEmpty()
}
1.3时间复杂度分析
当数据是有序的，例如[1,2,3,4,5,6,7]形成的二叉树就和链表一样了，时间复杂度也是O(n)了
O(logn)和O(n)时间复杂度的对比
2.映射Map
2.1二叉搜索树实现map
2.2链表实现map
2.3时间复杂度分析
2.4题目
package main
import "fmt"
func uniqueMorseRepresentations(words []string) int {
code := []string{".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."}
wordCodeMap :=make(map[string]int)
for _, word := range words {
wordCode := ""
for _,i :=range word{
wordCode += code[i-97]
}
wordCodeMap[wordCode] =1
}
return len(wordCodeMap)
}
func main() {
words := []string{"gin", "zen", "gig", "msg"}
fmt.Println(uniqueMorseRepresentations(words))
}
