golang基礎-高階資料結構

阿新 • • 發佈：2019-12-31

背景

golang 不像c++，已經有stl這種通用的高階資料結構。所以如果想要棧，佇列，連結串列等資料結構需要自己實現。

下面介紹下常用的幾種資料結構

連結串列

單連結串列是一種鏈式存取的資料結構，一個連結串列由一個或者多個節點組成，每個節點有一個指標指向下一個節點。以下是一個節點為int的連結串列實現。

package list

type List struct {
    Head * ListNode
    length int
}

type ListNode struct {
	Next *ListNode
    Data int
}

func (p *List) AddNode(data int) {
    if 
 p.Head == nil {
        p.Head = new(ListNode)
    }
    var node = &ListNode {
        Data : data,}
    currentNext := p.Head.Next
    p.Head.Next = node
    node.Next = currentNext
}

func (p *List) Lenth() int {
    return p.length
}

// delete specified pos
func (p *List) DeleteWithPos(pos int) {
    if 
 pos + 1 >  p.length {
        return
    }
    var i int
    pre := p.Head
    for {
        if i == pos {
            pre.Next = pre.Next.Next
        }
        pre = pre.Next
        i++
    }
    return
}

func (p *List) DeleteWithData(data int) {
    pre := p.Head
    for {
        if pre.Next == nil {
            break 

        }
        if data == pre.Next.Data {
            pre.Next = pre.Next.Next
        }
        pre = pre.Next
    }
    return
}
複製程式碼

佇列

佇列和生活中排隊的隊伍比較相似。特性是FIFO(first in first out)，先進先出。第一個進入佇列的，會第一個出來。舉個例子，你去銀行存錢，有10個人排隊，第一個加入隊伍的即1號，必定是第一個辦理業務的。

那麼看下golang 如何實現一個佇列：

package queue

import (
	"errors"
)

type Queue []interface{}

func (queue *Queue) Len() int {
	return len(*queue)
}

func (queue *Queue) IsEmpty() bool {
	return len(*queue) == 0
}

func (queue *Queue) Cap() int {
	return cap(*queue)
}

func (queue *Queue) Push(value interface{}) {
	*queue = append(*queue,value)
}

func (queue *Queue) Pop() (interface{},error) {
	theQueue := *queue
	if len(theQueue) == 0 {
		return nil,errors.New("Out of index,len is 0")
	}
	value := theQueue[0]
	*queue = theQueue[1:len(theQueue)]
	return value,nil
}
複製程式碼

棧

一種先入後出的資料結構。棧在生活中的場景，可以對應一個桶，裡面裝了大米，先放進去的最後才會被取出來。這裡使用interface實現一個相對通用的棧。

package stack

import "errors"

type Stack []interface{}

func (stack Stack) Len() int {
	return len(stack)
}

func (stack Stack) IsEmpty() bool {
	return len(stack) == 0
}

func (stack Stack) Cap() int {
	return cap(stack)
}

func (stack *Stack) Push(value interface{}) {
	*stack = append(*stack,value)
}

func (stack Stack) Top() (interface{},error) {
	if len(stack) == 0 {
		return nil,len is 0")
	}
	return stack[len(stack)-1],nil
}

func (stack *Stack) Pop() (interface{},error) {
	theStack := *stack
	if len(theStack) == 0 {
		return nil,len is 0")
	}
	value := theStack[len(theStack)-1]
	*stack = theStack[:len(theStack)-1]
	return value,nil
}
複製程式碼