xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-25 13:46:30 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #128 from msk397/master

Browse source 
List using Go
This commit is contained in:
Yudong Jin 2022-12-18 22:14:06 +08:00 committed by GitHub
commit 760b83f942
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 353 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

67
codes/go/chapter_array_and_linkedlist/list_test.go Normal file
View file

@ -0,0 +1,67 @@
// File: list_test.go
// Created Time: 2022-12-18
// Author: msk397 (machangxinq@gmail.com)
package chapter_array_and_linkedlist
import (
"fmt"
"sort"
"testing"
)
/* Driver Code */
func TestList(t *testing.T) {
/* 初始化列表 */
list := []int{1, 3, 2, 5, 4}
fmt.Println("列表 list =", list)
/* 访问元素 */
num := list[1] // 访问索引 1 处的元素
fmt.Println("访问索引 1 处的元素，得到 num =", num)
/* 更新元素 */
list[1] = 0 // 将索引 1 处的元素更新为 0
fmt.Println("将索引 1 处的元素更新为 0 ，得到 list =", list)
/* 清空列表 */
list = nil
fmt.Println("清空列表后 list =", list)
/* 尾部添加元素 */
list = append(list, 1)
list = append(list, 3)
list = append(list, 2)
list = append(list, 5)
list = append(list, 4)
fmt.Println("添加元素后 list =", list)
/* 中间插入元素 */
list = append(list[:3], append([]int{6}, list[3:]...)...) // 在索引 3 处插入数字 6
fmt.Println("在索引 3 处插入数字 6 ，得到 list =", list)
/* 删除元素 */
list = append(list[:3], list[4:]...) // 删除索引 3 处的元素
fmt.Println("删除索引 3 处的元素，得到 list =", list)
/* 通过索引遍历列表 */
count := 0
for i := 0; i < len(list); i++ {
count++
}
/* 直接遍历列表元素 */
count = 0
for range list {
count++
}
/* 拼接两个列表 */
list1 := []int{6, 8, 7, 10, 9}
list = append(list, list1...) // 将列表 list1 拼接到 list 之后
fmt.Println("将列表 list1 拼接到 list 之后，得到 list =", list)
/* 排序列表 */
sort.Ints(list) // 排序后，列表元素从小到大排列
fmt.Println("排序列表后 list =", list)
}

106
codes/go/chapter_array_and_linkedlist/my_list.go Normal file
View file

@ -0,0 +1,106 @@
// File: my_list.go
// Created Time: 2022-12-18
// Author: msk397 (machangxinq@gmail.com)
package chapter_array_and_linkedlist
/* 列表类简易实现 */
type MyList struct {
numsCapacity int
nums []int
numsSize int
extendRatio int
}
/* 构造函数 */
func newMyList() *MyList {
return &MyList{
numsCapacity: 10, // 列表容量
nums: make([]int, 10), // 数组（存储列表元素）
numsSize: 0, // 列表长度（即当前元素数量）
extendRatio: 2, // 每次列表扩容的倍数
}
}
/* 获取列表长度（即当前元素数量） */
func (l *MyList) size() int {
return l.numsSize
}
/* 获取列表容量 */
func (l *MyList) capacity() int {
return l.numsCapacity
}
/* 访问元素 */
func (l *MyList) get(index int) int {
// 索引如果越界则抛出异常，下同
if index >= l.numsSize {
panic("索引越界")
}
return l.nums[index]
}
/* 更新元素 */
func (l *MyList) set(num, index int) {
if index >= l.numsSize {
panic("索引越界")
}
l.nums[index] = num
}
/* 尾部添加元素 */
func (l *MyList) add(num int) {
// 元素数量超出容量时，触发扩容机制
if l.numsSize == l.numsCapacity {
l.extendCapacity()
}
l.nums[l.numsSize] = num
// 更新元素数量
l.numsSize++
}
/* 中间插入元素 */
func (l *MyList) insert(num, index int) {
if index >= l.numsSize {
panic("索引越界")
}
// 元素数量超出容量时，触发扩容机制
if l.numsSize == l.numsCapacity {
l.extendCapacity()
}
// 索引 i 以及之后的元素都向后移动一位
for j := l.numsSize - 1; j >= index; j-- {
l.nums[j+1] = l.nums[j]
}
l.nums[index] = num
// 更新元素数量
l.numsSize++
}
/* 删除元素 */
func (l *MyList) remove(index int) {
if index >= l.numsSize {
panic("索引越界")
}
// 索引 i 之后的元素都向前移动一位
for j := index; j < l.numsSize-1; j++ {
l.nums[j] = l.nums[j+1]
}
// 更新元素数量
l.numsSize--
}
/* 列表扩容 */
func (l *MyList) extendCapacity() {
// 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
l.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...)
// 更新列表容量
l.numsCapacity = len(l.nums)
}
/* 返回有效长度的列表 */
func (l *MyList) toArray() []int {
// 仅转换有效长度范围内的列表元素
return l.nums[:l.numsSize]
}

46
codes/go/chapter_array_and_linkedlist/my_list_test.go Normal file
View file

@ -0,0 +1,46 @@
// File: my_list_test.go
// Created Time: 2022-12-18
// Author: msk397 (machangxinq@gmail.com)
package chapter_array_and_linkedlist
import (
"fmt"
"testing"
)
/* Driver Code */
func TestMyList(t *testing.T) {
/* 初始化列表 */
list := newMyList()
/* 尾部添加元素 */
list.add(1)
list.add(3)
list.add(2)
list.add(5)
list.add(4)
fmt.Printf("列表 list = %v ，容量 = %v ，长度 = %v\n", list.toArray(), list.capacity(), list.size())
/* 中间插入元素 */
list.insert(6, 3)
fmt.Printf("在索引 3 处插入数字 6 ，得到 list = %v\n", list.toArray())
/* 删除元素 */
list.remove(3)
fmt.Printf("删除索引 3 处的元素，得到 list = %v\n", list.toArray())
/* 访问元素 */
num := list.get(1)
fmt.Printf("访问索引 1 处的元素，得到 num = %v\n", num)
/* 更新元素 */
list.set(0, 1)
fmt.Printf("将索引 1 处的元素更新为 0 ，得到 list = %v\n", list.toArray())
/* 测试扩容机制 */
for i := 0; i < 10; i++ {
// 在 i = 5 时，列表长度将超出列表容量，此时触发扩容机制
list.add(i)
}
fmt.Printf("扩容后的列表 list = %v ，容量 = %v ，长度 = %v\n", list.toArray(), list.capacity(), list.size())
}

143
docs/chapter_array_and_linkedlist/list.md
View file

@ -37,8 +37,9 @@ comments: true
=== "Go"
```go title="list.go"
```go title="list_test.go"
/* 初始化列表 */
list := []int{1, 3, 2, 5, 4}
```
=== "JavaScript"
@ -101,8 +102,12 @@ comments: true
=== "Go"
```go title="list.go"
```go title="list_test.go"
/* 访问元素 */
num := list[1] // 访问索引 1 处的元素
/* 更新元素 */
list[1] = 0 // 将索引 1 处的元素更新为 0
```
=== "JavaScript"
@ -201,8 +206,22 @@ comments: true
=== "Go"
```go title="list.go"
```go title="list_test.go"
/* 清空列表 */
list = nil
/* 尾部添加元素 */
list = append(list, 1)
list = append(list, 3)
list = append(list, 2)
list = append(list, 5)
list = append(list, 4)
/* 中间插入元素 */
list = append(list[:3], append([]int{6}, list[3:]...)...) // 在索引 3 处插入数字 6
/* 删除元素 */
list = append(list[:3], list[4:]...) // 删除索引 3 处的元素
```
=== "JavaScript"
@ -307,8 +326,18 @@ comments: true
=== "Go"
```go title="list.go"
```go title="list_test.go"
/* 通过索引遍历列表 */
count := 0
for i := 0; i < len(list); i++ {
count++
}
/* 直接遍历列表元素 */
count = 0
for range list {
count++
}
```
=== "JavaScript"
@ -384,8 +413,10 @@ comments: true
=== "Go"
```go title="list.go"
```go title="list_test.go"
/* 拼接两个列表 */
list1 := []int{6, 8, 7, 10, 9}
list = append(list, list1...) // 将列表 list1 拼接到 list 之后
```
=== "JavaScript"
@ -441,8 +472,9 @@ comments: true
=== "Go"
```go title="list.go"
```go title="list_test.go"
/* 排序列表 */
sort.Ints(list) // 排序后，列表元素从小到大排列
```
=== "JavaScript"
@ -739,7 +771,100 @@ comments: true
=== "Go"
```go title="my_list.go"
/* 列表类简易实现 */
type MyList struct {
numsCapacity int
nums []int
numsSize int
extendRatio int
}
/* 构造函数 */
func newMyList() *MyList {
return &MyList{
numsCapacity: 10, // 列表容量
nums: make([]int, 10), // 数组（存储列表元素）
numsSize: 0, // 列表长度（即当前元素数量）
extendRatio: 2, // 每次列表扩容的倍数
}
}
/* 获取列表长度（即当前元素数量） */
func (l *MyList) size() int {
return l.numsSize
}
/* 获取列表容量 */
func (l *MyList) capacity() int {
return l.numsCapacity
}
/* 访问元素 */
func (l *MyList) get(index int) int {
// 索引如果越界则抛出异常，下同
if index >= l.numsSize {
panic("索引越界")
}
return l.nums[index]
}
/* 更新元素 */
func (l *MyList) set(num, index int) {
if index >= l.numsSize {
panic("索引越界")
}
l.nums[index] = num
}
/* 尾部添加元素 */
func (l *MyList) add(num int) {
// 元素数量超出容量时，触发扩容机制
if l.numsSize == l.numsCapacity {
l.extendCapacity()
}
l.nums[l.numsSize] = num
// 更新元素数量
l.numsSize++
}
/* 中间插入元素 */
func (l *MyList) insert(num, index int) {
if index >= l.numsSize {
panic("索引越界")
}
// 元素数量超出容量时，触发扩容机制
if l.numsSize == l.numsCapacity {
l.extendCapacity()
}
// 索引 i 以及之后的元素都向后移动一位
for j := l.numsSize - 1; j >= index; j-- {
l.nums[j+1] = l.nums[j]
}
l.nums[index] = num
// 更新元素数量
l.numsSize++
}
/* 删除元素 */
func (l *MyList) Remove(index int) {
if index >= l.numsSize {
panic("索引越界")
}
// 索引 i 之后的元素都向前移动一位
for j := index; j < l.numsSize-1; j++ {
l.nums[j] = l.nums[j+1]
}
// 更新元素数量
l.numsSize--
}
/* 列表扩容 */
func (l *MyList) extendCapacity() {
// 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
l.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...)
// 更新列表容量
l.numsCapacity = len(l.nums)
}
```
=== "JavaScript"