结构算法(golang)

最新推荐文章于 2024-07-25 22:14:03 发布
最新推荐文章于 2024-07-25 22:14:03 发布
阅读量129 收藏
点赞数
文章标签： 数据结构 算法 golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45541665/article/details/115261154
版权

粗浅理解

  • 数据结构： 摆放数据的构造。
  • 算法： 处理数据的方法。

栈

实现

// 栈结构
type Stack struct {
	Capacity int // 容量
	Top    int // 顶元素索引，初始值设为 -1。
	arr    [5]int
}

// 压入栈
func (that *Stack) Push(val int) error {
	if that.Top == that.Capacity-1 {
		return errors.New("栈 满了")
	}
	that.Top++
	that.arr[that.Top] = val
	return nil
}

// 弹出栈
func (that *Stack) Pop() (val int, err error) {
	if that.Top == -1 {
		return 0, errors.New("栈 空了")
	}
	val = that.arr[that.Top]
	that.Top--
	return val, nil
}

// 从 栈顶-> 栈底 遍历栈
func (that Stack) List() {
	if that.Top == -1 {
		fmt.Println("空栈")
		return
	}
	for i := that.Top; i >= 0; i-- {
		fmt.Printf("arr[%d]=%d \n", i, that.arr[i])
	}
}

应用

  • 计算器
package main

import (
	"errors"
	"fmt"
	"strconv"
)

type Stack struct {
	Capacity int //容量
	Top      int
	arr      [20]int
}

func (that *Stack) Push(val int) error {
	if that.Top == that.Capacity-1 {
		return errors.New("栈 满了")
	}
	that.Top++
	that.arr[that.Top] = val
	return nil
}
func (that *Stack) Pop() (val int, err error) {
	if that.Top == -1 {
		return 0, errors.New("栈 空了")
	}
	val = that.arr[that.Top]
	that.Top--
	return val, nil

}
func (that Stack) List() {
	if that.Top == -1 {
		fmt.Println("空栈")
		return
	}
	for i := that.Top; i >= 0; i-- {
		fmt.Printf("arr[%d]=%d \n", i, that.arr[i])
	}

}

func main() {
	// 栈 实现 综合计算器： 10 以内的 加减乘除

	// 数 栈
	numStack := &Stack{
		Capacity: 20,
		Top:      -1,
	}

	// 符号 栈
	operStack := &Stack{
		Capacity: 20,
		Top:      -1,
	}

	exp := ""
	fmt.Println("请输入10以内的加减乘除：")
	fmt.Scanln(&exp)

	var num1, num2, oper, result int = 0, 0, 0, 0

	// 将 字符 分别 入栈
	for _, v := range exp {
		// 判断是 数子 还是 运算符号
		if isOper(int(v)) {
			if operStack.Top == -1 {
				// 如果 符号栈 为空，直接入栈
				operStack.Push(int(v))
			} else {
				//如果栈顶 符号 的 优先级 大于 要入栈 的,
				// 数栈 弹出两个数，符号栈 弹出一个 ，进行运算， 运算的结果 入展到 数栈，在把要入符号栈的 元素 放入
				if Priority(operStack.arr[operStack.Top]) > Priority(int(v)) {
					num1, _ = numStack.Pop()
					num2, _ = numStack.Pop()
					oper, _ = operStack.Pop()
					result = cal(num1, num2, oper)
					numStack.Push(result)
					operStack.Push(int(v))
				} else {
					operStack.Push(int(v))
				}
			}
		} else {
			res := byteToInt(v)
			numStack.Push(res) // 放入的是 数字，而不是数字对应的 字节。
		}
	}

	// 入完栈之后 进行 运算
	for {
		if operStack.Top == -1 {
			break
		}
		num1, _ = numStack.Pop()
		num2, _ = numStack.Pop()
		oper, _ = operStack.Pop()
		result = cal(num1, num2, oper)
		numStack.Push(result)
	}

	a, _ := numStack.Pop()

	fmt.Println(exp, "最后的结果是：", a)
}

// 判断一个字符 是不是一个 运算符(通过 ASCII)
func isOper(val int) bool {
	if val == 42 || val == 43 || val == 45 || val == 47 {
		return true
	} else {
		return false
	}
}

// 运算的方法
func cal(num1, num2, oper int) int {
	res := 0
	switch oper {
	case 42:
		res = num2 * num1
	case 43:
		res = num2 + num1
	case 45:
		res = num2 - num1
	case 47:
		res = num2 / num1
	default:
		fmt.Println("运算符错误")
	}
	return res
}

/*
	编写一个 处理 运算符 优先级的函数
  定义： 乘除的优先级是1； 加减的优先级是0
*/
func Priority(oper int) int {
	res := 0
	if oper == 42 || oper == 47 {
		res = 1
	} else if oper == 43 || oper == 45 {
		res = 0
	}
	return res
}

// 字节 转 int 数字
func byteToInt(a rune) int {
	s := string(a)
	res, _ := strconv.ParseInt(s, 10, 10)
	return int(res)
}

队列

实现

// 使用一个结构体 管理 环形队列
type CircleQueue struct {
	Capacity int // 容量
	head     int //指向 队头 元素，初始值设为0
	tail     int //指向 队尾 元素 的 后一位，初始值设为0
	array    [5]int
}

// 是否 满员 （重点）
func (that CircleQueue) IsFull() bool {
	/*
		每次插入数据之前都要 先看一下 插入的这个 数据位 的 后一位 是否为 头元素位，
		若是，就定义为满员，即使tail指向的该位一直空着，也不允许插入，
		所以 队列的 实际容量 比数组的长度 少一位，因为总有一个位置始终是空着的。
	*/
	return (that.tail+1)%that.Capacity == that.head
}

// 是否 为空
func (that CircleQueue) IsEmpty() bool {
	// 若相等，则说明：对头 和 队尾 之间 没有成员
	return that.tail == that.head
}

// 入队 （入队的时候 tail负责记录）
func (that *CircleQueue) Push(val int) (err error) {
	if that.IsFull() {
		fmt.Printf("%v 装不下了\n", val)
		return errors.New("full")
	}

	that.array[that.tail] = val
	// 数组 的 最后一位 空出来（始终不会装载元素），当作了标志位
	that.tail = (that.tail + 1) % that.Capacity //取模的妙用： 给定范围  让数值圈内打转
	return nil
}

// 出队 （出队的时候 head负责记录）
func (that *CircleQueue) Pop() (int, error) {
	if that.IsEmpty() {
		return -1, errors.New("完犊子，啥也没有了")
	}

	val := that.array[that.head]
	that.head = (that.head + 1) % that.Capacity
	return val, nil
}

// 元素个数（重点）
func (that CircleQueue) Size() int {
	return (that.tail + that.Capacity - that.head) % that.Capacity
}

// 显示 队列
func (that CircleQueue) ShowQueue() {
	length := that.Size()
	if length == 0 {
		fmt.Println("空队列")
	} else {
		var indexOfHead int = that.head
		for i := 0; i < length; i++ {
			fmt.Printf("arr[%d]=%d \t", i, that.array[indexOfHead])
			indexOfHead = (indexOfHead + 1) % that.Capacity
		}
		fmt.Println()
	}
}

应用

  • channel

链表

单向链表

// 链表 节点
type node struct {
	name string // 存储数据的地方
	next *node  // 指向下一个节点
}

// 链尾 加 节点
func InsertNewNode(head *node, newNode *node) {
	var temp = head
	for {
		if temp.next == nil {
			break
		}
		// 移动到下一个节点
		temp = temp.next
	}
	temp.next = newNode
}

func showAllNode(head *node) {
	if head.next == nil {
		fmt.Println("空链表")
	} else {
		var i = 1
		var temp = head.next
		for {
			fmt.Printf("第%d个节点的值是 %v \n", i, temp.name)
			if temp.next == nil {
				break
			}
			temp = temp.next
			i++
		}
	}

}

// 根据name 删除节点
func deleteNode(head *node, name string) {
	var temp = head
	for {
		if temp.next.name == name {
			// 此时 temp 是 要删除节点 的 上一个节点
			break
		}
		if temp.next == nil {
			fmt.Println("整条链都找完了，无此节点")
			return
		}
		temp = temp.next
	}

	// 判断删除的 是否为 最后一个节点
	if temp.next.next == nil {
		temp.next = nil
	} else {
		temp.next = temp.next.next
	}
	fmt.Println("删除成功")
}

双向链表

// 链表 节点
type node struct {
	name string
	pre  *node
	next *node
}

func InsertNewNode(head, tail *node, newNode *node) {
	var temp = head
	for {
		if temp.next == tail {
			break
		}
		temp = temp.next
	}
	// 先链接
	newNode.pre = temp
	newNode.next = tail
	// 再断开
	temp.next = newNode
	tail.pre = newNode
}

func GetLength(head, tail *node) int {
	var temp = head
	var i = 0
	for {
		if temp.next == tail {
			//此时 temp为 tail 的前一个 节点
			return i
		}
		i++
		temp = temp.next
	}
}

func showAllNode(head, tail *node) {
	if head.next == tail {
		fmt.Println("空链表")
	} else {
		var i = 1
		var temp = head.next
		for {
			fmt.Printf("第%d个节点的值是 %v \n", i, temp.name)
			if temp.next == tail {
				break
			}
			temp = temp.next
			i++
		}
	}

}

func deleteNode(head, tail *node, name string) {
	var temp = head
	fmt.Println(temp.next)
	for {
		if temp.name == name { // 在前
			// 此时 temp 是 要删除节点
			break
		}
		if temp.next == tail { // 在后
			fmt.Println("无此节点")
			return
		}
		temp = temp.next
	}
	temp.pre.next = temp.next
	temp.next.pre = temp.pre
	fmt.Println("删除成功")
}

排序

选择排序： 8万个数字排序 用时：12秒
插入排序： 8万个数字排序 用时：5秒
快速排序： 8百万个数字排序 用时：3秒

选择排序

// 从大到小
func SelectSort(arr *[5]int) {

	for j := 0; j < len(arr)-1; j++ {
		max := arr[j]
		maxIndex := j

		// 找出身后最大值
		for i := j + 1; i < len(arr); i++ {
			if max < arr[i] {
				max = arr[i]
				maxIndex = i
			}
		}

		// 交换
		if maxIndex != j {
			arr[j], arr[maxIndex] = arr[maxIndex], arr[j]
		}
		fmt.Printf("第%d次比较之后的结果是:%v \n", j, arr)

	}
}
  • 说明：
    假设 第一个元素为 最大值，然后 遍历其后面元素，若身后有大约第一个元素的，就让 大元素当 最大值，等到全部遍历完身后的元素，真正的最大值就找出来了，然后将真正的最大值 和 一开始 假设的最大值交换位置。

插入排序

// 从大到小
func InserSort(arr *[5]int) {
	for i := 1; i < len(arr); i++ {
		// 从第二个元素 开始和 前面的元素 进行 比较，索引 i=1开始
		insertVal := arr[i]

		insertIndex := i - 1

		for insertIndex >= 0 && arr[insertIndex] < insertVal {
			// 被比下去的元素 后移一位
			arr[insertIndex+1] = arr[insertIndex]
			// 比较的索引  前移一位
			insertIndex--
		}
		//插入
		if insertIndex+1 != i { //如果比较的元素 小于第一个比较的元素，那么自身的位置 就是 要插入的位置
			arr[insertIndex+1] = insertVal
		}
		
		fmt.Printf("第%d次比较后的结果%v \n", i, arr)
	}
}
  • 说明：
    从第二位元素开始，依次作为被比较元素insertVal， 分别 和 其前面的元素比较，如果前面的元素 小于 被比较的元素，则前面的元素后移一位，如果前面的元素大于 被比较元素，则被比较元素就放在大元素的邻后位就可以了。

快速排序

// 从小到大
// left: 数组左边的下标
// right:数组右边的下标
func QuickSort(left, right int, arr *[6]int) {
	l := left
	r := right
	// 中轴
	pivot := arr[(left+right)/2]

	// for循环的作用是： 将 比 pivot 小的 放到 左边， 大的放到右边。
	for l < r {
		// 从 pivot 左侧找到一个 比 pivot 大的 元素的 索引 l
		for arr[l] < pivot {
			l++
		}
		// 从 pivot 左侧找到一个 比 pivot 小的 元素的 索引 l
		for arr[r] > pivot {
			r--
		}
		// l >= r 表明 此次 两边元素 交换的 任务 完成了
		if l >= r {
			break
		}

		// 交换 两个元素（一个比pivot大 和 一个比pivot小） 的位置
		arr[l], arr[r] = arr[r], arr[l]
		fmt.Println("交换之后的结果：", arr)

		// 相等的情况下不必交换
		if arr[l] == pivot {
			r--
		}
		// 相等的情况下不必交换
		if arr[r] == pivot {
			l++
		}

	}
	// 如果 l==r ， 在移动下， 如果没有该句，可能会 死循环
	if l == r {
		l++
		r--
	}

	// 向左递归
	if left < r {
		QuickSort(left, r, arr)
	}
	// 向右递归
	if right > l {
		QuickSort(l, right, arr)
	}
}
  • 说明：

哈希表

package main

import (
	"fmt"
)

/*
** 1.定义员工Emp结构体(数据节点)
 */
type Emp struct {
	Id   int
	Name string
	Next *Emp
}

// Emp的方法
func (that *Emp) ShowMe() {
	fmt.Printf("在链表%d中，找到id=%d的员工\n", that.Id%7, that.Id)
}

/*
** 2.定义EmpLink结构体(数据链)
 */
type EmpLink struct {
	Head *Emp //不要表头,即第一个结点就存放员工
}

//2.1添加员工的方法, 重点： 保证添加时，编号 从小到大
func (that *EmpLink) EmpLinkInsert(emp *Emp) {

	cur := that.Head   // 这是辅助指针
	var pre *Emp = nil // 让 pre 始终在cur 的 邻前

	//如果当前的EmpLink就是一个空链表
	if that.Head == nil {
		that.Head = emp //员工插入完成
		return
	}

	//如果不是一个空链表,给emp找到对应的位置并插入
	//思路是 让 cur 和 emp 比较，然后让pre 保持在 cur 邻前
	for {
		if cur != nil {
			//比较
			if cur.Id > emp.Id {
				//找到位置,cur的前面，pre的后面
				break
				// pre.Next, emp.Next = emp, cur
				// return
			}
			//pre和cur各向后移动一位
			pre, cur = cur, cur.Next
		} else {
			break
			// pre.Next, emp.Next = emp, cur
			// return
		}
	}
	//退出时，将emp插入pre的后面，cur的前面
	pre.Next, emp.Next = emp, cur
}

//2.2显示链表的信息
func (that *EmpLink) ShowLink(no int) {
	if that.Head == nil {
		fmt.Printf("链表%d 为空\n", no)
		return
	}

	//遍历当前的链表，并显示数据
	cur := that.Head
	for {
		if cur != nil {
			fmt.Printf("链表%d:员工id=%d，名字=%s ->", no, cur.Id, cur.Name)
			cur = cur.Next
		} else {
			break
		}
	}
	fmt.Println() //换行处理
}

//2.3根据id查找对应的员工，如果没有就返回nil
func (that *EmpLink) FindEmpById(id int) *Emp {
	cur := that.Head
	for {
		if cur != nil && cur.Id == id {
			return cur
		} else if cur == nil {
			break
		}
		cur = cur.Next
	}
	return nil
}


/*
** 数组型：哈希表
*/
type HashTable struct {
	LinkArr [7]EmpLink
}

// 哈希函数
func (that *HashTable) HashFun(id int) int {
	return id % 7
}

// 増
func (that *HashTable) HashTableInsert(emp *Emp) {
	//使用哈希函数，确定将该员工添加到哪个链表
	linkNo := that.HashFun(emp.Id)
	//使用对应的链表添加
	//HashTable这里只做了id散列，真正添加在EmpLink的EmpLinkInsert方法中完成的
	that.LinkArr[linkNo].EmpLinkInsert(emp)
}

// 查
func (that *HashTable) ShowAll() {
	for i := 0; i < len(that.LinkArr); i++ {
		that.LinkArr[i].ShowLink(i)
	}
}

// 找
func (that *HashTable) FindHashTableById(id int) *Emp {
	//使用散列函数，确定将该员工应该在哪个链表
	linkNo := that.HashFun(id)
	return that.LinkArr[linkNo].FindEmpById(id)
}

func main() {
	HX := HashTable{}

	data1 := Emp{
		Id:   1,
		Name: "tom",
	}
	data2 := Emp{
		Id:   8,
		Name: "cat",
	}

	HX.HashTableInsert(&data1)
	HX.HashTableInsert(&data2)
	HX.ShowAll()
	res := HX.FindHashTableById(1)
	fmt.Println(res)
}

二叉树

package main

import "fmt"

//定义二叉树的节点
type Node struct {
	value int
	left  *Node
	right *Node
}

//功能：打印节点的值
//参数：nil
//返回值：nil
func (node *Node) Print() {
	fmt.Printf("%d ", node.value)
}

//功能：设置节点的值
//参数：节点的值
//返回值：nil
func (node *Node) SetValue(value int) {
	node.value = value
}

//功能：创建节点
//参数：节点的值
//返回值：nil
func CreateNode(value int) *Node {
	return &Node{value, nil, nil}
}

//功能：查找节点，利用递归进行查找
//参数：根节点，查找的值
//返回值：查找值所在节点
func (node *Node) FindNode(n *Node, x int) *Node {
	if n == nil {
		return nil
	} else if n.value == x {
		return n
	} else {
		p := node.FindNode(n.left, x)
		if p != nil {
			return p
		}
		return node.FindNode(n.right, x)
	}
}

//功能：求树的高度
//参数：根节点
//返回值：树的高度，树的高度=Max(左子树高度，右子树高度)+1
func (node *Node) GetTreeHeigh(n *Node) int {
	if n == nil {
		return 0
	} else {
		lHeigh := node.GetTreeHeigh(n.left)
		rHeigh := node.GetTreeHeigh(n.right)
		if lHeigh > rHeigh {
			return lHeigh + 1
		} else {
			return rHeigh + 1
		}
	}
}

// 根节点在前： 前序遍历
//功能：递归--前序--遍历二叉树
//参数：根节点
//返回值：nil
func (node *Node) PreOrder(n *Node) {
	if n != nil {
		fmt.Printf("%d ", n.value)
		node.PreOrder(n.left)
		node.PreOrder(n.right)
	}
}

// 根节点在中： 中序遍历
//功能：递归--中序--遍历二叉树
//参数：根节点
//返回值：nil
func (node *Node) InOrder(n *Node) {
	if n != nil {
		node.InOrder(n.left)
		fmt.Printf("%d ", n.value)
		node.InOrder(n.right)
	}
}

// 根节点在后： 后序遍历
//功能：递归--后序--遍历二叉树
//参数：根节点
//返回值：nil
func (node *Node) PostOrder(n *Node) {
	if n != nil {
		node.PostOrder(n.left)
		node.PostOrder(n.right)
		fmt.Printf("%d ", n.value)
	}
}

//功能：打印所有的叶子节点
//参数：root
//返回值：nil
func (node *Node) GetLeafNode(n *Node) {
	if n != nil {
		if n.left == nil && n.right == nil {
			fmt.Printf("%d ", n.value)
		}
		node.GetLeafNode(n.left)
		node.GetLeafNode(n.right)
	}
}

func main() {
	//创建一根节点
	root := CreateNode(1)
	root.left = CreateNode(2)
	root.right = CreateNode(3)

	root.left.left = CreateNode(4)
	root.left.right = CreateNode(5)

	root.right.left = CreateNode(6)
	root.right.right = CreateNode(7)

	root.left.left.left = CreateNode(8)
	root.left.left.right = CreateNode(9)

	root.left.right.left = CreateNode(10)
	root.left.right.right = CreateNode(11)

	root.right.left.left = CreateNode(12)
	root.right.left.right = CreateNode(13)

	root.right.right.left = CreateNode(14)
	root.right.right.right = CreateNode(15)
/*
                                                       1
                                    2                                   3
                         4                  5                  6                 7
                   8      9        10    11       12   13      14    15
*/

	fmt.Printf("树的高度%d\n", root.GetTreeHeigh(root))

	fmt.Printf("前序遍历：")//1 2 4 8 9 5 10 11 3 6 12 13 7 14 15
	root.PreOrder(root)
	fmt.Printf("\n")

	fmt.Printf("中序遍历：")//8 4 9 2 10 5 11 1 12 6 13 3 14 7 15
	root.InOrder(root)
	fmt.Printf("\n")

	fmt.Printf("后序遍历：")//8 9 4 10 11 5 2 12 13 6 14 15 7 3 1
	root.PostOrder(root)
	fmt.Printf("\n")

	fmt.Printf("叶节点：")//8 9 10 11 12 13 14 15
	root.GetLeafNode(root)
	fmt.Printf("\n")
}

相关说明：

  • 前序(根左右)，中序(左根右)，后序(左右根)

  • 前序 + 中序 遍历的结果 可以还原 二叉树

  • 后序 + 中序 遍历的结果 也可以还原 二叉树

  • 前序 + 后序 遍历的结果 不可以还原 二叉树

码刀攻城
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
golang数据结构与算法——栈
qq_39280718的博客
08-18 432
栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底
golang数据结构
Pepsi_QAQ的博客
08-13 463
常见的数据结构有数组、切片、Map、结构体。 一、数组 数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或多个元素组成。 数组的声明语法如下 var variable_name [size] variable_type 数组变量名：数组声明及使用时的变量名。 元素数量：数组的元素数量，可以是一个表达式，但最终通过编译期计算的结果必须是整型数值，元素数量不能含有到运行时才能确认大小的数值。 Type：可以是任意基本类型，包括数组本身，类型为数组本身时，可以实现多维数组。 数组的每个元素都可以
golang A* 导航算法
weixin_43114209的博客
02-19 6582
【代码】golang A* 导航算法。
golang 10大排序算法
Haikuotiankong11111的博客
09-28 2674
1. 快速排序 思路和算法 快速排序的主要思想是通过划分将待排序的序列分成前后两部分，其中前一部分的数据都比后一部分的数据要小，然后再递归调用函数对两部分的序列分别进行快速排序，以此使整个序列达到有序。 快排模板1： func quick_sort(nums []int, l, r int) { if l >= r { return } rand.Seed(time.Now().Unix()) p := rand.Intn(r-l+1) + l nums[r], nums[p] =
Golang数据结构和算法
hixiaoyang的博客
08-31 699
Golang数据结构和算法 数据的逻辑结构和物理结构 常见数据结构及其特点 算法的时间复杂度和空间复杂度 Golang冒泡排序 Golang选择排序 Golang插入排序 Golang快速排序 Golang归并排序 Golang二分查找 Golang sort包 Golang链表 Golang container/list标准库 Golang栈stack Golang二叉搜索树
常见数据结构和算法(golang)
poqweur的博客
04-22 893
go实现数据结构和算法
golang常见数据结构之树
SMILY12138的博客
04-10 574
在上面的代码中，我们首先定义了一个Node类型，它包含一个值和两个子节点。NewNode方法用于创建一个新的节点，Insert方法用于将一个元素插入到树中，Search方法用于搜索树中是否存在某个元素。总之，Golang提供了tree包来实现树的功能。在计算机科学中，树是一种非线性数据结构，它由节点和边组成。在main函数中，我们创建了一个Node对象，并分别将5、13、7、3四个元素插入到树中。tree包提供了丰富的接口和方法，可以轻松地定义和操作树。在Golang中，我们可以使用结构体和指针来实现树。
一致性哈希算法golang版本
weixin_43683432的博客
06-30 317
一致性哈希（Consistent Hashing）是一种分布式系统中常用的算法，用于在节点（如缓存服务器）之间均匀分配数据。它的核心思想是将所有可能的哈希值组织成一个环形结构，并将数据和节点通过哈希值映射到这个环上。这样在添加或删除节点时，只需重新分配极少量的数据，从而实现负载均衡和高可用性。简单说：将节点均匀的分布，由一个环形结构，来将这些节点映射，实现负载均衡和高可用效果。
堆排序算法 golang实现
qq_49723651的博客
11-30 668
堆排序算法 golang实现 文章目录堆排序算法 golang实现算法描述算法步骤代码 算法描述 算法描述：首先建一个堆，然后调整堆，调整过程是将节点和子节点进行比较，将 其中最大的值变为父节点，递归调整调整次数lgn,最后将根节点和尾节点交换再n次 调整。 算法步骤 创建大根堆或者小根堆。 调整堆。 交换首尾节点(为了维持一个完全二叉树才要进行收尾交换)。 代码 实现1: package main import "fmt" func HeapSortMax(arr []int, len
Golang实现一致性Hash算法
何忆清风
09-05 1646
golang实现一致性Hash算法
golang实现的数据结构与算法
07-17
golang实现的数据结构与算法
数据结构与算法 by golang.zip
01-01
不过，考虑到标题是“数据结构与算法 by golang.zip”，我们可以假设这是一个关于使用Golang语言讲解数据结构和算法的资源包。下面我将基于这个主题，详细介绍数据结构和算法以及它们在Golang中的应用。 数据结构是...
基于Golang的算法竞赛模板库
02-21
在编程竞赛中，拥有一个高效的算法模板库是至关重要的，特别是在使用Golang这种高效且简洁的开发语言时。本文将详细探讨如何构建和利用“基于Golang的算法竞赛模板库”，以及它对参赛者和开发者的价值。 首先，...
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 771
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
（数据结构）二叉树
2401_83526138的博客
07-24 621
树是一种非线性的数据结构，它是由n（n>=0）个有限节点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：有一个特殊的节点，称为根节点，根节点没有前驱节点除根节点外，其余节点被分成M（M > 0）个互不相交的集合T1, T2, ......, Tm，其中每一个集合Ti(1 <= i <= m)又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继树是递归定义的。
【C语言】数组栈的实现
最新发布
2301_80840905的博客
07-25 745
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端
数据结构——双向链表及其总结
2406_83392683的博客
07-23 343
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
7.24数据结构
2301_81236242的博客
07-24 591
1>树形结构：表示数据元素之间存在一对多的关系2>树：是由一个根节点多个子树构成的树形结构3>节点：就是树中的数据元素4>父亲节点：当前节点的直接上级节点5>孩子节点：当前节点的直接下架节点6>祖先节点：当前节点的直接或间接上级节点7>子孙节点：当前节点的直接或间接下级节点8>兄弟节点：拥有相同父节点的所有节点互称为兄弟节点9>堂兄弟节点：其父节点在同一层的所有节点，互为堂兄弟节点10>根节点：没有父节点的节点11>叶子节点：没有子节点的节点称为叶子节点。
【数据结构】搜索二叉树
dab112的博客
07-24 1313
介绍了二叉搜索树的实现与模拟
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值