Go 언어의 전문적인 데이터 구조 및 알고리즘
2. 배열 개념
3. Golang은 배열 구조를 구현합니다
. 4. Golang은 배열 반복자를 구현합니다.
5. 배열 스택의 고급 구현
6. 스택은 저수준 재귀를 시뮬레이션합니다.
7. 피보나치 시퀀스 스택은 재귀를 시뮬레이션합니다
. 8. 폴더 순회를 재귀적으로 구현합니다
. 9. 스택 시뮬레이션 파일 재귀
10. 계층적 표시 폴더
11. 배열 큐의 실현
12. 큐 실현 트래버스 폴더
13. 순환 큐
14. 체인 스택
15. 체인 큐
16. 작업
17. 정렬 및 검색이 필요한 이유
18. 선택 정렬
19. 문자열 비교 크기
20. 문자열 선택 정렬
21. 삽입 정렬
22. 버블 정렬 23. 힙 정렬
24.
빠른 정렬 25.
패리티
정렬 26. 병합 정렬
27. 힐 정렬
28. 기수 정렬
29. 통계 정렬
30. 칵테일
31. 데이터 추출
32 . 데이터 정렬 시간
33. 데이터 메모리 검색 34.
데이터 구조 배열 메모리 모델 검색
35. 데이터 맵 메모리 모델
36. 빠른 정렬 프로그래밍 구현
37. 이진 검색 방법
38. 데이터 검색을 위한 이진 검색 및 빠른 정렬
39. 내용 설명
40. 이진 검색 방법
41. 데이터 순차 검색
42. 실제 데이터 검색에서의 빠른 정렬 및 이진 검색
43. QQ 데이터에 대한 빠른 정렬 및 이진 검색
44. 개선된 버전 Quick sort
45. QQ 데이터를 20초 만에 1억 개로 정렬
46. 성능 튜닝 중앙값 검색
47. 피보나치 검색
48. 이진 검색 변형 작성
49. gnomesort
50. N번째로 큰 QQ
쿼리 51. 수면 정렬
52 .Hill 정렬 향상된 빗 정렬
53 . 버킷 정렬
54. 3점 검색
55. 해시 테이블 원리
56. 집합 구조
57. 숙제
3. Golang은 배열 구조를 구현합니다.
코드\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 호출
코드\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은 배열 반복자를 구현합니다.
코드\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
}
D:\Workspace\Go\src\projects\code\main.go
package main
import (
"fmt"
"projects/code/ArrayList"
)
func main() {
// 定义接口对象，赋值的对象必须实现接口的所有方法
var list ArrayList.List = ArrayList.NewArrayList()
list.Append("a1")
list.Append("b2")
list.Append("c3")
list.Append("d3")
list.Append("f3")
for it := list.Iterator(); it.HasNext(); {
item, _ := it.Next()
fmt.Println(item)
}
}PS D:\Workspace\Go\src\projects\code> go run main.go
a1
b2
c3
d3
f3D:\Workspace\Go\src\projects\code\main.go
func main() {
// 定义接口对象，赋值的对象必须实现接口的所有方法
var list ArrayList.List = ArrayList.NewArrayList()
list.Append("a1")
list.Append("b2")
list.Append("c3")
list.Append("d3")
list.Append("f3")
for it := list.Iterator(); it.HasNext(); {
item, _ := it.Next()
if item == "d3" {
it.Remove()
}
fmt.Println(item)
}
fmt.Println(list)
}PS D:\Workspace\Go\src\projects\code> go run main.go
a1
b2
c3
d3
f3
[a1 b2 c3 f3]5. 어레이 스택의 고급 구현
D:\작업공간\고\src\프로젝트\코드\StackArray\StackArray.go
package StackArray
type StackArray interface {
Clear() // 清空
Size() int // 大小
Pop() interface{} // 弹出
Push(data interface{}) // 压入
IsFull() bool // 是否满了
IsEmpty() bool // 是否为空
}
type Stack struct {
dataSource []interface{}
capsize int // 最大范围
currentsize int // 实际使用大小
}
func NewStack() *Stack {
mystack := new(Stack)
mystack.dataSource = make([]interface{}, 0, 10) // 数组
mystack.capsize = 10 // 空间
mystack.currentsize = 0
return mystack
}
func (mystack *Stack) Clear() {
mystack.dataSource = make([]interface{}, 0, 10) // 数组
mystack.currentsize = 0
mystack.capsize = 10 // 空间
}
func (mystack *Stack) Size() int {
return mystack.currentsize
}
func (mystack *Stack) Pop() interface{} {
if !mystack.IsEmpty() {
last := mystack.dataSource[mystack.currentsize-1] // 最后一个数据
mystack.dataSource = mystack.dataSource[:mystack.currentsize-1] // 删除最后一个数据
mystack.currentsize-- // 删除
return last
}
return nil
}
func (mystack *Stack) Push(data interface{}) {
if !mystack.IsFull() {
mystack.dataSource = append(mystack.dataSource, data) // 叠加数据，压入
mystack.currentsize++
}
}
func (mystack *Stack) IsFull() bool { // 判断满了
if mystack.currentsize >= mystack.capsize {
return true
} else {
return false
}
}
func (mystack *Stack) IsEmpty() bool {
if mystack.currentsize == 0 {
return true
} else {
return false
}
}
D:\Workspace\Go\src\projects\code\main.go
func main() {
mystack := StackArray.NewStack()
mystack.Push(1)
mystack.Push(2)
mystack.Push(3)
mystack.Push(4)
fmt.Println(mystack.Pop())
fmt.Println(mystack.Pop())
fmt.Println(mystack.Pop())
fmt.Println(mystack.Pop())
}PS D:\Workspace\Go\src\projects\code> go run main.go
4
3
2
1D:\Workspace\Go\src\projects\code\ArrayList\ArrayListStack.go
package ArrayList
type StackArray interface {
Clear() // 清空
Size() int // 大小
Pop() interface{} // 弹出
Push(data interface{}) // 压入
IsFull() bool // 是否满了
IsEmpty() bool // 是否为空
}
type Stack struct {
myarray *ArrayList
capsize int // 最大范围
}
func NewArrayListStack() *Stack {
mystack := new(Stack)
mystack.myarray = NewArrayList() // 数组
mystack.capsize = 10 // 空间
return mystack
}
func (mystack *Stack) Clear() {
mystack.myarray.Clear()
mystack.capsize = 10 // 空间
}
func (mystack *Stack) Size() int {
return mystack.myarray.TheSize
}
func (mystack *Stack) Pop() interface{} {
if !mystack.IsEmpty() {
last := mystack.myarray.dataStore[mystack.myarray.TheSize-1] // 删除
mystack.myarray.Delete(mystack.myarray.TheSize - 1)
return last
}
return nil
}
func (mystack *Stack) Push(data interface{}) {
if !mystack.IsFull() {
mystack.myarray.Append(data)
}
}
func (mystack *Stack) IsFull() bool { // 判断满了
if mystack.myarray.TheSize >= mystack.capsize {
return true
} else {
return false
}
}
func (mystack *Stack) IsEmpty() bool {
if mystack.myarray.TheSize == 0 {
return true
} else {
return false
}
}
D:\Workspace\Go\src\projects\code\main.go
func main() {
mystack := ArrayList.NewArrayListStack()
mystack.Push(1)
mystack.Push(2)
mystack.Push(3)
mystack.Push(4)
fmt.Println(mystack.Pop())
fmt.Println(mystack.Pop())
fmt.Println(mystack.Pop())
fmt.Println(mystack.Pop())
}D:\Workspace\Go\src\projects\code\ArrayList\ArrayListIteratorStack.go
package ArrayList
type StackArrayX interface {
Clear() // 清空
Size() int // 大小
Pop() interface{} // 弹出
Push(data interface{}) // 压入
IsFull() bool // 是否满了
IsEmpty() bool // 是否为空
}
type StackX struct {
myarray *ArrayList
Myit Iterator
}
func NewArrayListStackX() *StackX {
mystack := new(StackX)
mystack.myarray = NewArrayList() // 数组
mystack.Myit = mystack.myarray.Iterator() // 迭代
return mystack
}
func (mystack *StackX) Clear() {
mystack.myarray.Clear()
mystack.myarray.TheSize = 0
}
func (mystack *StackX) Size() int {
return mystack.myarray.TheSize
}
func (mystack *StackX) Pop() interface{} {
if !mystack.IsEmpty() {
last := mystack.myarray.dataStore[mystack.myarray.TheSize-1] // 删除
mystack.myarray.Delete(mystack.myarray.TheSize - 1)
return last
}
return nil
}
func (mystack *StackX) Push(data interface{}) {
if !mystack.IsFull() {
mystack.myarray.Append(data)
}
}
func (mystack *StackX) IsFull() bool { // 判断满了
if mystack.myarray.TheSize >= 10 {
return true
} else {
return false
}
}
func (mystack *StackX) IsEmpty() bool {
if mystack.myarray.TheSize == 0 {
return true
} else {
return false
}
}
D:\Workspace\Go\src\projects\code\main.go
func main() {
mystack := ArrayList.NewArrayListStackX()
mystack.Push(1)
mystack.Push(2)
mystack.Push(3)
mystack.Push(4)
// fmt.Println(mystack.Pop())
// fmt.Println(mystack.Pop())
// fmt.Println(mystack.Pop())
// fmt.Println(mystack.Pop())
for it := mystack.Myit; it.HasNext(); {
item, _ := it.Next()
fmt.Println(item)
}
}6. 스택은 저수준 재귀를 시뮬레이트합니다.
1. 피보나치 시퀀스 스택은 재귀를 시뮬레이션합니다.
2. 폴더 순회 재귀 구현
3. 스택 시뮬레이션 파일 재귀
4. 계층 표시 폴더
5. 어레이 큐 구현
6. Queue는 폴더 통과를 실현합니다.
7. 순환 대기열
8. 연결된 스택
9. 연쇄 대기열
10. 숙제
1. 정렬 및 검색
2. 선택 정렬
3. 문자열 비교 크기
4. 문자열 선택 정렬
5. 삽입 정렬
6. 버블 정렬
7. 힙 정렬
8. 퀵 정렬
9. 패리티 정렬
1. 병합 정렬
2. 힐 정렬
3. 기수 정렬
4. 통계별 정렬
5. 토너먼트 정렬
6. 칵테일
7. 데이터 추출
8. 데이터 정렬 시간
1. 데이터 하드디스크 검색
2. 데이터 메모리 검색
3. 데이터 구조 배열 메모리 모델 조회
4. 데이터 맵 메모리 모델
5. 빠른 정렬 프로그래밍 구현
6. 이진 검색 방법
7.7 데이터 검색을 위한 이진 검색 및 빠른 정렬
1. 내용 설명
2. 이진 검색 방법
3. 순차 검색 데이터
4. 실제 데이터 검색에서 빠른 정렬 및 이진 검색
5. QQ 데이터의 빠른 정렬 및 이진 검색
6. 퀵 정렬 개선
7. QQ 데이터를 20초 만에 1억개 정렬
8. 성능 튜닝 중앙값 검색
9. 피보나치 찾기
10. 이진 검색 변형 작성
1. N번째로 큰 QQ 쿼리
2.gnomesort
3. 수면 분류
4. 힐소트 개선 콤소트
5. 캐스크 선별
6. 3점 검색
7. 해시 테이블 원리
8.세트 구조
9. 숙제
58. Linked list
59. Linked list 아키텍처의 헤드 삽입 및 쿼리
60. Linked list tail 삽입 및 삽입 후 임의 위치
61. Linked list 삭제
62. Single linked list 응용 프로그램 처리 데이터
63. Linked list의 중간 노드
64. Linked list reversal
65. 이중 연결 리스트 구조
66. 이중 연결 리스트 삽입
67. 이중 연결 리스트 삽입 개선 및 쿼리
68. 이중 연결 리스트 삭제
69. 이중 연결 리스트 응용 프로그램 처리 데이터
70. 스레드 안전성 및 스레드 안전성 해결
71. 스레드 안전 큐
72. 최대 힙 최소값 실현
73 .우선 순위 큐
74. 해시 테이블 원칙
75. 해시 테이블 해시 알고리즘
76. 해시 테이블 구현
77. 작업 설명
78. 멀티 스레드 힐 정렬
79. 스레드 안전 맵 구조
80. 분산 병합 정렬 원리
81. 분산 정렬을 위한 미들웨어 작성 82.
동시 정렬
83. 분산 정렬
84. 분산 정렬 프로토콜 개요
85. 분산 정렬 프로그래밍 프로토콜
86. 분산 네트워크 타임아웃 연결 해제
87. 분산 정렬의 기본 프로토콜 및 트랜스코딩
88. 데이터 전송 프로토콜
89. 이중 통신 어레이 전송 프로토콜
90. 궁극의 분산 정렬
91. 분산 필수 기본 RPC 프로토콜
92. 숙제
93. 설명 94.
분산 정렬 및 네트워크 소개
95. 데이터 프로토콜 및 전송 프로토콜
96. 네트워크 타임아웃 메커니즘 구현
97. 분산 이중 통신
98. 단절된 재접속 구현
99. 분산 정렬
100. 스레드에서 빠른 정렬의 높은 동시성 구현 풀
101. 최대값과 최소값을 얻기 위해 수억 개의 데이터를 달성하는 연결된 힙
102. 조셉 링을 해결하기 위한 단일 링크 연결 목록 구현
103. 이중 연결 목록 소개
104. 이중 연결 목록 검색
105. 이중- 연결 리스트 순회 및 수정
106. 이중 연결 리스트 삭제
107. 이중 연결 리스트 추가, 삭제, 수정 및 쿼리 테스트
108. 빠른 주소 정렬
109. 테이블 삽입 정렬
110. 집합 교차 합집합 하위 집합 차이의 기본 구조 구현 연산 구현
111. 이중 연결 목록 구현 해시 테이블
112. 동시적이고 안전한 해시맵 구조 추가, 삭제, 수정 및 쿼리 데이터
113. 스레드로부터 안전한 원형 양방향 연결 목록
114. 불교 정렬
115. 수동 제어 구현 미로
116. 미로의 길 찾기 알고리즘 구현
117. 미로 탈출 제어
118. 미로 탈출 논리 오류 해결을 위해 미로 탈출
119. 큐를 이용한 스택 깊이 순회 및 폭 순회 원리
120. 재귀를 달성하기 위한 스택 시뮬레이션 경로 찾기
121. 폭 통과를 달성하기 위한 대기열
122. 하노이의 재귀 타워
123. 하노이의 그래픽 타워
124. 재귀적으로 미로 해결하기
125. 재귀적으로 배낭 문제 해결하기
126. 비재귀적으로 해결하기 위한 배낭 보충 자료
127. 재귀적으로 Queens 문제 해결하기
128. 재귀적으로 개선된 Queens 문제 해결하기
129. 문자열 구문 분석 개요
/*
130. 이더리움 VM 가상머신 분석 원리 문자열 표현 기초
131. 이더리움 VM 가상머신 분석 원리 문자열 표현 최종 데이터 정산
132. 이더리움 VM 가상머신 분석 원리 문자열 표현 문자 판독 판단
133 .이더리움 VM 가상머신 원리 파싱 문자열 표현 데이터 세그먼트 처리
134. 이더리움 VM 가상 머신 원리 구문 분석 문자열 표현 데이터 세그먼트 처리 코어 구문 분석 클래스 1
135. 이더리움 VM 가상 머신 원리 구문 분석 문자열 표현 데이터 세그먼트 처리 코어 구문 분석 클래스 2
136. 이더리움 VM 가상 머신 구문 분석 원리 문자열 표현을 구현하고 마침내
137개를 구현합니다. Ethereum VM 가상 머신의 원리는 명령 추가를 실현합니다.
*/
138. 재귀 지공
139. 오토파일럿 알고리즘 소개 A-스타 알고리즘
140. 실제 오토파일럿 알고리즘 A-스타 알고리즘-구현 스택
141. 실제 오토파일럿 알고리즘 A-스타 알고리즘-맵
142. 실제 오토파일럿 알고리즘 A-스타 알고리즘-A Star Point 데이터 구조
143. 실제 Autopilot 알고리즘 A-Star 알고리즘 - A-Star 알고리즘의 핵심 구현
144. 실제 Autopilot 알고리즘 A-Star 알고리즘 - A-Star 호출
145. 학습 트리의 필요성
146. Binary Tree 정의 및 삽입
147. 이진 트리 이진 검색
148. 이진 트리의 최대값과 최소값 획득
149. 이진 트리 재귀적으로 in-order 및 post-order traversal 구현
150. 이진 트리의 트리 표시
151. 이진 트리 최대 및 최소 삭제
152. 재귀 이진 트리 삭제 구현
153. 순차 순회 비재귀 구현
154. 선순 순회
비재귀 구현 155. 후속 순회 비재귀 구현
156. 이진 트리 요약
157. 이진 트리 깊이 순회, 폭 순회 및 계층 순회
158. 이진 트리 최소 공통 조상
159. 재귀 이진 트리 깊이
160. 스택 구현
161. 데이터 유형 변환
162. 연산자 및 간단한 계산의 정의
163. 네 가지 산술 연산 및 접미사 표현의 원리 정의
164. 문자열 절단
165. 중위식을 접미사식으로 변환
166. 디지털 대수식 계산
167. 우선 순위 및 괄호 처리 수정
168. 알고리즘 요약 개요
169. 이진 트리 검토 및 이진 트리의 노드 수를 재귀적으로 계산
170. AVL 트리의 이론적 근거
171. AVL 트리의 기본 정의
172. 임의 검색 및 검색 최대값 AVL 트리의
173 .AVL 트리 생성
174. AVL 트리 왼손잡이 및 오른 손잡이 프로그래밍 구현
175. AVL 트리 먼저 왼쪽 다음 오른쪽 먼저 오른쪽 다음 왼쪽
176. AVL 트리의 자동 균형
177. AVL 트리 삽입 데이터
178 . AVL 트리 삭제 데이터
179 .AVL 트리 데이터 순회
180. AVL 트리 테스트
181. AVL 삭제 문제
182. AVL 균형 트리 수준 오류 수정
183. 레드-블랙 트리의 기본 정의
184. 레드-블랙 트리 기본 데이터 유형 캡슐화
185. 레드-블랙 트리 탐색이 매우 크다 최소값과 임의값
186. 왼손 레드-블랙 트리 구현
187. 레드-블랙 트리 오른손 구현
188. 레드-블랙 트리의 삽입 알고리즘
189. 레드-블랙 트리
190. 레드-블랙 트리의 깊이
191. 레드-블랙 트리 근사 검색
192. 다양한 상황을 처리하는 레드-블랙 트리 삭제 알고리즘
193. 레드-블랙 트리 삭제 균형
194. 레드-블랙 트리 테스트 추가, 삭제, 수정 및 쿼리 효율성
195. 작업 설명
196. B 트리의 원리
197. B 트리 및 노드 검색의 정의
198. B 트리의 노드 삽입
199. B 트리 검색 및 삽입 및 문자열 표시
200. B 트리 테스트 완료
201. Huffman 트리 정의 및 힙 구현
202. 실용적인 Huffman 트리 구축
203. 데이터 구조 종합 검토
204. 데이터 구조 표준 라이브러리의 2차 호출 205. 데이터 구조 표준 라이브러리의
코드 관계 및 구조 206. 사전 트리의 원리 207. 사전 트리의 매핑 구조 208. 사전 트리의 기본 정의 209 사전 트리의 데이터 저장 210. 사전 트리 검색 알고리즘 211. 사전 트리 제안 및 테스트 212. 사전 트리의 접두사 및 접미사 수정 213. 라인 세그먼트 트리 설명 214. 배열 라인 세그먼트 트리 구성 215. 재귀 구현 배열 라인 세그먼트 트리에 쿼리 및 삽입 216. 배열 라인 세그먼트 트리 일반 수정 217. 배열 라인 세그먼트 트리 테스트 218. 이진 트리 라인 세그먼트 트리 선언 219. 이진 트리 라인 세그먼트 트리 인터페이스 220. 이진 트리 라인 세그먼트 트리 구성 및 삽입 곱셈 221. 이진 트리 라인 세그먼트 트리 쿼리 RMQ 및 ST 테이블 222. 이진 트리 라인 세그먼트 트리 테스트 223. 이진 트리 라인 세그먼트 트리 구현 224. 머클 트리 구현 프로그래밍 225. 엔터프라이즈급 머클 트리 226. 스플레이 트리 정의 227. 스플레이 트리 검색 구현 228. 스플레이 트리 삽입 구현
229. 스트레치 트리 삭제 구현
230. 스트레치 트리 인쇄 구현
231. 스트레치 트리 왼쪽 회전 및 오른쪽 회전 구현
232. 스트레치 트리 왼쪽 이중 선택 오른쪽 이중 선택 왼쪽 및 오른쪽 회전 구현
233 스트레치 트리 테스트
234. VEB 트리 정의
235. VEB 트리 저장 및 인터페이스 정의
236. VEB 트리 저장 및 인터페이스 정의
237. VEB 트리 검색 통계 인쇄
238. VEB 트리 삽입 및 구성
239. VEB 구현 삭제
240. VEB 테스트
241. 빠른 업로드 원칙의 Baidu 네트워크 디스크 해시 트리 구현
242. KD 트리의 목적
243. KD 트리의 기본 정의
244. KD 트리 구성 및 데이터 순서 보장
245. KD 트리 검색 실현 및 차원에 따른 최대값과 최소값 검색
246. KD 트리 차원 검색 범위 내 데이터 구현
247. KD 트리 차원에 따른 삭제 구현
248. KD 트리의 추가, 삭제, 수정 및 조회 및 균형
249. KNN 코어 알고리즘 프레임워크 250. KD 트리의
KNN 알고리즘 구현
251. KD 트리 테스트
252. 라인 세그먼트 253. rangeTree 범위는
데이터 인접 계산 실현
254. Bplus 트리의 개념 255.
Bplus 트리의 정의
256. Bplus 트리의 리프 노드 검색
257. Bplus 트리 규칙의 리프 노드 및 분할 및 에지
258. Bplus 트리의 기본 기능
259. Bplus 트리의 검색 구현 및 트리 분할
260. Bplus 트리의 삽입
261. Bplus 트리의 테스트 및 저장 범위
262. B-tree와 B+ 트리의 차이점
263. B+ 트리의 전사적 개발 실습 소개
264. 배열 병합
265. 병합 체인 구현
266. Skiplist의 사용 및 정의
267. 점프 테이블 구현
268. Skiplist 검색 구현
269. Skiplist 데이터 설정 구현
270. Skiplist 데이터 획득 및 삭제 구현
271. Skiplist 테스트 및 높은 동시 구현 스레드 안전 테스트
272. 문자열 검색 및 무차별 대입 검색 구현
273. 무차별 검색 문자열 최적화의 첫 번째 단계
274. KMP 문자열 빠른 검색 실현
275. 깊이 탐색 및 너비 탐색 원칙
276. 너비 탐색으로 미로 탐색 실현
277. 깊이 탐색 미로 통과
278 실현. 그래프 279 깊이 통과
그래프 280 폭 통과
Floyd 최단 경로 알고리즘