添加 structures

Author: halfrost

structures/Heap.go

@@ -0,0 +1,30 @@
+package structures
+
+// intHeap 实现了 heap 的接口
+type intHeap []int
+
+func (h intHeap) Len() int {
+	return len(h)
+}
+
+func (h intHeap) Less(i, j int) bool {
+	return h[i] < h[j]
+}
+
+func (h intHeap) Swap(i, j int) {
+	h[i], h[j] = h[j], h[i]
+}
+
+func (h *intHeap) Push(x interface{}) {
+	// Push 使用 *h，是因为
+	// Push 增加了 h 的长度
+	*h = append(*h, x.(int))
+}
+
+func (h *intHeap) Pop() interface{} {
+	// Pop 使用 *h ，是因为
+	// Pop 减短了 h 的长度
+	res := (*h)[len(*h)-1]
+	*h = (*h)[:len(*h)-1]
+	return res
+}

structures/Heap_test.go

@@ -0,0 +1,30 @@
+package structures
+
+import (
+	"container/heap"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_intHeap(t *testing.T) {
+	ast := assert.New(t)
+
+	ih := new(intHeap)
+	heap.Init(ih)
+
+	heap.Push(ih, 1)
+	heap.Pop(ih)
+
+	begin, end := 0, 10
+	for i := begin; i < end; i++ {
+		heap.Push(ih, i)
+		ast.Equal(0, (*ih)[0], "插入 %d 后的最小值却是 %d，ih=%v", i, (*ih)[0], (*ih))
+	}
+
+	for i := begin; i < end; i++ {
+		fmt.Println(i, *ih)
+		ast.Equal(i, heap.Pop(ih), "Pop 后 ih=%v", (*ih))
+	}
+}

structures/Interval.go

@@ -0,0 +1,30 @@
+package structures
+
+// Interval 提供区间表示
+type Interval struct {
+	Start int
+	End   int
+}
+
+// Interval2Ints 把 Interval 转换成 整型切片
+func Interval2Ints(i Interval) []int {
+	return []int{i.Start, i.End}
+}
+
+// IntervalSlice2Intss 把 []Interval 转换成 [][]int
+func IntervalSlice2Intss(is []Interval) [][]int {
+	res := make([][]int, 0, len(is))
+	for i := range is {
+		res = append(res, Interval2Ints(is[i]))
+	}
+	return res
+}
+
+// Intss2IntervalSlice 把 [][]int 转换成 []Interval
+func Intss2IntervalSlice(intss [][]int) []Interval {
+	res := make([]Interval, 0, len(intss))
+	for _, ints := range intss {
+		res = append(res, Interval{Start: ints[0], End: ints[1]})
+	}
+	return res
+}

structures/Interval_test.go

@@ -0,0 +1,59 @@
+package structures
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_Interval2Ints(t *testing.T) {
+	ast := assert.New(t)
+
+	actual := Interval2Ints(Interval{Start: 1, End: 2})
+	expected := []int{1, 2}
+	ast.Equal(expected, actual)
+}
+
+func Test_IntervalSlice2Intss(t *testing.T) {
+	ast := assert.New(t)
+
+	actual := IntervalSlice2Intss(
+		[]Interval{
+			Interval{
+				Start: 1,
+				End:   2,
+			},
+			Interval{
+				Start: 3,
+				End:   4,
+			},
+		},
+	)
+	expected := [][]int{
+		[]int{1, 2},
+		[]int{3, 4},
+	}
+
+	ast.Equal(expected, actual)
+}
+func Test_Intss2IntervalSlice(t *testing.T) {
+	ast := assert.New(t)
+
+	expected := []Interval{
+		Interval{
+			Start: 1,
+			End:   2,
+		},
+		Interval{
+			Start: 3,
+			End:   4,
+		},
+	}
+	actual := Intss2IntervalSlice([][]int{
+		[]int{1, 2},
+		[]int{3, 4},
+	},
+	)
+
+	ast.Equal(expected, actual)
+}

structures/ListNode.go

@@ -0,0 +1,78 @@
+package structures
+
+import (
+	"fmt"
+)
+
+// ListNode 是链接节点
+// 这个不能复制到*_test.go文件中。会导致Travis失败
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+// List2Ints convert List to []int
+func List2Ints(head *ListNode) []int {
+	// 链条深度限制，链条深度超出此限制，会 panic
+	limit := 100
+
+	times := 0
+
+	res := []int{}
+	for head != nil {
+		times++
+		if times > limit {
+			msg := fmt.Sprintf("链条深度超过%d，可能出现环状链条。请检查错误，或者放宽 l2s 函数中 limit 的限制。", limit)
+			panic(msg)
+		}
+
+		res = append(res, head.Val)
+		head = head.Next
+	}
+
+	return res
+}
+
+// Ints2List convert []int to List
+func Ints2List(nums []int) *ListNode {
+	l := &ListNode{}
+	t := l
+	for _, v := range nums {
+		t.Next = &ListNode{Val: v}
+		t = t.Next
+	}
+	return l.Next
+}
+
+// GetNodeWith returns the first node with val
+func (l *ListNode) GetNodeWith(val int) *ListNode {
+	res := l
+	for res != nil {
+		if res.Val == val {
+			break
+		}
+		res = res.Next
+	}
+	return res
+}
+
+// Ints2ListWithCycle returns a list whose tail point to pos-indexed node
+// head's index is 0
+// if pos = -1, no cycle
+func Ints2ListWithCycle(nums []int, pos int) *ListNode {
+	head := Ints2List(nums)
+	if pos == -1 {
+		return head
+	}
+	c := head
+	for pos > 0 {
+		c = c.Next
+		pos--
+	}
+	tail := c
+	for tail.Next != nil {
+		tail = tail.Next
+	}
+	tail.Next = c
+	return head
+}

structures/ListNode_test.go

@@ -0,0 +1,68 @@
+package structures
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_l2s(t *testing.T) {
+	ast := assert.New(t)
+	ast.Equal([]int{}, List2Ints(nil), "输入nil，没有返回[]int{}")
+
+	one2three := &ListNode{
+		Val: 1,
+		Next: &ListNode{
+			Val: 2,
+			Next: &ListNode{
+				Val: 3,
+			},
+		},
+	}
+	ast.Equal([]int{1, 2, 3}, List2Ints(one2three), "没有成功地转换成[]int")
+
+	limit := 100
+	overLimitList := Ints2List(make([]int, limit+1))
+	ast.Panics(func() { List2Ints(overLimitList) }, "转换深度超过 %d 限制的链条，没有 panic", limit)
+}
+
+func Test_s2l(t *testing.T) {
+	ast := assert.New(t)
+	ast.Nil(Ints2List([]int{}), "输入[]int{}，没有返回nil")
+
+	ln := Ints2List([]int{1, 2, 3, 4, 5, 6, 7, 8, 9})
+	i := 1
+	for ln != nil {
+		ast.Equal(i, ln.Val, "对应的值不对")
+		ln = ln.Next
+		i++
+	}
+}
+
+func Test_getNodeWith(t *testing.T) {
+	ast := assert.New(t)
+	//
+	ln := Ints2List([]int{1, 2, 3, 4, 5, 6, 7, 8, 9})
+	val := 10
+	node := &ListNode{
+		Val: val,
+	}
+	tail := ln
+	for tail.Next != nil {
+		tail = tail.Next
+	}
+	tail.Next = node
+	expected := node
+	actual := ln.GetNodeWith(val)
+	ast.Equal(expected, actual)
+}
+
+func Test_Ints2ListWithCycle(t *testing.T) {
+	ast := assert.New(t)
+	ints := []int{1, 2, 3}
+	l := Ints2ListWithCycle(ints, -1)
+	ast.Equal(ints, List2Ints(l))
+
+	l = Ints2ListWithCycle(ints, 1)
+	ast.Panics(func() { List2Ints(l) })
+}

structures/NestedInteger.go

@@ -0,0 +1,37 @@
+package structures
+
+// NestedInteger  is the interface that allows for creating nested lists.
+// You should not implement it, or speculate about its implementation
+type NestedInteger struct {
+	Num int
+	Ns  []*NestedInteger
+}
+
+// IsInteger Return true if this NestedInteger holds a single integer, rather than a nested list.
+func (n NestedInteger) IsInteger() bool {
+	return n.Ns == nil
+}
+
+// GetInteger Return the single integer that this NestedInteger holds, if it holds a single integer
+// The result is undefined if this NestedInteger holds a nested list
+// So before calling this method, you should have a check
+func (n NestedInteger) GetInteger() int {
+	return n.Num
+}
+
+// SetInteger Set this NestedInteger to hold a single integer.
+func (n *NestedInteger) SetInteger(value int) {
+	n.Num = value
+}
+
+// Add  Set this NestedInteger to hold a nested list and adds a nested integer to it.
+func (n *NestedInteger) Add(elem NestedInteger) {
+	n.Ns = append(n.Ns, &elem)
+}
+
+// GetList Return the nested list that this NestedInteger holds, if it holds a nested list
+// The list length is zero if this NestedInteger holds a single integer
+// You can access NestedInteger's List element directly if you want to modify it
+func (n NestedInteger) GetList() []*NestedInteger {
+	return n.Ns
+}

structures/NestedInterger_test.go

@@ -0,0 +1,30 @@
+package structures
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_NestedInteger(t *testing.T) {
+	ast := assert.New(t)
+
+	n := NestedInteger{}
+
+	ast.True(n.IsInteger())
+
+	n.SetInteger(1)
+	ast.Equal(1, n.GetInteger())
+
+	elem := NestedInteger{Num: 1}
+
+	expected := NestedInteger{
+		Num: 1,
+		Ns:  []*NestedInteger{&elem},
+	}
+	n.Add(elem)
+
+	ast.Equal(expected, n)
+
+	ast.Equal(expected.Ns, n.GetList())
+}

structures/Point.go

@@ -0,0 +1,27 @@
+package structures
+
+// Point 定义了一个二维坐标点
+type Point struct {
+	X, Y int
+}
+
+// Intss2Points 把 [][]int 转换成 []Point
+func Intss2Points(points [][]int) []Point {
+	res := make([]Point, len(points))
+	for i, p := range points {
+		res[i] = Point{
+			X: p[0],
+			Y: p[1],
+		}
+	}
+	return res
+}
+
+// Points2Intss 把 []Point 转换成　[][]int
+func Points2Intss(points []Point) [][]int {
+	res := make([][]int, len(points))
+	for i, p := range points {
+		res[i] = []int{p.X, p.Y}
+	}
+	return res
+}