001_顺序表的实现

最新推荐文章于 2021-08-28 11:51:09 发布

Hi℃瑞

最新推荐文章于 2021-08-28 11:51:09 发布

阅读量176

点赞数

分类专栏： GO语言算法

本文链接：https://blog.csdn.net/qq_22056419/article/details/88784511

版权

GO语言算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

实现顺序表(别看下面的代码这么长，大部分我写操作增删改查去了)

实现顺序表的，增，删，改，查

//	作者：itruirui@outlook.com
package main
import (
	"fmt"
	"os"
	"time"
	"errors"
	"os/exec"
)

func main(){
		var list List	//定义一个接口类型的数据
		list = NewArrayList(10)
		play(list)	//操作数据的增删改查
}

type List interface{
	//实现基本功能，增，删，改，查
	
	//增
	Append(v interface{})(error)	//在末尾添加一个数据
	Insert(index int, v interface{})(error)	//在指定位置插入数据
	
	//删
	Clear()	//清空整个顺序表
	Delete(index int)(error)	//删除指定索引数据
	
	//改
	Set(index int, v interface{})(error)	//设置指定索引的数据
	
	//查
	CurSize()(int,int)	//获取当前已经用空间大小
	Get(index int)(interface{}, error)	//获取指定索引的数据
	GetAll()([]interface{})	//获取所有的数据
}

type ArrayList struct{
	Data []interface{}
	TheSize int
}

//增：创建一个顺序表
func NewArrayList(size int)(*ArrayList){
	list := new(ArrayList)
	list.Data = make([]interface{}, 0, size)
	list.TheSize = 0
	return list
}

//增：在末尾添加一个数据
func (list *ArrayList)Append(v interface{})(error){
	if list.TheSize >= cap(list.Data){	//因为append会自动扩容list.Data的容量，所以，为了避免自动扩容，写了这么一个限制
		return errors.New("顺序表已经写满了")
	}
	if len(list.Data) == cap(list.Data){
		list.Data[list.TheSize] = v
	}else{
		list.Data = append(list.Data, v)
	}
	list.TheSize++
	return nil
}

//增：在指定索引位置，插入数据
func (list *ArrayList)Insert(index int, v interface{})(error){
	if index < 0 || index >= list.TheSize && index != 0{
		return errors.New("索引越界")
	}
	list.Data = list.Data[:list.TheSize + 1]
	for i := list.TheSize; i > index; i--{
		list.Data[i] = list.Data[i-1]
	}
	list.Data[index] = v
	list.TheSize++
	return nil
}

//删：清空顺序表
func (list *ArrayList)Clear(){
	list.TheSize = 0
}

//删：删除一个指定索引的数据
func (list *ArrayList)Delete(index int)(error){
	if index < 0 || index >= list.TheSize{
		return errors.New("索引越界")
	}
	for i := index; i < list.TheSize - 1; i++{
		list.Data[i] = list.Data[i+1]
	}
	if list.TheSize <= 1{
		list.TheSize = 0
	}else{
		list.TheSize--
	}
	return nil
}

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

//查：获取当前顺序表的len和cap
func (list *ArrayList)CurSize()(int,int){
	return list.TheSize, cap(list.Data)
}

//查：获取指定索引的数据
func (list *ArrayList)Get(index int)(interface{}, error){
	if index < 0 || index >= list.TheSize{
		return nil, errors.New("索引越界")
	}
	return list.Data[index], nil
}

//查：获取所有的数据
func (list *ArrayList)GetAll()([]interface{}){
	var sum []interface{}
	for i := 0; i < list.TheSize; i++{
		sum = append(sum, list.Data[i])
	}
	return sum
}

//操作数据的增删改查
func play(list List){
		var command = 0
		var index int
		var data string
		for{
			fmt.Println("1、末尾新增一个数据")
			fmt.Println("2、指定位置插入一个数据")
			fmt.Println("3、删除指定位置数据")
			fmt.Println("4、清空这个顺序表")
			fmt.Println("5、设置指定位置的数据")
			fmt.Println("6、查看已用空间")
			fmt.Println("7、获取指定位置数据")
			fmt.Scan(&command)
			fmt.Println("你输入的指令是：", command)
			switch command{
				case 1:
					fmt.Print("请输入数据(value)：")
					fmt.Scan(&data)
					fmt.Println(data)
					err := list.Append(data)
					if err != nil{
						fmt.Println("新增数据失败：", err)
						time.Sleep(time.Second * 5)
					}
				case 2:
					fmt.Print("请输入指定位置和数据(index value)：")
					fmt.Scan(&index, &data)
					fmt.Println(index," = ", data)
					err := list.Insert(index, data)
					if err != nil{
						fmt.Println("插入数据失败：", err)
						time.Sleep(time.Second * 5)
					}
				case 3:
					fmt.Print("请输入指定位置(index)：")
					fmt.Scan(&index)
					err := list.Delete(index)
					if err != nil{
						fmt.Println("删除数据失败：", err)
						time.Sleep(time.Second * 5)
					}
				case 4:
					list.Clear()
				case 5:
					fmt.Print("请输入要修改的指定位置和数据(index value)：")
					fmt.Scan(&index, &data)
					fmt.Println(index," = ", data)
					err := list.Set(index, data)
					if err != nil{
						fmt.Println("修改数据失败：", err)
						time.Sleep(time.Second * 5)
					}
				case 6:
					l,c := list.CurSize()
					fmt.Println("当前已经使用：", l, "，总容量：", c)
					time.Sleep(time.Second * 3)
				case 7:
					fmt.Print("请输入指定位置(index)：")
					fmt.Scan(&index)
					s, err := list.Get(index)
					if err != nil{
						fmt.Println("查找数据失败：", err)
					}else{
						fmt.Println("下标为[", index, "]的数据是：", s)
					}
					time.Sleep(time.Second * 3)
				default:
					fmt.Println("请重新输入操作！")
					time.Sleep(time.Second * 5)
			}
			cmd := exec.Command("cmd.exe", "/c", "cls")
			cmd.Stdout = os.Stdout
			cmd.Run()
			fmt.Println("打印所有数据：")
			fmt.Println("==============================================================================")
			fmt.Println(list.GetAll())
			fmt.Println("==============================================================================")
		}
}

1、首先，我们需要定义一个接口

先抽象化一下基本功能

type List interface{
	//实现基本功能，增，删，改，查
	
	//增
	Append(v interface{})(error)	//在末尾添加一个数据
	Insert(index int, v interface{})(error)	//在指定位置插入数据
	
	//删
	Clear()	//清空整个顺序表
	Delete(index int)(error)	//删除指定索引数据
	
	//改
	Set(index int, v interface{})(error)	//设置指定索引的数据
	
	//查
	CurSize()(int,int)	//获取当前已经用空间大小
	Get(index int)(interface{}, error)	//获取指定索引的数据
	GetAll()([]interface{})	//获取所有的数据
}

2、然后创建一个数据结构体

type ArrayList struct{
	Data []interface{}
	TheSize int
}

3、实现，增

//增：创建一个顺序表
func NewArrayList(size int)(*ArrayList){
	list := new(ArrayList)
	list.Data = make([]interface{}, 0, size)
	list.TheSize = 0
	return list
}

//增：在末尾添加一个数据
func (list *ArrayList)Append(v interface{})(error){
	if list.TheSize >= cap(list.Data){	//因为append会自动扩容list.Data的容量，所以，为了避免自动扩容，写了这么一个限制
		return errors.New("顺序表已经写满了")
	}
	if len(list.Data) == cap(list.Data){
		list.Data[list.TheSize] = v
	}else{
		list.Data = append(list.Data, v)
	}
	list.TheSize++
	return nil
}

//增：在指定索引位置，插入数据
func (list *ArrayList)Insert(index int, v interface{})(error){
	if index < 0 || index >= list.TheSize && index != 0{
		return errors.New("索引越界")
	}
	list.Data = list.Data[:list.TheSize + 1]
	for i := list.TheSize; i > index; i--{
		list.Data[i] = list.Data[i-1]
	}
	list.Data[index] = v
	list.TheSize++
	return nil
}

4、实现，删

//删：清空顺序表
func (list *ArrayList)Clear(){
	list.TheSize = 0
}

//删：删除一个指定索引的数据
func (list *ArrayList)Delete(index int)(error){
	if index < 0 || index >= list.TheSize{
		return errors.New("索引越界")
	}
	for i := index; i < list.TheSize - 1; i++{
		list.Data[i] = list.Data[i+1]
	}
	if list.TheSize <= 1{
		list.TheSize = 0
	}else{
		list.TheSize--
	}
	return nil
}

5、实现、改

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

6、实现、查

//查：获取指定索引的数据
func (list *ArrayList)Get(index int)(interface{}, error){
	if index < 0 || index >= list.TheSize{
		return nil, errors.New("索引越界")
	}
	return list.Data[index], nil
}

//查：获取所有的数据
func (list *ArrayList)GetAll()([]interface{}){
	var sum []interface{}
	for i := 0; i < list.TheSize; i++{
		sum = append(sum, list.Data[i])
	}
	return sum
}

那么，基本上，就完成了。
剩下的，就是测试一下我们的顺序表
给它来一个操作控制

7、实现增删改成操作

//查：获取指定索引的数据
//操作数据的增删改查
func play(list List){
		var command = 0
		var index int
		var data string
		for{
			fmt.Println("1、末尾新增一个数据")
			fmt.Println("2、指定位置插入一个数据")
			fmt.Println("3、删除指定位置数据")
			fmt.Println("4、清空这个顺序表")
			fmt.Println("5、设置指定位置的数据")
			fmt.Println("6、查看已用空间")
			fmt.Println("7、获取指定位置数据")
			fmt.Scan(&command)
			fmt.Println("你输入的指令是：", command)
			switch command{
				case 1:
					fmt.Print("请输入数据(value)：")
					fmt.Scan(&data)
					fmt.Println(data)
					err := list.Append(data)
					if err != nil{
						fmt.Println("新增数据失败：", err)
						time.Sleep(time.Second * 5)
					}
				case 2:
					fmt.Print("请输入指定位置和数据(index value)：")
					fmt.Scan(&index, &data)
					fmt.Println(index," = ", data)
					err := list.Insert(index, data)
					if err != nil{
						fmt.Println("插入数据失败：", err)
						time.Sleep(time.Second * 5)
					}
				case 3:
					fmt.Print("请输入指定位置(index)：")
					fmt.Scan(&index)
					err := list.Delete(index)
					if err != nil{
						fmt.Println("删除数据失败：", err)
						time.Sleep(time.Second * 5)
					}
				case 4:
					list.Clear()
				case 5:
					fmt.Print("请输入要修改的指定位置和数据(index value)：")
					fmt.Scan(&index, &data)
					fmt.Println(index," = ", data)
					err := list.Set(index, data)
					if err != nil{
						fmt.Println("修改数据失败：", err)
						time.Sleep(time.Second * 5)
					}
				case 6:
					l,c := list.CurSize()
					fmt.Println("当前已经使用：", l, "，总容量：", c)
					time.Sleep(time.Second * 3)
				case 7:
					fmt.Print("请输入指定位置(index)：")
					fmt.Scan(&index)
					s, err := list.Get(index)
					if err != nil{
						fmt.Println("查找数据失败：", err)
					}else{
						fmt.Println("下标为[", index, "]的数据是：", s)
					}
					time.Sleep(time.Second * 3)
				default:
					fmt.Println("请重新输入操作！")
					time.Sleep(time.Second * 5)
			}
			cmd := exec.Command("cmd.exe", "/c", "cls")
			cmd.Stdout = os.Stdout
			cmd.Run()
			fmt.Println("打印所有数据：")
			fmt.Println("==============================================================================")
			fmt.Println(list.GetAll())
			fmt.Println("==============================================================================")
		}
}

Hi℃瑞

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
001_顺序表的实现

实现顺序表实现顺序表的，增，删，改，查// 作者：itruirui@outlook.compackage mainimport ( "fmt" "os" "time" "errors" "os/exec")func main(){ var list List //定义一个接口类型的数据 list = NewArrayList(10) play(list) //操...
复制链接

扫一扫

专栏目录