go语言之专业数据结构与算法

3.golang实现数组结构

code\ArrayList\ArrayList.go

package ArrayList

import (
	"errors"
	"fmt"
)

// 接口
type List interface {
	Size() int                                  // 数组大小
	Get(index int) (interface{}, error)         // 抓取第几个元素
	Set(index int, newval interface{}) error    // 修改数据
	Insert(index int, newval interface{}) error // 插入数据
	Append(newval interface{})                  // 追加
	Clear()                                     // 清空
	Delete(index int) error                     // 删除
	String() string                             // 返回字符串
}

// 数据结构，字符串，整数，实数
type ArrayList struct {
	dataStore []interface{} // 数组存储
	TheSize   int           // 数组的大小
}

func NewArrayList() *ArrayList {
	list := new(ArrayList)                      // 初始化结构体
	list.dataStore = make([]interface{}, 0, 10) // 开辟空间10个
	list.TheSize = 0
	return list
}

func (list *ArrayList) Size() int {
	return list.TheSize // 返回数据大小
}

func (list *ArrayList) Append(newval interface{}) {
	list.dataStore = append(list.dataStore, newval) // 叠加数据
	list.TheSize++
}

func (list *ArrayList) Get(index int) (interface{}, error) { // 抓取第几个元素
	if index < 0 || index > list.TheSize {
		return nil, errors.New("索引越界")
	}
	return list.dataStore[index], nil
}

func (list *ArrayList) String() string {
	return fmt.Sprint(list.dataStore)
}

调用ArrayList.go

code\main.go

package main

import (
	"fmt"

	"./ArrayList"
)

func main() {
	list := ArrayList.NewArrayList()
	list.Append(1)
	list.Append(2)
	list.Append(3)
	fmt.Println(list)
}

package main

import (
	"fmt"

	"./ArrayList"
)

func main1() {
	list := ArrayList.NewArrayList()
	list.Append(1)
	list.Append(2)
	list.Append(3)
	fmt.Println(list)
}

func main2() {
	list := ArrayList.NewArrayList()
	list.Append("a1")
	list.Append("b2")
	list.Append("c3")
	fmt.Println(list.TheSize) //TheSize大写包外可见
}

func main() {
	var list ArrayList.List = ArrayList.NewArrayList()
	list.Append("a1")
	list.Append("b2")
	list.Append("c3")
	fmt.Println(list.Size) //Size大写包外可见
}

var list ArrayList.List = ArrayList.NewArrayList() 无法编译，由于接口中的方法没有都实现。

package ArrayList

import (
	"errors"
	"fmt"
)

// 接口
type List interface {
	Size() int                                  // 数组大小
	Get(index int) (interface{}, error)         // 抓取第几个元素
	Set(index int, newval interface{}) error    // 修改数据
	Insert(index int, newval interface{}) error // 插入数据
	Append(newval interface{})                  // 追加
	Clear()                                     // 清空
	Delete(index int) error                     // 删除
	String() string                             // 返回字符串
}

// 数据结构，字符串，整数，实数
type ArrayList struct {
	dataStore []interface{} // 数组存储
	TheSize   int           // 数组的大小
}

func NewArrayList() *ArrayList {
	list := new(ArrayList)                      // 初始化结构体
	list.dataStore = make([]interface{}, 0, 10) // 开辟空间10个
	list.TheSize = 0
	return list
}

// 数组大小
func (list *ArrayList) Size() int {
	return list.TheSize // 返回数据大小
}

// 追加
func (list *ArrayList) Append(newval interface{}) {
	list.dataStore = append(list.dataStore, newval) // 叠加数据
	list.TheSize++
}

// 抓取第几个元素
func (list *ArrayList) Get(index int) (interface{}, error) {
	if index < 0 || index > list.TheSize {
		return nil, errors.New("索引越界")
	}
	return list.dataStore[index], nil
}

// 返回字符串
func (list *ArrayList) String() string {
	return fmt.Sprint(list.dataStore)
}

// 修改数据
func (list *ArrayList) Set(index int, newval interface{}) error {
	return nil
}

// 插入数据
func (list *ArrayList) Insert(index int, newval interface{}) error {
	return nil
}

// 清空
func (list *ArrayList) Clear() {

}

// 删除
func (list *ArrayList) Delete(index int) error {
	return nil
}

现在编译没有问题

func main() {
	// 定义接口对象，赋值的对象必须实现接口的所有方法
	var list ArrayList.List = ArrayList.NewArrayList()
	list.Append("a1")
	list.Append("b2")
	list.Append("c3")
	fmt.Println(list.Size) //TheSize大写包外可见
}

package ArrayList

import (
	"errors"
	"fmt"
)

// 接口
type List interface {
	Size() int                                  // 数组大小
	Get(index int) (interface{}, error)         // 抓取第几个元素
	Set(index int, newval interface{}) error    // 修改数据
	Insert(index int, newval interface{}) error // 插入数据
	Append(newval interface{})                  // 追加
	Clear()                                     // 清空
	Delete(index int) error                     // 删除
	String() string                             // 返回字符串
}

// 数据结构，字符串，整数，实数
type ArrayList struct {
	dataStore []interface{} // 数组存储
	TheSize   int           // 数组的大小
}

func NewArrayList() *ArrayList {
	list := new(ArrayList)                      // 初始化结构体
	list.dataStore = make([]interface{}, 0, 10) // 开辟空间10个
	list.TheSize = 0
	return list
}

func (list *ArrayList) checkisFull() {
	if list.TheSize == cap(list.dataStore) { // 判断内存使用
		newdataStore := make([]interface{}, 0, 2*list.TheSize) // 开辟双倍内存
		copy(newdataStore, list.dataStore)                     // 拷贝
		list.dataStore = newdataStore                          // 赋值
	}
}

// 数组大小
func (list *ArrayList) Size() int {
	return list.TheSize // 返回数据大小
}

// 追加
func (list *ArrayList) Append(newval interface{}) {
	list.dataStore = append(list.dataStore, newval) // 叠加数据
	list.TheSize++
}

// 抓取第几个元素
func (list *ArrayList) Get(index int) (interface{}, error) {
	if index < 0 || index > list.TheSize {
		return nil, errors.New("索引越界")
	}
	return list.dataStore[index], nil
}

// 返回字符串
func (list *ArrayList) String() string {
	return fmt.Sprint(list.dataStore)
}

// 修改数据
func (list *ArrayList) Set(index int, newval interface{}) error {
	if index < 0 || index > list.TheSize {
		return errors.New("索引越界")
	}
	list.dataStore[index] = newval // 数据设置
	return nil
}

// 插入数据
func (list *ArrayList) Insert(index int, newval interface{}) error {
	if index < 0 || index > list.TheSize {
		return errors.New("索引越界")
	}
	list.checkisFull()                               // 检查内存，如果满了，自动追加
	list.dataStore = list.dataStore[:list.TheSize+1] // 插入数据，内存移动一位
	for i := list.TheSize; i > index; i-- {          // 从后往前移动
		list.dataStore[i] = list.dataStore[i-1]
	}
	list.dataStore[index] = newval // 插入数据
	list.TheSize++                 // 索引追加
	return nil
}

// 清空
func (list *ArrayList) Clear() {
	// 把原先的内存废弃，重写开辟内存
	list.dataStore = make([]interface{}, 0, 10) // 开辟空间10个
	list.TheSize = 0
}

// 删除
func (list *ArrayList) Delete(index int) error {
	// 重写叠加，跳过index
	list.dataStore = append(list.dataStore[:index], list.dataStore[index+1:]...)
	list.TheSize--
	return nil
}

测试

func main() {
	// 定义接口对象，赋值的对象必须实现接口的所有方法
	var list ArrayList.List = ArrayList.NewArrayList()
	list.Append("a1")
	list.Append("b2")
	list.Append("c3")
	for i := 0; i < 10; i++ {
		list.Insert(1, "x5")
		fmt.Println(list) 
	}
	
	fmt.Println(list) 
}

内存失效

func main() {
	// 定义接口对象，赋值的对象必须实现接口的所有方法
	var list ArrayList.List = ArrayList.NewArrayList()
	list.Append("a1")
	list.Append("b2")
	list.Append("c3")
	for i := 0; i < 4; i++ {
		list.Insert(1, "x5")
		fmt.Println(list)
	}
	fmt.Println("delete")
	list.Delete(5)
	fmt.Println(list)
}

func main() {
	// 定义接口对象，赋值的对象必须实现接口的所有方法
	var list ArrayList.List = ArrayList.NewArrayList()
	list.Append("a1")
	list.Append("b2")
	list.Append("c3")
	for i := 0; i < 15; i++ {
		list.Insert(1, "x5")
		fmt.Println(list)
	}

	// fmt.Println(list)
}

优化接口的插入方法，checkisFull方法

func (list *ArrayList) checkisFull() {
	if list.TheSize == cap(list.dataStore) { // 判断内存使用
		fmt.Println("A", list.dataStore)

		newdataStore := make([]interface{}, 0, 2*list.TheSize) // 开辟双倍内存
		copy(newdataStore, list.dataStore)                     // 拷贝
		list.dataStore = newdataStore                          // 赋值
		fmt.Println("A", list.dataStore)
		fmt.Println("A", newdataStore)

	}
}

func (list *ArrayList) checkisFull() {
	if list.TheSize == cap(list.dataStore) { // 判断内存使用
		fmt.Println("A", list.dataStore)

		newdataStore := make([]interface{}, 0, 2*list.TheSize) // 开辟双倍内存
		// copy(newdataStore, list.dataStore)                     // 拷贝
		// 使用for循环赋值
		for i := 0; i < len(list.dataStore); i++ {
			newdataStore[i] = list.dataStore[i]
		}
		list.dataStore = newdataStore // 赋值
		fmt.Println("A", list.dataStore)
		fmt.Println("A", newdataStore)

	}
}

newdataStore := make([]interface{}, 0, 2*list.TheSize)

0导致并没有开辟内存，

newdataStore := make([]interface{}, 2*list.TheSize, 2*list.TheSize)

func (list *ArrayList) checkisFull() {
	if list.TheSize == cap(list.dataStore) { // 判断内存使用
		fmt.Println("A", list.dataStore)
        // make 中间的参数，0，没有开辟内存
		newdataStore := make([]interface{}, 2*list.TheSize, 2*list.TheSize) // 开辟双倍内存
		copy(newdataStore, list.dataStore)                     // 拷贝
		// 使用for循环赋值
		// for i := 0; i < len(list.dataStore); i++ {
		//	 newdataStore[i] = list.dataStore[i]
		// }
		list.dataStore = newdataStore // 赋值
		fmt.Println("A", list.dataStore)
		fmt.Println("A", newdataStore)

	}
}

4.golang实现数组迭代器

code\ArrayList\ArrayListIterator.go

package ArrayList

import "errors"

type Iterator interface {
	HasNext() bool              // 是否有下一个
	Next() (interface{}, error) // 下一个
	Remove()                    // 删除
	GetIndex() int              // 得到索引
}

type Iterable interface {
	Iterator() Iterator // 构造初始化接口
}

// 构造指针访问数组
type ArraylistIterator struct {
	list         *ArrayList // 数组指针
	currentindex int        // 当前索引
}

func (list *ArrayList) Iterator() Iterator {
	it := new(ArraylistIterator)
	it.currentindex = 0
	it.list = list
	return it
}

func (it *ArraylistIterator) HasNext() bool {
	return it.currentindex < it.list.TheSize // 是否有下一个
}

func (it *ArraylistIterator) Next() (interface{}, error) {
	if !it.HasNext() {
		return nil, errors.New("没有下一个")
	}
	value, err := it.list.Get(it.currentindex) // 抓取当前数据
	it.currentindex++
	return value, err
}

func (it *ArraylistIterator) Remove() {
	it.currentindex--
	it.list.Delete(it.currentindex) // 删除一个元素
}

func (it *ArraylistIterator) GetIndex() int {
	return it.currentindex
}

D:\Workspace\Go\src\projects\code\ArrayList\ArrayList.go

package ArrayList

import (
	"errors"
	"fmt"
)

// 接口
type List interface {
	Size() int                                  // 数组大小
	Get(index int) (interface{}, error)         // 抓取第几个元素
	Set(index int, newval interface{}) error    // 修改数据
	Insert(index int, newval interface{}) error // 插入数据
	Append(newval interface{})                  // 追加
	Clear()                                     // 清空
	Delete(index int) error                     // 删除
	String() string                             // 返回字符串
	Iterator() Iterator
}

// 数据结构，字符串，整数，实数
type ArrayList struct {
	dataStore []interface{} // 数组存储
	TheSize   int           // 数组的大小
}

func NewArrayList() *ArrayList {
	list := new(ArrayList)                      // 初始化结构体
	list.dataStore = make([]interface{}, 0, 10) // 开辟空间10个
	list.TheSize = 0
	return list
}

func (list *ArrayList) checkisFull() {
	if list.TheSize == cap(list.dataStore) { // 判断内存使用
		fmt.Println("A", list.dataStore)
		// make 中间的参数，0，没有开辟内存
		newdataStore := make([]interface{}, 2*list.TheSize, 2*list.TheSize) // 开辟双倍内存
		copy(newdataStore, list.dataStore)                                  // 拷贝
		// 使用for循环赋值
		// for i := 0; i < len(list.dataStore); i++ {
		// 	newdataStore[i] = list.dataStore[i]
		// }
		list.dataStore = newdataStore // 赋值
		fmt.Println("A", list.dataStore)
		fmt.Println("A", newdataStore)

	}
}

// 数组大小
func (list *ArrayList) Size() int {
	return list.TheSize // 返回数据大小
}

// 追加
func (list *ArrayList) Append(newval interface{}) {
	list.dataStore = append(list.dataStore, newval) // 叠加数据
	list.TheSize++
}

// 抓取第几个元素
func (list *ArrayList) Get(index int) (interface{}, error) {
	if index < 0 || index > list.TheSize {
		return nil, errors.New("索引越界")
	}
	return list.dataStore[index], nil
}

// 返回字符串
func (list *ArrayList) String() string {
	return fmt.Sprint(list.dataStore)
}

// 修改数据
func (list *ArrayList) Set(index int, newval interface{}) error {
	if index < 0 || index > list.TheSize {
		return errors.New("索引越界")
	}
	list.dataStore[index] = newval // 数据设置
	return nil
}

// 插入数据
func (list *ArrayList) Insert(index int, newval interface{}) error {
	if index < 0 || index > list.TheSize {
		return errors.New("索引越界")
	}
	list.checkisFull()                               // 检查内存，如果满了，自动追加
	list.dataStore = list.dataStore[:list.TheSize+1] // 插入数据，内存移动一位
	for i := list.TheSize; i > index; i-- {          // 从后往前移动
		list.dataStore[i] = list.dataStore[i-1]
	}
	list.dataStore[index] = newval // 插入数据
	list.TheSize++                 // 索引追加
	return nil
}

// 清空
func (list *ArrayList) Clear() {
	// 把原先的内存废弃，重写开辟内存
	list.dataStore = make([]interface{}, 0, 10) // 开辟空间10个
	list.TheSize = 0
}

// 删除
func (list *ArrayList) Delete(index int) error {
	// 重写叠加，跳过index
	list.dataStore = append(list.dataStore[:index], list.dataStore[index+1:]...)
	list.TheSize--
	return nil
}