剑指offer-之-数据结构1

常考数据结构：数组，字符串，链表，树，栈，队列

数组和字符串是最常用的数据结构：用连续内存存储数字和字符。

链表和树也是很常用的数据结构，由于操作链表和树需要大量的指针，注意程序的鲁棒性。

栈是一个与递归相关的数据结构，同样队列也会广度优先算法相关。深刻理解这两种数据结构。

1.数组

内存连续，为所有数组预先分配内存。

为了解决数组的空间效率不高问题，又出现了多种动态数组。

[code]package main

import (
"fmt"
"github.com/pkg/errors"
)

//链表
type link struct {
id int32
next *link
}

func(head *link)addToTail(val int32) error{
pNew := link{id:val}

if head == nil {
return errors.New("operate nil link")
}

for {
if head.next != nil{
head = head.next
}else {
head.next = &pNew
break
}
}

return nil
}
func main1(){
node0 := link{id:0}
node1 := link{id:1}
node2 := link{id:2}
node3 := link{id:3}

node0.next = &node1
node1.next = &node2
node2.next = &node3

node0.addToTail(4)

fmt.Println(node3.next)
}

//栈
type stack struct {
array []int
indexNow int
}

//push
func(s *stack) pushStack(val int) int{
index := s.indexNow
index++
s.array[index] = val

return index
}
func(s *stack) pop() int{
index := s.indexNow
val := s.array[index]
index--
return val
}

//tree 未测试呢
type treeNode struct {
id int64
left *treeNode
right *treeNode
}

func(rootNode *treeNode)traverse(){
//理想情况
fmt.Println(rootNode.id)
if rootNode.left !=nil && rootNode.right != nil {
fmt.Println(rootNode.id)
rootNode.right.traverse()
rootNode.left.traverse()
}
}