Go实现静态顺序表

原创

it泥瓦匠 2023-09-10 23:39:11 博主文章分类：数据结构 ©著作权

文章标签 顺序表 Golang 数据结构 文章分类 Go语言后端开发 指尖人生

©著作权归作者所有：来自51CTO博客作者it泥瓦匠的原创作品，请联系作者获取转载授权，否则将追究法律责任

顺序表基本参数

定义顺序表的容量

const MaxSize = 50 			// 顺序表的容量为50

定义元素的数据类型

type ElemType = int			// 创建一个类型别名，需要存储其他类型时可以直接更改

定义顺序表的底层结构

type SqList struct{
	elem [MaxSize]ElemType	// 顺序表用来存储元素的数组，长度为MaxSize
    length int				// 顺序表的长度，即当前存储的元素个数
}

顺序表的工具方法

初始化顺序表

func InitSqList()*SqList{
    return new(SqList)		// 返回一个指向空顺序表的指针
}

获取顺序表当前长度

func (l SqList) GetLength() int {
	return l.length			// 直接返回顺序表的长度
}

判断顺序表是否为空

func (l SqList) IsEmpty() bool {
	return l.length == 0 	// 判断顺序表的长度是否等于0
}

判断顺序表是否为满

func (l SqList) IsFull() bool {
	return l.length == MaxSize // 判断顺序表的长度是否等于MaxSize
}

打印顺序表中的所有元素

// PrintBySlice 以切片的形式打印所有元素
func (l SqList) PrintBySlice() {
    end := l.GetLength()	  // 获取当前顺序表的长度
    fmt.Println(l.elem[:end]) // 以切片的形式打印所有元素
}

顺序表的插入操作

在尾部插入元素

// InsertHead 在顺序表中的尾部位置插入元素
// elem 待插入的元素
func (l *SqList) InsertTail(elem ElemType) bool {
	//1.判断当前顺序表是否存满
	if full := l.IsFull(); full {
		return false
	}
	//2.获取最后一个元素的下标
	lastIndex := l.GetLength() - 1
	//3.在尾部插入新元素
	l.elem[lastIndex+1] = elem
	//4.顺序表的长度增1
	l.length++
	//5.返回操作结果
	return true
}

//调用Insert方法实现
func (l *SqList) InsertTail(elem ElemType) bool {
	locIndex := l.GetLength()
	return l.Insert(locIndex, elem) //插入位置固定为最后一个元素后
}

在头部插入元素

// InsertHead 在顺序表中的头部位置插入元素
// elem 待插入的元素
func (l *SqList) InsertHead(elem ElemType) bool {
	//1.判断当前顺序表是否存满
	if full := l.IsFull(); full {
		return false
	}
	//2.获取最后一个元素的下标
	lastIndex := l.GetLength() - 1
	//3.从最后一个元素开始，遍历到第一个元素结束（包括第一个元素），均向后移动一个位置
	for i := lastIndex; i >= 0; i-- {
		l.elem[i+1] = l.elem[i]
	}
	//3、将新元素插入到第一个位置
	l.elem[0] = elem
	//4、顺序表的长度增1
	l.length++
	//5、返回操作结果
	return true
}

//调用Insert方法实现
func (l *SqList) InsertHead(elem ElemType) bool {
    return l.Insert(1,elem)	//插入位置固定为1
}

在指定位置插入元素

// Insert 在顺序表中的指定位置插入元素
// loc 目标位置
// elem 待插入的元素
func (l *SqList) Insert(loc int, elem ElemType) bool {
	//1.判断当前顺序表是否存满
	if full := l.IsFull(); full {
		return false
	}
	//2.判断目标位置loc是否合法
	if loc < 1 || loc > l.length+1 {
		return false
	}
	//3.获取最后一个元素的下标
	lastIndex := l.GetLength() - 1
	//4.从最后一个元素开始，向前遍历到插入位置元素结束（包括插入位置），均向后移动一个位置
	for i := lastIndex; i >= locIndex; i-- {
		l.elem[i+1] = l.elem[i]
	}
	//4.获取目标位置loc的下标
    locIndex := loc - 1
    //5.在目标位置插入元素
	l.elem[locIndex] = elem
	//6.顺序表的长度增1
	l.length++
	//7.返回操作结果
	return true
}

顺序表的删除操作

在尾部删除元素

// DeleteTail 在顺序表尾部位置删除元素
func (l *SqList) DeleteTail() bool {
	//1.判断当前顺序表是否为空
	if empty := l.IsEmpty();empty{
		return false
	}
	//2.顺序表的长度减1
	l.length--
	//3.返回操作结果
	return true
}

// DeleteAndReturnTail 在顺序表尾部位置删除元素并返回删除的元素
func (l *SqList) DeleteAndReturnTail() (ElemType, bool) {
	//1.判断当前顺序表是否为空
	if empty := l.IsEmpty(); empty {
		return -1, false
	}
	//2.获取最后一个元素的下标
	lastIndex := l.GetLength() - 1
	//3.记录最后一个元素的值
	lastElem := l.elem[lastIndex]
	//4.顺序表的长度减1
	l.length--
	//5.返回操作结果
	return lastElem, true
}

在头部删除元素

// DeleteHead 在顺序表头部删除元素
func (l *SqList) DeleteHead() bool {
	//1.判断当前顺序表是否为空
	if empty := l.IsEmpty(); empty {
		return false
	}
	//2.获取最后一个元素的下标
	lastIndex := l.GetLength() - 1
	//3.从第二个元素开始，向后遍历到最后一个元素结束(包括最后一个元素)，均向前移动一个位置
	for i := 1; i <= lastIndex; i++ {
		l.elem[i-1] = l.elem[i]
	}
	//4.顺序表长度-1
	l.length--
	//5.返回操作结果
	return true
}

// DeleteAndReturnHead 在顺序表头部删除元素并返回删除的元素
func (l *SqList) DeleteAndReturnHead() (ElemType, bool) {
	//1.判断当前顺序表是否为空
	if empty := l.IsEmpty(); empty {
		return -1, false
	}
	//2.记录第一个元素的值
	firstElem := l.elem[0]
	//3.获取最后一个元素的下标
	lastIndex := l.GetLength() - 1
	//4.从第二个元素开始，遍历到最后一个元素结束(包括最后一个元素)，均向前移动一个位置
	for i := 1; i <= lastIndex; i++ {
		l.elem[i-1] = l.elem[i]
	}
	//5.顺序表长度-1
	l.length--
	//6.返回操作结果
	return firstElem, true
}

删除指定位置元素

// Delete 删除指定位置上的元素
// loc 目标位置
func (l *SqList) Delete(loc int) bool {
	//1.判断当前顺序表是否为空
	if empty := l.IsEmpty(); empty {
		return false
	}
	//2.判断目标位置是否合法
	if loc < 1 || loc > l.length {
		return false
	}
	//3.获取目标位置的下标
	locIndex := loc - 1
	//4.获取最后一个元素的下标
	lastIndex := l.GetLength() - 1
	//5.从目标位置的下一个位置的下标开始，向后遍历到最后一个元素的下标结束（包括最后一个元素），均向前移动一个位置
	for i := locIndex + 1; i <= lastIndex; i++ {
		l.elem[i-1] = l.elem[i]
	}
	//6.顺序表长度-1
	l.length--
	//7.返回操作结果
	return true
}

// DeleteAndReturn 删除指定位置上的元素并返回删除的元素
func (l *SqList) DeleteAndReturn(loc int) (ElemType, bool) {
	//1.判断当前顺序表是否为空
	if empty := l.IsEmpty(); empty {
		return -1, false
	}
	//2.判断目标位置是否合法
	if loc < 1 || loc > l.length {
		return -1, false
	}
	//3.获取目标位置的下标
	locIndex := loc - 1
	//4.记录目标位置元素的值
	locElem := l.elem[locIndex]
	//5.获取最后一个元素的下标
	lastIndex := l.GetLength() - 1
	//6.从目标位置的下一个位置的下标开始，向后遍历到最后一个元素的下标结束（包括最后一个元素），均向前移动一个位置
	for i := locIndex + 1; i <= lastIndex; i++ {
		l.elem[i-1] = l.elem[i]
	}
	//7.顺序表长度-1
	l.length--
	//8.返回操作结果
	return locElem, true
}

顺序表的修改操作

修改指定位置元素

// Update 修改指定位置上元素的值
// loc 目标位置
// elem 修改后的值
func (l *SqList) Update(loc int, elem ElemType) bool {
	//1.判断当前顺序表是否为空
	if empty := l.IsEmpty(); empty {
		return false
	}
	//2.判断目标位置是否合法
	if loc < 1 || loc > l.length {
		return false
	}
	//3.获取目标位置的下标
	locIndex := loc - 1
	//4、在目标位置修改元素
	l.elem[locIndex] = elem
	//5、返回操作结果
	return true
}

// UpdateAndReturn 修改指定位置上元素的值并返回修改前的值
func (l *SqList) UpdateAndReturn(loc int, elem ElemType) (ElemType, bool) {
	//1.判断当前顺序表是否为空
	if empty := l.IsEmpty(); empty {
		return -1, false
	}
	//2.判断目标位置是否合法
	if loc < 1 || loc > l.length {
		return -1, false
	}
	//3.获取目标位置的下标
	locIndex := loc - 1
    //4.记录目标位置元素的值
    locElem := l.elem[locIndex]
	//5、在目标位置修改元素
	l.elem[locIndex] = elem
	//6、返回操作结果
	return locElem, true
}

顺序表的查找操作

// GetIndex 根据指定元素查找元素的位置
// elem 待查找的元素
func (l SqList) GetLocat(elem ElemType) (int, bool) {
	//1.判断当前顺序表是否为空
	if empty := l.IsEmpty(); empty {
		return -1, false
	}
	//2.最后一个元素的下标
	lastIndex := l.GetLength() - 1
	//3.遍历顺序表
	for i := 0; i <= lastIndex; i++ {
		if l.elem[i] == elem {
			return i + 1, true
		}
	}
	return -1, false
}

// GetElem 根据指定的位置查找元素
// loc 目标位置
func (l SqList) GetElem(loc int) (ElemType, bool) {
	//1.判断当前顺序表是否为空
	if empty := l.IsEmpty(); empty {
		return -1, false
	}
	//2.判断目标位置是否合法
	if loc < 1 || loc > l.length {
		return -1, false
	}
	//3.获取目标位置的下标
	locIndex := loc - 1
	//4.获取目标位置的元素
	locElem := l.elem[locIndex]
	//5.返回操作结果
	return locElem, true
}