网站建设注意哪些问题,上海建设手机网站,盱眙有做公司网站的吗,泰州网站建设go语言之专业数据结构与算法
2.数组概念 3.golang实现数组结构 4.golang实现数组迭代器 5.数组栈的高级实现 6.栈模拟低级递归 7.斐波那契数列栈模拟递归 8.递归实现文件夹遍历 9.栈模拟文件递归 10.层级展示文件夹 11.数组队列的实现 12.队列实现遍历文件夹 13.循环队列 14.链…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.数据的map内存模型 36.快速排序编程实现 37.二分查找法 38.二分查找与快速排序用于数据搜索 39.内容说明 40.二分查找法 41.顺序搜索数据 42.快速排序与二分查找在数据搜索实战 43.QQ数据的快速排序与二分查找 44.改良版快速排序 45.QQ的数据20秒排序完一个亿 46.性能调优中值搜索 47.斐波那契查找 48.二分查找变形写法 49.gnomesort 50.查询第N大的QQ 51.休眠排序 52.希尔排序改良梳子排序 53.木桶排序 54.三分查找 55.哈希表原理 56.set结构 57.作业
3.golang实现数组结构
code\ArrayList\ArrayList.go
package ArrayListimport (errorsfmt
)// 接口
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 0return 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
code\main.go
package mainimport (fmt./ArrayList
)func main() {list : ArrayList.NewArrayList()list.Append(1)list.Append(2)list.Append(3)fmt.Println(list)
}package mainimport (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 ArrayListimport (errorsfmt
)// 接口
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 0return 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 ArrayListimport (errorsfmt
)// 接口
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 0return 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.TheSize1] // 插入数据内存移动一位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 {// 重写叠加跳过indexlist.dataStore append(list.dataStore[:index], list.dataStore[index1:]...)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实现数组迭代器
code\ArrayList\ArrayListIterator.go
package ArrayListimport errorstype 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 0it.list listreturn 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.currentindexreturn 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 ArrayListimport (errorsfmt
)// 接口
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 0return 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.TheSize1] // 插入数据内存移动一位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 {// 重写叠加跳过indexlist.dataStore append(list.dataStore[:index], list.dataStore[index1:]...)list.TheSize--return nil
}D:\Workspace\Go\src\projects\code\main.go
package mainimport (fmtprojects/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
f3
D:\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:\Workspace\Go\src\projects\code\StackArray\StackArray.go
package StackArraytype 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 0return mystack
}func (mystack *Stack) Clear() {mystack.dataSource make([]interface{}, 0, 10) // 数组mystack.currentsize 0mystack.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
1
D:\Workspace\Go\src\projects\code\ArrayList\ArrayListStack.go
package ArrayListtype StackArray interface {Clear() // 清空Size() int // 大小Pop() interface{} // 弹出Push(data interface{}) // 压入IsFull() bool // 是否满了IsEmpty() bool // 是否为空
}type Stack struct {myarray *ArrayListcapsize 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 ArrayListtype StackArrayX interface {Clear() // 清空Size() int // 大小Pop() interface{} // 弹出Push(data interface{}) // 压入IsFull() bool // 是否满了IsEmpty() bool // 是否为空
}type StackX struct {myarray *ArrayListMyit 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.队列实现遍历文件夹 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.数据的map内存模型 5.快速排序编程实现 6.二分查找法 7.7二分查找与快速排序用于数据搜索 1.内容说明 2.二分查找法 3.顺序搜索数据 4.快速排序与二分查找在数据搜索实战 5.QQ数据的快速排序与二分查找 6.改良版快速排序 7.QQ的数据20秒排序完一个亿 8.性能调优中值搜索 9.斐波那契查找 10.二分查找变形写法 1.查询第N大的QQ 2.gnomesort 3.休眠排序 4.希尔排序改良梳子排序 5.木桶排序 6.三分查找 7.哈希表原理 8.set结构 9.作业 58.链表 59.链表架构头部插入与查询 60.链表尾部插入以及随机位置的后插入 61.链表的删除 62.单链表应用处理数据 63.链表的中间节点 64.链表反转 65.双链表结构 66.双链表的插入 67.双链表插入改进与查询 68.双链表的删除 69.双链表应用处理数据 70.线程安全与解决线程安全 71.线程安全的队列 72.实现最大堆最小值 73.优先队列 74.哈希表原理 75.哈希表哈希算法 76.哈希表实现 77.作业说明 78.多线程希尔排序 79.线程安全的map结构 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.并发安全的hashmap结构增删改查数据 113.线程安全的循环双端链表 114.佛系排序 115.实现手动控制走迷宫 116.实现迷宫的寻路算法 117.控制迷宫走出 118.for逻辑错误解决迷宫走出 119.栈与队列深度遍历广度遍历原理 120.栈模拟实现递归寻路 121.队列实现广度遍历 122.递归汉诺塔 123.汉诺塔图形化 124.递归求解迷宫 125.递归解决背包问题 126.非递归解决背包补充 127.递归解决皇后问题 128.递归改进解决皇后问题 129.字符串解析概述
/* 130.以太坊VM虚拟机原理解析字符串表达式基础 131.以太坊VM虚拟机原理解析字符串表达式最终数据结算 132.以太坊VM虚拟机原理解析字符串表达式字符读取判断 133.以太坊VM虚拟机原理解析字符串表达式数据分段处理 134.以太坊VM虚拟机原理解析字符串表达式数据分段处理核心解析类1 135.以太坊VM虚拟机原理解析字符串表达式数据分段处理核心解析类2 136.以太坊VM虚拟机原理解析字符串表达式最终实现 137.以太坊VM虚拟机原理实现增加指令
*/ 138.递归九宫格 139.自动驾驶算法A星算法简介 140.实战自动驾驶算法A星算法-实现栈 141.实战自动驾驶算法A星算法-地图类 142.实战自动驾驶算法A星算法-A星点数据结构 143.实战自动驾驶算法A星算法-A星算法核心实现 144.实战自动驾驶算法A星算法-调用A星 145.学习树的必要性 146.二叉树定义与插入 147.二叉树的二分查找 148.取得二叉树的极大值极小值 149.二叉树递归实现中序后序遍历 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.哈夫曼树的定义与堆实现 202.构造实战哈夫曼树 203.数据结构综合复习 204.数据结构标准库的二次调用 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.实现百度网盘急速上传原理之哈希树 242.KD树的用途 243.KD树的基本定义 244.构造KD树并保证数据有序 245.实现KD树的查找与按照维度搜索极大极小 246.KD树实现维度搜索范围内的数据 247.KD树实现按照维度删除 248.KD树的增删改查以及平衡 249.KD树的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树与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最短路径算法
