go专业数据结构与算法

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 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

code\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实现数组迭代器

code\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
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 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
1

D:\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.队列实现遍历文件夹

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最短路径算法