Estrutura de dados profissional e algoritmo da linguagem go
2. Conceito de array
3. Golang implementa estrutura de array
4. Golang implementa iterador de array
5. Implementação avançada de pilha de array
6. Pilha simula recursão de baixo nível
7. Pilha de sequência de Fibonacci simula recursão
8. Implementação recursiva de travessia de pasta
9. Pilha Simula arquivo recursão
10. Pasta de exibição hierárquica
11. Realização da fila de matriz
12. Pasta transversal de realização da fila
13. Fila circular
14. Pilha de cadeia
15. Fila de cadeia
16. Tarefa
17. Por que você precisa classificar e pesquisar
18. Classificação de seleção
19. Comparação de strings tamanho
20. Ordenação por seleção de strings
21. Ordenação por inserção
22. Ordenação por bolhas 23. Ordenação por heap
24. Ordenação
rápida 25. Ordenação por
paridade 26. Ordenação por mesclagem 27. Ordenação por montes 28. Ordenação por raízes 29. Ordenação estatística 30. Coquetel 31. Extração de dados 32 Tempo de classificação de dados 33. Pesquisa de memória de dados 34. Pesquisa de modelo de memória de matriz de estrutura de dados 35. Modelo de memória de mapa de dados 36. Implementação de programação de classificação rápida 37. Método de pesquisa binária
38. Pesquisa binária e classificação rápida para pesquisa de dados
39. Descrição do conteúdo
40. Método de pesquisa binária
41. Dados de pesquisa sequencial
42. Classificação rápida e pesquisa binária na pesquisa de dados reais
43. Classificação rápida e pesquisa binária para dados QQ
44. Versão aprimorada Quick classificação
45. Dados QQ classificados por 100 milhões em 20 segundos
46. Pesquisa mediana de ajuste de desempenho
47. Pesquisa Fibonacci
48. Escrita variante de pesquisa binária
49. gnomesort
50. Consulta o N-ésimo maior QQ
51. Classificação do sono
52. Classificação de colina aprimorada classificação de pente
53 Classificação de baldes
54. Pesquisa de três pontos
55. Princípio da tabela hash
56.estrutura do
conjunto 57. Tarefa de casa
3. Golang realiza a estrutura da matriz
código\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)
}
Chame ArrayList.go
código\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() não será compilado porque nenhum dos métodos na interface foi implementado.
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
}
Agora compila sem problemas
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
}
teste
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)
}falha de memoria
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)
}
Inserir método de interface de otimização, método 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 resulta em nenhuma memória sendo alocada,
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 implementa iteradores de matriz
código\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. Implementação avançada de pilha de matriz
D:\Workspace\Go\src\projects\code\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. Stack simula recursão de baixo nível
1. A pilha de sequência de Fibonacci simula recursão
2. Implementação recursiva de travessia de pasta
3. Recursão do arquivo de simulação de pilha
4. Pasta de exibição hierárquica
5. Implementação da fila de array
6. A fila realiza a travessia de pastas
7. Fila Circular
8. Pilha encadeada
9. Fila encadeada
10. Lição de casa
1. Classificando e pesquisando
2. Classificação de seleção
3. Tamanho de comparação de strings
4. Ordenação da seleção de string
5. Ordenação por inserção
6. Ordenação por bolhas
7. Classificação de heap
8. Classificação rápida
9. Ordenação por paridade
1. Mesclar classificação
2. Tipo de colina
3. Ordenação Radix
4. Classifique por estatísticas
5. Classificação do Torneio
6. Coquetéis
7. Extração de dados
8. Tempo de classificação de dados
1. Pesquisa de dados no disco rígido
2. Pesquisa de memória de dados
3. Pesquisa de modelo de memória de matriz de estrutura de dados
4. Modelo de memória do mapa de dados
5. Implementação de programação de classificação rápida
6. Método de busca binária
7.7 Pesquisa binária e classificação rápida para pesquisa de dados
1. Descrição do conteúdo
2. Método de busca binária
3. Dados de pesquisa sequencial
4. Classificação rápida e pesquisa binária na pesquisa de dados reais
5. Classificação rápida e pesquisa binária de dados QQ
6. Classificação rápida aprimorada
7. Dados QQ classificados 100 milhões em 20 segundos
8. Pesquisa mediana de ajuste de desempenho
9. Descoberta de Fibonacci
10. Escrita da variante de pesquisa binária
1. Consultar o N-ésimo maior QQ
2.gnomesort
3. Classificação do sono
4. Classificação de pente melhorada
5. Seleção de barris
6. Pesquisa de três pontos
7. Princípio da tabela hash
8. definir a estrutura
9. Trabalho de casa
58. Lista encadeada
59. Inserção de cabeça e consulta de arquitetura de lista encadeada
60. Inserção de cauda de lista encadeada e posição aleatória pós-inserção
61. Exclusão de lista encadeada
62. Dados de processamento de aplicativos de lista encadeada única
63. Nós intermediários da lista encadeada
64. Lista encadeada reversão
65. Estrutura de lista duplamente vinculada
66. Inserção de lista duplamente
vinculada 67. Melhoria e consulta de inserção de lista
duplamente vinculada 68. Exclusão de lista duplamente vinculada
69. Dados de processamento de aplicativo de lista duplamente vinculada
70. Segurança de rosca e solução de segurança de rosca
71. Fila thread-safe
72. Realizando o valor mínimo do heap máximo
73. Fila prioritária
74. Princípio da tabela hash
75. Algoritmo hash da tabela hash
76. Implementação da tabela hash
77. Descrição do trabalho
78. Classificação multithreaded Hill
79. Estrutura do mapa thread-safe
80. Princípio de classificação por mesclagem distribuída
81. Escrita de middleware para classificação distribuída
82. Classificação simultânea
83. Classificação distribuída
84. Visão geral do protocolo de classificação distribuída
85. Protocolo de programação de classificação distribuída
86. Desconexão de tempo limite de rede distribuída
87. Protocolo básico e transcodificação de classificação distribuída
88. Protocolo de transmissão de dados
89. Protocolo de transmissão de matriz de comunicação duplex
90. Classificação distribuída final
91. Protocolo RPC básico essencial distribuído
92. Lição de casa
93. Descrição
94. Classificação distribuída e introdução à rede
95. Protocolo de dados e protocolo de transmissão
96. Implementação do mecanismo de tempo limite da rede
97. Comunicação duplex distribuída
98. Realização de reconexão desconectada
99. Classificação distribuída
100. Alta simultaneidade Implementação de classificação rápida em thread pool
101. Heap vinculado para atingir centenas de milhões de dados para obter valores máximos e mínimos
102. Implementação de lista vinculada de link único para resolver o anel de Joseph
103. Introdução à lista de links duplos
104. Pesquisa de lista de links duplos
105. Double-linked list travessia e modificação de lista
encadeada 106. Exclusão de
lista encadeada 107. Adição, exclusão, modificação e teste de consulta em lista encadeada
108. Classificação rápida de endereços
109. Classificação por inserção de tabela
110. Realização da estrutura básica da diferença de subconjunto de união de interseção de conjunto implementação de operação
111. Tabela de hash de implementação de lista duplamente vinculada
112. Adição, exclusão, modificação e consulta de estrutura hashmap simultânea e segura
113. Lista vinculada circular de duas extremidades segura para threads
114. Classificação budista
115. Realização de controle manual para percorrer o labirinto
116. Realização do algoritmo de descoberta de caminhos do labirinto
117. Controlando o labirinto para sair
118. Para resolver o erro lógico do labirinto para sair do
119. Princípio de travessia de profundidade e travessia de largura de pilha com fila
120. Simulação de pilha para obter recursividade pathfinding
121. Fila para alcançar a travessia em largura
122. Torre Recursiva de Hanoi
123. Torre Gráfica de Hanoi
124. Resolução recursiva de labirintos
125. Resolução recursiva de problemas de mochila
126. Solução não recursiva de suplementos de mochila
127. Resolução recursiva de problemas de rainhas
128. Resolução recursivamente aprimorada de problemas de rainhas
129. Visão geral da análise de strings
/*
130. Princípio de Ethereum VM Análise de Máquina Virtual Expressão de String Básico
131. Princípio de Ethereum VM Análise de Máquina Virtual Expressão de String Liquidação de Dados Finais
132. Princípio de Ethereum VM Análise de Máquina Virtual Expressão de String Julgamento de Leitura de Caracteres
133 .Ethereum VM análise do princípio da máquina virtual Processamento de segmento de dados de expressão de string
134. Princípio da máquina virtual Ethereum VM processamento de segmento de dados de expressão de string classe de análise 1
135. Princípio da máquina virtual Ethereum VM análise de expressão de string Processamento de segmentos de dados classe de análise 2
136. O princípio da máquina virtual Ethereum VM analisa expressões de string e finalmente realiza
137. O princípio da máquina virtual Ethereum VM realiza a adição de instruções
*/
138. Jiugongge recursivo
139. Introdução ao algoritmo de piloto automático Algoritmo A-Star
140. Pilha de implementação do algoritmo A-Star real do algoritmo A-Star
141. Algoritmo real do piloto automático A-Star Algoritmo-Mapa
142. Algoritmo real do piloto automático A-Star Algoritmo-A Estrutura de dados de ponto estrela
143. Algoritmo de piloto automático real Algoritmo A-Star - Implementação principal do algoritmo A-Star
144. Algoritmo de piloto automático real Algoritmo A-Star - Chamando A-Star
145. Necessidade de Árvore de Aprendizagem
146. Definição e Inserção de Árvore Binária
147. Pesquisa binária de árvore binária
148. Obter os valores máximo e mínimo da árvore binária
149. Árvore binária implementa recursivamente a travessia em ordem e pós-ordem
150. Exibição da árvore binária
151. Árvore binária exclui máximo e mínimo
152. Recursivo implementação de exclusão de árvore binária
153. Implementação não recursiva de travessia em ordem
154 .Implementação não recursiva de travessia de pré -ordem
155. Implementação não recursiva de travessia subsequente
156. Resumo da árvore binária
157. Travessia em profundidade, largura e hierárquica da árvore binária travessia
158. Antepassado comum mínimo da árvore binária
159. Profundidade da árvore binária recursiva
160. Implementação da pilha
161. Conversão de tipo de dados
162. Definição de operadores e cálculos simples
163. Definição de quatro operações aritméticas e princípios de expressões de sufixo
164. Corte de strings
165. Convertendo Expressões Infixas em Expressões Sufixas
166. Cálculo de Expressões de Álgebra Digital
167. Modificar prioridade e processamento de parênteses
168. Visão geral resumida do algoritmo
169. Revisão da árvore binária e cálculo recursivo do número de nós na
árvore binária 170. Base teórica da árvore AVL
171. Definição básica da árvore AVL
172. Pesquisa aleatória e valor máximo de pesquisa da árvore AVL
173 Criação da árvore .AVL
174. Realização da programação para canhotos e destros da árvore AVL
175. Árvore AVL primeiro à esquerda e depois à direita e primeiro à direita e depois à esquerda
176. Equilíbrio automático da árvore AVL
177. Dados de inserção da árvore AVL
178 Dados de exclusão de árvore AVL
179 Percorrendo dados de árvore AVL
180. Teste de árvore AVL
181. O problema da exclusão de AVL
182. Modificação de erro de nível de árvore balanceada AVL
183. Definição básica da árvore rubro-negra
184. Encapsulamento do tipo de dados básico da árvore rubro-negra
185. A busca da árvore rubro-negra é extremamente grande Valor mínimo e valor arbitrário
186. Realize a árvore rubro-negra canhota
187. Realize a árvore rubro-negra destra
188. Algoritmo de inserção da árvore rubro-negra
189. Algoritmo de equilíbrio de inserção de árvore rubro-negra
190. Profundidade da árvore rubro-negra
191. Árvore rubro-negra Busca aproximada
192. Algoritmo de deleção de árvore rubro-negra lida com diferentes situações
193. Balanço de deleção de árvore rubro-negra
194. Adição, exclusão, teste de árvore rubro-negra eficiência de modificação e consulta
195. Descrição do trabalho
196. Princípio da árvore B
197. Definição da árvore B e pesquisa de nó
198. Inserção de nó da árvore B
199. Pesquisa e inserção da árvore B e exibição de string
200. Completar o teste da
árvore B 201. Definição e implementação de heap da árvore Huffman
202. Construção prática da árvore Huffman
203. Revisão abrangente da estrutura de dados
204. A chamada secundária da biblioteca padrão de estrutura de dados
205. O relacionamento de código e a estrutura
da biblioteca padrão de estrutura de dados 206. O princípio da árvore do dicionário
207. A estrutura de mapeamento da árvore do dicionário
208. A definição básica da árvore do dicionário
209. O armazenamento de dados da árvore do dicionário
210. Algoritmo de busca da Árvore do Dicionário
211. Sugestão e teste da árvore do dicionário
212. Modificação do prefixo e sufixo da árvore do dicionário
213. Descrição da árvore do segmento de linha 214.
Construção da árvore do segmento de linha do array
215. Implementação recursiva de consulta e inserção na árvore de segmento de linha de matriz
216. Modificando a árvore de segmento de linha de matriz Genérica
217. Teste de árvore de segmento
de linha de matriz 218. Declaração da árvore de segmento de linha de árvore binária
219. Interface de árvore de segmento de linha de árvore binária
220. Construção de árvore de segmento de linha de árvore binária e multiplicação por inserção
221. Consulta de árvore de segmento de linha de árvore binária RMQ e tabela ST
222. Teste de árvore de segmento
de linha de árvore binária 223. Implementação de árvore de segmento de linha de árvore binária
224. Realização de programação da árvore Merkle
225. Árvore Merkle de nível empresarial
226. Definição de árvore splay
227. Realização de busca por splay tree
228. Implementação de inserção de splay tree
229. Realize a exclusão da árvore do trecho
230. Realize a impressão da árvore do trecho
231. Realize a rotação à esquerda e à direita da árvore do trecho
232. Realize a seleção dupla à esquerda Seleção dupla à direita à esquerda e rotação à direita da
árvore do trecho 233 Testar a árvore stretch
234. Definição de árvore VEB
235. Armazenamento de árvore VEB e definição de interface
236. Armazenamento de árvore VEB e definição de interface
237. Impressão de estatísticas de pesquisa de árvore VEB
238. Inserção e construção de árvore VEB
239. Exclusão de implementação VEB
240. Teste VEB
241. Implementação da árvore de Hash do disco de rede Baidu do princípio de upload rápido
242. O objetivo da árvore KD
243. A definição básica da árvore KD
244. Construir árvore KD e garantir a ordem dos dados
245. Realize a pesquisa da árvore KD e pesquisa de máximo e mínimo de acordo com as dimensões
246. Realização da árvore KD Dados dentro do escopo da pesquisa de dimensão
247. A árvore KD realiza a exclusão de acordo com a dimensão
248. Adição, exclusão, modificação e consulta da árvore KD e balanceamento
249. Estrutura do algoritmo central KNN da árvore KD
250. Implementação do algoritmo KNN da árvore KD
251. Teste da árvore KD
252. Segmento de linha 253. faixa rangeTree realiza
o cálculo do vizinho de dados
254. conceito da árvore Bplus 255.
definição da árvore Bplus
256. busca do nó folha da árvore Bplus
257. nó folha e divisão e aresta da regra da árvore Bplus
258. Funções básicas da árvore Bplus
259. Implementação de pesquisa e particionamento
da árvore Bplus 260. Inserção
da árvore Bplus 261. Teste e intervalo de armazenamento
da árvore Bplus 262. Diferenças entre a árvore B e a árvore B+
263. Desenvolvimento de nível empresarial da árvore B+ prática Introdução
264. Array Merge
265. Implementação de Merge Chain
266. Uso e Definição de Skiplist
267. Realize Jump Table
268. Realize Skiplist Search
269. Realize Skiplist Data Setting
270. Realize Skiplist Data Acquisition and delete
271. Implemente skiplist test e high concorrente teste de segurança de thread
272. Implementação de pesquisa de string e pesquisa de força bruta
273. Primeira etapa da otimização de string de pesquisa de força bruta
274. Realize recuperação rápida de string KMP
275. Princípio de travessia em profundidade e travessia em largura
276. Travessia em largura realiza a travessia do labirinto
277. Travessia em profundidade realiza a travessia do labirinto
278. Percurso em profundidade do gráfico
279. Percurso em largura do gráfico
280. Algoritmo de caminho mais curto Floyd