完成 ArrayN del 操作

sparse_array/array3/array3.go

@@ -0,0 +1,142 @@
+package array3
+
+type Array3 struct {
+	ysizes    []int
+	xsizes    [][]int
+	xyproduct int
+	zsize     int
+	ysize     int
+	xsize     int
+	data      [][][]interface{}
+}
+
+func New() *Array3 {
+	return NewWithCap(8, 8, 8)
+}
+
+func NewWithCap(zsize, ysize, xsize int) *Array3 {
+	arr := &Array3{zsize: zsize, ysize: ysize, xsize: xsize}
+
+	arr.ysizes = make([]int, arr.zsize, arr.zsize)
+
+	arr.xsizes = make([][]int, arr.zsize, arr.zsize)
+	for i := 0; i < arr.zsize; i++ {
+		arr.xsizes[i] = make([]int, arr.ysize, arr.ysize)
+	}
+
+	arr.xyproduct = arr.ysize * arr.xsize
+	arr.data = make([][][]interface{}, arr.zsize, arr.zsize)
+	return arr
+}
+
+func (arr *Array3) Values() []interface{} {
+	var result []interface{}
+	for _, z := range arr.data {
+		if z != nil {
+
+			for _, y := range z {
+				if y == nil {
+					for i := 0; i < arr.xsize; i++ {
+						result = append(result, nil)
+					}
+				} else {
+					for _, x := range y {
+						if x == nil {
+							result = append(result, struct{}{})
+						} else {
+							result = append(result, x)
+						}
+					}
+				}
+			}
+		} else {
+			for i := 0; i < arr.ysize*arr.xsize; i++ {
+				result = append(result, nil)
+			}
+		}
+	}
+
+	return result
+}
+
+func (arr *Array3) Set(idx int, value interface{}) {
+	zindex := idx / arr.xyproduct
+	nidx := (idx % arr.xyproduct)
+	yindex := nidx / arr.xsize
+	xindex := nidx % arr.xsize
+
+	ydata := arr.data[zindex]
+	if ydata == nil {
+		ydata = make([][]interface{}, arr.ysize, arr.ysize)
+		arr.data[zindex] = ydata
+	}
+
+	xdata := ydata[yindex]
+	if xdata == nil {
+		xdata = make([]interface{}, arr.xsize, arr.xsize)
+		ydata[yindex] = xdata
+		arr.ysizes[zindex]++
+	}
+
+	v := xdata[xindex]
+	if v == nil {
+		arr.xsizes[zindex][yindex]++
+	}
+	xdata[xindex] = value
+}
+
+func (arr *Array3) Get(idx int) (interface{}, bool) {
+	zindex := idx / arr.xyproduct
+	nextsize := (idx % arr.xyproduct)
+	yindex := nextsize / arr.xsize
+	xindex := nextsize % arr.xsize
+
+	ydata := arr.data[zindex]
+	if ydata == nil {
+		return nil, false
+	}
+
+	xdata := ydata[yindex]
+	if xdata == nil {
+		return nil, false
+	}
+
+	v := xdata[xindex]
+	return v, v != nil
+}
+
+func (arr *Array3) Del(idx int) (interface{}, bool) {
+	zindex := idx / arr.xyproduct
+	nextsize := (idx % arr.xyproduct)
+	yindex := nextsize / arr.xsize
+	xindex := nextsize % arr.xsize
+
+	ydata := arr.data[zindex]
+	if ydata == nil {
+		return nil, false
+	}
+
+	xdata := ydata[yindex]
+	if xdata == nil {
+		return nil, false
+	}
+
+	v := xdata[xindex]
+	xdata[xindex] = nil
+
+	isnotnil := v != nil
+
+	if isnotnil {
+		arr.xsizes[zindex][yindex]--
+		if arr.xsizes[zindex][yindex] == 0 {
+			arr.data[zindex][yindex] = nil
+
+			arr.ysizes[zindex]--
+			if arr.ysizes[zindex] == 0 {
+				arr.data[zindex] = nil
+			}
+		}
+	}
+
+	return v, isnotnil
+}

sparse_array/array3/array3_test.go

@@ -0,0 +1,214 @@
+package array3
+
+import (
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+
+	"github.com/Pallinder/go-randomdata"
+)
+
+func testSet1(t *testing.T) {
+	arr := NewWithCap(2, 2, 2)
+	l := []int{0, 1, 7}
+	for _, v := range l {
+		arr.Set(v, v)
+	}
+
+	var result string
+	result = spew.Sprint(arr.Values())
+	if result != "[0 1 <nil> <nil> <nil> <nil> {} 7]" {
+		t.Error(result)
+	}
+
+	defer func() {
+		if err := recover(); err == nil {
+			t.Error("err == nil, but array the set is out of range")
+		}
+	}()
+
+	arr.Set(8, 8)
+}
+
+func testSet2(t *testing.T) {
+	arr := NewWithCap(2, 2, 3)
+	l := []int{0, 6, 5, 11}
+	for _, v := range l {
+		arr.Set(v, v)
+	}
+
+	var result string
+	result = spew.Sprint(arr.Values())
+	if result != "[0 {} {} {} {} 5 6 {} {} {} {} 11]" {
+		t.Error(arr.data)
+		t.Error(result)
+	}
+
+	defer func() {
+		if err := recover(); err == nil {
+			t.Error("err == nil, but array the set is out of range")
+		}
+	}()
+
+	arr.Set(12, 12)
+}
+
+func TestArray2Set(t *testing.T) {
+	testSet1(t)
+	testSet2(t)
+}
+
+func testArray2Get1(t *testing.T) {
+	arr := New()
+	for i := 0; i < 64; i++ {
+		arr.Set(i, i)
+	}
+
+	for i := 0; i < 64; i++ {
+		if v, ok := arr.Get(i); ok {
+			if v != i {
+				t.Error("v is equal i, but", v, i)
+			}
+		} else {
+			t.Error("not ok is error")
+		}
+	}
+
+	defer func() {
+		if err := recover(); err == nil {
+			t.Error("err == nil, but array the get is out of range")
+		}
+	}()
+
+	arr.Get(64)
+}
+
+func testArray2Get2(t *testing.T) {
+	arr := NewWithCap(4, 3, 3)
+	for i := 0; i < 64; i++ {
+		arr.Set(i, i)
+	}
+
+	for i := 0; i < 64; i++ {
+		if v, ok := arr.Get(i); ok {
+			if v != i {
+				t.Error("v is equal i, but", v, i)
+			}
+		} else {
+			t.Error("not ok is error")
+		}
+	}
+
+	defer func() {
+		if err := recover(); err == nil {
+			t.Error("err == nil, but array the get is out of range")
+		}
+	}()
+
+	arr.Get(72)
+}
+
+func TestArray2Get(t *testing.T) {
+	testArray2Get1(t)
+	testArray2Get2(t)
+}
+
+func TestArray2Del(t *testing.T) {
+	arr := NewWithCap(2, 2, 3)
+	l := []int{0, 6, 5, 11}
+	for _, v := range l {
+		arr.Set(v, v)
+	}
+	// default  [0 {} {} {} {} 5 6 {} <nil> <nil> <nil> <nil> {} {} {} 15]
+	var result string
+
+	arr.Del(0)
+	result = spew.Sprint(arr.Values())
+	if result != "[<nil> <nil> <nil> {} {} 5 6 {} {} {} {} 11]" {
+		t.Error(arr.data)
+		t.Error(result)
+	}
+
+	arr.Del(5)
+	result = spew.Sprint(arr.Values())
+	if result != "[<nil> <nil> <nil> <nil> <nil> <nil> 6 {} {} {} {} 11]" {
+		t.Error(arr.data)
+		t.Error(result)
+	}
+
+	arr.Del(6)
+	result = spew.Sprint(arr.Values())
+	if result != "[<nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> {} {} 11]" {
+		t.Error(result)
+	}
+
+	arr.Del(11)
+	result = spew.Sprint(arr.Values())
+	if result != "[<nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil>]" {
+		t.Error(result)
+	}
+
+	defer func() {
+		if err := recover(); err == nil {
+			t.Error("err == nil, but array the del is out of range")
+		}
+	}()
+
+	arr.Del(18)
+}
+
+func BenchmarkArray2Set(b *testing.B) {
+
+	arr := NewWithCap(100, 100, 10)
+	b.N = 500000000
+
+	b.StopTimer()
+	var l []int
+	for i := 0; i < b.N/10; i++ {
+		l = append(l, randomdata.Number(0, 65535))
+	}
+	b.StartTimer()
+	for c := 0; c < 10; c++ {
+		for i := 0; i < b.N/10; i++ {
+			arr.Set(l[i], i)
+		}
+	}
+
+}
+
+func BenchmarkArray2Get(b *testing.B) {
+
+	arr := NewWithCap(100, 100, 10)
+	b.N = 500000000
+
+	b.StopTimer()
+
+	for i := 0; i < 105535; i++ {
+		v := randomdata.Number(0, 65535)
+		arr.Set(v, v)
+	}
+	b.StartTimer()
+
+	for i := 0; i < b.N; i++ {
+		arr.Get(i % 65535)
+	}
+
+}
+
+func BenchmarkArray2Del(b *testing.B) {
+
+	arr := NewWithCap(100, 100, 10)
+	b.N = 500000000
+
+	b.StopTimer()
+	for i := 0; i < 105535; i++ {
+		v := randomdata.Number(0, 65535)
+		arr.Set(v, v)
+	}
+	b.StartTimer()
+
+	for i := 0; i < b.N; i++ {
+		arr.Del(i % 65535)
+	}
+
+}