手擼golang 基本數據結構與算法 鏈表
手擼golang 基本數據結構與算法 鏈表
緣起
最近閱讀<<個人第一本算法書>>(【日】石田保輝；宮崎修一)
本系列筆記擬採用golang練習之node
鏈表
鏈表是數據結構之一，其中的數據呈線性排列。 每一個數據節點都有1個「指針」，它指向下一個數據的內存地址。 訪問數據時，咱們須要從鏈表頭部開始查找（線性查找）， 若是目標數據在鏈表最後的話，須要的時間就是O(n)。 另外，添加數據只須要更改兩個指針的指向，因此耗費的時間與n無關。 若是已經到達了添加數據的位置，那麼添加操做只需花費O(1)的時間。 刪除數據一樣也只需O(1)的時間。 摘自 <<個人第一本算法書>>(【日】石田保輝；宮崎修一)
目標
- 實現一個鏈表, 提供與數組相似的線性訪問接口
設計
- ILinkedList: 鏈表接口
- IListIterator: 鏈表迭代器接口
- tLinkedList: 鏈表, 實現ILinkedList接口
- tListIterator: 鏈表迭代器, 實現IListIterator接口
單元測試
linked_list_test.gogolang
package data_structure
import (
"fmt"
"learning/gooop/data_structure/linked_list"
"strings"
"testing"
)
func Test_LinkedList(t *testing.T) {
fnAssertTrue := func(b bool, msg string) {
if !b {
panic(msg)
}
}
list := linked_list.NewLinkedList()
state := list.String()
t.Log(state)
fnAssertTrue(state == "h=nil,t=nil,s=0", "expecting empty list")
list.Append(0)
state = list.String()
t.Log(state)
fnAssertTrue(state == "h=0,t=0,s=1,0", "expecting [0]")
list.Append(1)
state = list.String()
t.Log(state)
fnAssertTrue(state == "h=0,t=1,s=2,0,1", "expecting [0,1]")
e,it := list.Get(0)
t.Log(it)
fnAssertTrue(e == nil, "expecting e == nil")
fnAssertTrue(it == 0, "expecting 0")
e,it = list.Get(1)
t.Log(it)
fnAssertTrue(e == nil, "expecting e == nil")
fnAssertTrue(it == 1, "expecting 1")
e = list.Set(0, 10)
state = list.String()
t.Log(state)
fnAssertTrue(e == nil, "expecting e == nil")
fnAssertTrue(state == "h=10,t=1,s=2,10,1", "expecting [10,1]")
e = list.Set(1, 20)
state = list.String()
t.Log(state)
fnAssertTrue(e == nil, "expecting e == nil")
fnAssertTrue(state == "h=10,t=20,s=2,10,20", "expecting [10,20]")
e = list.Remove(1)
state = list.String()
t.Log(state)
fnAssertTrue(e == nil, "expecting e == nil")
fnAssertTrue(state == "h=10,t=10,s=1,10", "expecting [10]")
e = list.Remove(0)
state = list.String()
t.Log(state)
fnAssertTrue(e == nil, "expecting e == nil")
fnAssertTrue(state == "h=nil,t=nil,s=0", "expecting []")
e = list.Insert(0, 0)
state = list.String()
t.Log(state)
fnAssertTrue(e == nil, "expecting e == nil")
fnAssertTrue(state == "h=0,t=0,s=1,0", "expecting [0]")
e = list.Insert(1, 1)
state = list.String()
t.Log(state)
fnAssertTrue(e == nil, "expecting e == nil")
fnAssertTrue(state == "h=0,t=1,s=2,0,1", "expecting [0,1]")
e = list.Insert(3, 3)
t.Log(e)
fnAssertTrue(e != nil, "expecting e != nil")
e = list.Insert(-1, -1)
t.Log(e)
fnAssertTrue(e != nil, "expecting e != nil")
items := make([]string, 0)
for iter := list.Iterator();iter.More(); {
e,v := iter.Next()
fnAssertTrue(e == nil, "expecting e == nil")
items = append(items, fmt.Sprintf("%v", v))
}
state = strings.Join(items, ",")
t.Log(state)
fnAssertTrue(state == "0,1", "expecting [0,1]")
}
測試輸出
$ go test -v linked_list_test.go
=== RUN Test_LinkedList
linked_list_test.go:19: h=nil,t=nil,s=0
linked_list_test.go:24: h=0,t=0,s=1,0
linked_list_test.go:29: h=0,t=1,s=2,0,1
linked_list_test.go:33: 0
linked_list_test.go:38: 1
linked_list_test.go:44: h=10,t=1,s=2,10,1
linked_list_test.go:50: h=10,t=20,s=2,10,20
linked_list_test.go:56: h=10,t=10,s=1,10
linked_list_test.go:62: h=nil,t=nil,s=0
linked_list_test.go:68: h=0,t=0,s=1,0
linked_list_test.go:74: h=0,t=1,s=2,0,1
linked_list_test.go:79: index out of bounds
linked_list_test.go:83: index out of bounds
linked_list_test.go:93: 0,1
--- PASS: Test_LinkedList (0.00s)
PASS
ok command-line-arguments 0.002s
ILinkedList.go
鏈表接口算法
package linked_list
type ILinkedList interface {
Size() int
IsEmpty() bool
IsNotEmpty() bool
Get(i int) (error,interface{})
Set(i int, it interface{}) error
Append(it interface{})
Remove(i int) error
Insert(i int, it interface{}) error
Iterator() IListIterator
String() string
}
IListIterator.go
鏈表迭代器接口數組
package linked_list
type IListIterator interface {
More() bool
Next() (error,interface{})
}
tLinkedList.go
鏈表, 實現ILinkedList接口數據結構
package linked_list
import (
"errors"
"fmt"
"strings"
)
type tLinkedList struct {
head *tLinkedNode
tail *tLinkedNode
size int
}
type tLinkedNode struct {
value interface{}
next *tLinkedNode
}
var gIndexOutofBoundsError = errors.New("index out of bounds")
func NewLinkedList() ILinkedList {
return &tLinkedList{
head: nil,
tail: nil,
size: 0,
}
}
func newLinkedNode(value interface{}) *tLinkedNode {
return &tLinkedNode{
value,nil,
}
}
func (me *tLinkedList) Size() int {
return me.size
}
func (me *tLinkedList) IsEmpty() bool {
return me.size <= 0
}
func (me *tLinkedList) IsNotEmpty() bool {
return !me.IsEmpty()
}
func (me *tLinkedList) Get(i int) (error,interface{}) {
e,_,node := me.getNodeAt(i)
if e != nil {
return e, nil
}
return e,node.value
}
func (me *tLinkedList) getNodeAt(i int) (err error, prev *tLinkedNode, node *tLinkedNode) {
if i >= me.size || i < 0 {
return gIndexOutofBoundsError, nil, nil
}
n := 0
prev = nil
node = me.head
for {
if n >= i {
return nil, prev, node
}
if node == nil {
return gIndexOutofBoundsError, nil, nil
}
n++
prev = node
node = node.next
}
}
func (me *tLinkedList) Set(i int, value interface{}) error {
e,prev,node := me.getNodeAt(i)
if e != nil {
return e
}
nn := newLinkedNode(value)
if prev == nil {
me.head = nn
} else {
prev.next = nn
}
nn.next = node.next
if nn.next == nil {
me.tail = nn
}
return nil
}
func (me *tLinkedList) Append(value interface{}) {
nn := newLinkedNode(value)
t := me.tail
if t == nil {
me.head = nn
} else {
t.next = nn
}
me.tail = nn
me.size++
}
func (me *tLinkedList) Remove(i int) error {
e,prev,node := me.getNodeAt(i)
if e != nil {
return e
}
if prev != nil {
prev.next = node.next
} else {
me.head = node.next
}
if node.next == nil {
me.tail = prev
} else {
me.tail = node.next
}
me.size--
return nil
}
func (me *tLinkedList) Insert(i int, value interface{}) error {
nn := newLinkedNode(value)
if i == me.size {
// always allow inserting tail
t := me.tail
me.tail = nn
if t != nil {
t.next = nn
}
if me.head == nil {
me.head = nn
}
me.size++
return nil
}
e,prev,node := me.getNodeAt(i)
if e != nil {
return e
}
if prev == nil {
me.head = nn
} else {
prev.next = nn
}
nn.next = node
me.size++
return nil
}
func (me *tLinkedList) Iterator() IListIterator {
items := make([]interface{}, me.size)
i := 0
for node := me.head;; {
if node == nil {
break
}
items[i] = node.value
node = node.next
i++
}
return newListIterator(items)
}
func (me *tLinkedList) String() string {
items := make([]string, 0)
if me.head == nil {
items = append(items, "h=nil")
} else {
items = append(items, fmt.Sprintf("h=%v", me.head.value))
}
if me.tail == nil {
items = append(items, "t=nil")
} else {
items = append(items, fmt.Sprintf("t=%v", me.tail.value))
}
items = append(items, fmt.Sprintf("s=%v", me.size))
for node:=me.head;node != nil; {
items = append(items, fmt.Sprintf("%v", node.value))
node = node.next
}
return strings.Join(items, ",")
}
tListIterator.go
鏈表迭代器, 實現IListIterator接口app
package linked_list
type tListIterator struct {
items []interface{}
count int
pos int
}
func newListIterator(items []interface{}) IListIterator {
size := len(items)
copy := make([]interface{}, size)
for i,it := range items {
copy[i] = it
}
return &tListIterator{
items: copy,
count: size,
pos: 0,
}
}
func (me *tListIterator) More() bool {
return me.pos < me.count
}
func (me *tListIterator) Next() (error,interface{}) {
if me.pos >= me.count {
return gIndexOutofBoundsError, nil
}
n := me.pos
me.pos++
return nil, me.items[n]
}
(end)oop
相關文章
- 1. 數據結構與算法篇 鏈表
- 2. 數據結構與算法——鏈表（上）
- 3. 數據結構與算法之鏈表
- 4. 「算法與數據結構」鏈表的9個基本操做
- 5. 『數據結構與算法』——鏈表
- 6. 數據結構與算法--鏈表
- 7. 算法與數據結構(二)：鏈表
- 8. 數據結構與算法（單鏈表）
- 9. 數據結構與算法基本
- 10. 數據結構基礎算法-鏈表
- 更多相關文章...
- • Redis鏈表（linked-list）數據結構和常用命令 - Redis教程
- • C# 基本語法 - C#教程
- • Kotlin學習（一）基本語法
- • 算法總結-回溯法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. eclipse設置粘貼字符串自動轉義
- 2. android客戶端學習-啓動模擬器異常Emulator: failed to initialize HAX: Invalid argument
- 3. android.view.InflateException: class com.jpardogo.listbuddies.lib.views.ListBuddiesLayout問題
- 4. MYSQL8.0數據庫恢復 MYSQL8.0ibd數據恢復 MYSQL8.0恢復數據庫
- 5. 你本是一個肉體，是什麼驅使你前行【1】
- 6. 2018.04.30
- 7. 2018.04.30
- 8. 你本是一個肉體，是什麼驅使你前行【3】
- 9. 你本是一個肉體，是什麼驅使你前行【2】
- 10. 【資訊】LocalBitcoins達到每週交易比特幣的7年低點
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 數據結構與算法篇 鏈表
- 2. 數據結構與算法——鏈表（上）
- 3. 數據結構與算法之鏈表
- 4. 「算法與數據結構」鏈表的9個基本操做
- 5. 『數據結構與算法』——鏈表
- 6. 數據結構與算法--鏈表
- 7. 算法與數據結構(二)：鏈表
- 8. 數據結構與算法（單鏈表）
- 9. 數據結構與算法基本
- 10. 數據結構基礎算法-鏈表