algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-12-19 07:17:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add build script for Go and update Go codes.

Browse Source
This commit is contained in:
krahets
2023-02-09 04:45:06 +08:00
parent 12c085a088
commit e8c78f89f0
39 changed files with 391 additions and 1468 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
docs/chapter_stack_and_queue/queue.md
View File

@@ -302,52 +302,7 @@ comments: true
=== "Go"
```go title="linkedlist_queue.go"
/* 基于链表实现的队列 */
type linkedListQueue struct {
// 使用内置包 list 来实现队列
data *list.List
}
// newLinkedListQueue 初始化链表
func newLinkedListQueue() *linkedListQueue {
return &linkedListQueue{
data: list.New(),
}
}
// push 入队
func (s *linkedListQueue) push(value any) {
s.data.PushBack(value)
}
// poll 出队
func (s *linkedListQueue) poll() any {
if s.isEmpty() {
return nil
}
e := s.data.Front()
s.data.Remove(e)
return e.Value
}
// peek 访问队首元素
func (s *linkedListQueue) peek() any {
if s.isEmpty() {
return nil
}
e := s.data.Front()
return e.Value
}
// size 获取队列的长度
func (s *linkedListQueue) size() int {
return s.data.Len()
}
// isEmpty 判断队列是否为空
func (s *linkedListQueue) isEmpty() bool {
return s.data.Len() == 0
}
[class]{linkedListQueue}-[func]{}
```
=== "JavaScript"
@@ -424,74 +379,7 @@ comments: true
=== "Go"
```go title="array_queue.go"
/* 基于环形数组实现的队列 */
type arrayQueue struct {
nums []int // 用于存储队列元素的数组
front int // 队首指针，指向队首元素
queSize int // 队列长度
queCapacity int // 队列容量（即最大容纳元素数量）
}
// newArrayQueue 基于环形数组实现的队列
func newArrayQueue(queCapacity int) *arrayQueue {
return &arrayQueue{
nums: make([]int, queCapacity),
queCapacity: queCapacity,
front: 0,
queSize: 0,
}
}
// size 获取队列的长度
func (q *arrayQueue) size() int {
return q.queSize
}
// isEmpty 判断队列是否为空
func (q *arrayQueue) isEmpty() bool {
return q.queSize == 0
}
// push 入队
func (q *arrayQueue) push(num int) {
// 当 rear == queCapacity 表示队列已满
if q.queSize == q.queCapacity {
return
}
// 计算尾指针，指向队尾索引 + 1
// 通过取余操作，实现 rear 越过数组尾部后回到头部
rear := (q.front + q.queSize) % q.queCapacity
// 尾结点后添加 num
q.nums[rear] = num
q.queSize++
}
// poll 出队
func (q *arrayQueue) poll() any {
num := q.peek()
// 队首指针向后移动一位，若越过尾部则返回到数组头部
q.front = (q.front + 1) % q.queCapacity
q.queSize--
return num
}
// peek 访问队首元素
func (q *arrayQueue) peek() any {
if q.isEmpty() {
return nil
}
return q.nums[q.front]
}
// 获取 Slice 用于打印
func (q *arrayQueue) toSlice() []int {
rear := (q.front + q.queSize)
if rear >= q.queCapacity {
rear %= q.queCapacity
return append(q.nums[q.front:], q.nums[:rear]...)
}
return q.nums[q.front:rear]
}
[class]{arrayQueue}-[func]{}
```
=== "JavaScript"

95
docs/chapter_stack_and_queue/stack.md
View File

@@ -305,52 +305,7 @@ comments: true
=== "Go"
```go title="linkedlist_stack.go"
/* 基于链表实现的栈 */
type linkedListStack struct {
// 使用内置包 list 来实现栈
data *list.List
}
// newLinkedListStack 初始化链表
func newLinkedListStack() *linkedListStack {
return &linkedListStack{
data: list.New(),
}
}
// push 入栈
func (s *linkedListStack) push(value int) {
s.data.PushBack(value)
}
// pop 出栈
func (s *linkedListStack) pop() any {
if s.isEmpty() {
return nil
}
e := s.data.Back()
s.data.Remove(e)
return e.Value
}
// peek 访问栈顶元素
func (s *linkedListStack) peek() any {
if s.isEmpty() {
return nil
}
e := s.data.Back()
return e.Value
}
// size 获取栈的长度
func (s *linkedListStack) size() int {
return s.data.Len()
}
// isEmpty 判断栈是否为空
func (s *linkedListStack) isEmpty() bool {
return s.data.Len() == 0
}
[class]{linkedListStack}-[func]{}
```
=== "JavaScript"
@@ -425,53 +380,7 @@ comments: true
=== "Go"
```go title="array_stack.go"
/* 基于数组实现的栈 */
type arrayStack struct {
data []int // 数据
}
func newArrayStack() *arrayStack {
return &arrayStack{
// 设置栈的长度为 0，容量为 16
data: make([]int, 0, 16),
}
}
// size 栈的长度
func (s *arrayStack) size() int {
return len(s.data)
}
// isEmpty 栈是否为空
func (s *arrayStack) isEmpty() bool {
return s.size() == 0
}
// push 入栈
func (s *arrayStack) push(v int) {
// 切片会自动扩容
s.data = append(s.data, v)
}
// pop 出栈
func (s *arrayStack) pop() any {
// 弹出栈前，先判断是否为空
if s.isEmpty() {
return nil
}
val := s.peek()
s.data = s.data[:len(s.data)-1]
return val
}
// peek 获取栈顶元素
func (s *arrayStack) peek() any {
if s.isEmpty() {
return nil
}
val := s.data[len(s.data)-1]
return val
}
[class]{arrayStack}-[func]{}
```
=== "JavaScript"