paho.mqtt.golang--option.go 源码解析

broker: 指 mqtt 服务器 package mqtt import ( "crypto/tls" "net/http" "net/url" "regexp" "strings" "time" ) // 允许在重新连接之前更新用户名和密码。函数应该返回当前的用户名和密码。 type CredentialsProvider func() (username string, password string) // MessageHandler 是一种回调类型， // 可以设置为在发布到订阅了客户端的主题的消息到达时执行。 type MessageHandler func(Client, Message) // ConnectionLostHandler是一种回调类型，可以设置为在与MQT...阅读全文

mandodb: 教你如何从零开始写一个时序数据库

Go语言入门(二)-流程控制

go流程控制 字符串详解 字符串原理 字符串底层就是一个byte数组，所以可以和[]byte类型互相转换 字符串中的字符是不能修改的 字符串是有byte字节组成，所以字符串的长度是byte字节的长度 rune类型(int32占四个字节)用来表示utf8字符，一个rune由一个或者多个byte组成 func stringByte() { var str string str = "abc你好" var b []byte = []byte(str) var c[]rune = []rune(str) fmt.Printf("%c\n",97) fmt.Printf("b=%v,\tlen(str)=%d\n",b,len(str)) fmt.Printf("%d\n",len(c)) } 练习 ...阅读全文

leetcode_99

Golang: 思路：这题最简单的思路，因为二叉搜索树中序遍历的特性，使得我们可以遍历所有值，找到被交换的那两位，然后把他们重新交换回来。这里给出morris算法实现（可能是这题真正最大的价值） 代码如下： func recoverTree(root *TreeNode) { //还是应该理解为找逆序对，使用中序遍历 var pre, x, y *TreeNode for root != nil { if root.Left != nil { node := root.Left for node.Right != nil && node.Right != root { node = node.Right } if node.Right == nil { node.Right = root r...阅读全文

leetcode_1051

Golang: 思路：这题最好的思路是桶排序，因为限制条件明确而清晰，这里不得不说大佬还是大佬。常规思路自然是：将数组复制一遍，然后排序，排完序后的数组与原数组对比，求出所有同一位上数值不同的元素的数量。 代码如下： func heightChecker(heights []int) int { if len(heights)<=1 { return len(heights) } temp:=make([]int,len(heights)) copy(temp,heights) sort.Ints(temp) res:=0 for i:=0;i阅读全文

golang语言map的并发和排序

golang语言map的并发和排序 map的并发问题 golang缺省的map不是thread safe的，如果存在读写并发的使用场景，必须在外面使用lock机制。 包sync里面引入一个安全map； type Map struct func (m *Map) Store(key, value interface{}) func (m *Map) Load(key interface{}) (value interface{}, ok bool) func (m *Map) Range(f func(key, value interface{}) bool) func (m *Map) Delete(key interface{}) 用法： package main import ( "fm...阅读全文

golang排序算法(sort)简单好用

golang排序，是我们锻炼逻辑必不可少的，不会可以QQ联系 2817228206。相互学习。本人是小白。写的比较简单，推荐用官网的包。package mainimport "fmt"func numsum(arr []int) []int { sum := []int{} ksum := 0 vsum := 0 for _, v := range arr { for ka, va := range arr { if va > v || len(arr) == 1 { ksum = ka vsum = va } } } sum = append(sum, ksum, vsum) return sum}func main() { var arr = []int{} arr = append(a...阅读全文

golang 二维切片排序

package main import ( "fmt" "sort" ) //type value []string type value [][]int func (p value) Len() int { return len(p) } // 二维切片排序 func (p value) Less(i, j int) bool { for k := 0; k < len(p[i]); k++ { if len(p[j]) == 0 || p[j] == nil { // 长度为空时 return true } fmt.Println(p, i, j, k) if p[i][k] > p[j][k] { // < 则正序 return true } else if p[i][k] == p[...阅读全文

golang 快速排序

golang 快速排序 package main import ( "fmt" "strconv" ) func quickSort(arr []int, low, high int) { if low < high { var pivot = partition(arr, low, high) quickSort(arr, low, pivot) quickSort(arr, pivot + 1, high) } } func partition(arr []int,low,high int) int { var pivot = arr[low] var i = low var j= high // 6 5 4 3 2 1 // 6 1 2 3 4 7 for i< j{ for arr[...阅读全文

插入排序的Golang 实现

再次研究了插入排序的概念：定义一个有序的数据序列a，将待排序的序列b中的数依次插入到a的合适位置，插入后仍然有序总结其与冒泡、选择的区别在于，内部迭代的次数是逐渐增大的，二后两者随着排序进行迭代次数逐渐减少尝试基于Go的实现： func insertSort(arr []int) { l := len(arr) for i := 1; i < l; i++ { for v := 0; v < i; v++ { if arr[v] > arr[i] { arr[v], arr[i] = arr[i], arr[v] } } } ...阅读全文

二叉树的基本运算2

这一篇是接上一篇文章二叉树的基本运算 二叉树的遍历 二叉树遍历分为三种：前序、中序、后序: 前序遍历：根结点 -> 左子树 -> 右子树 中序遍历：左子树 -> 根结点 -> 右子树 后序遍历：左子树 -> 右子树 -> 根结点 另外还有一种层次遍历，即每一层都从左向右遍历。譬如，对于下面的二叉树 前序遍历：abdefgc中序遍历：debgfac后序遍历：edgfbca层次遍历：abcdfeg 实现方法 因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中，前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对来说要难一点 中序遍历 go实现 // 中序遍历，用栈实现 f...阅读全文

【Golang 基础】Go 语言 面向对象

Go 语言的面向对象   Go 语言的面向对象非常简单，仅支持封装，不支持继承和多态。继承和多态是在接口中实现的。   因此 Go 语言中没有 class，而是通过 struct（结构体） 对相同类型或不同类型的数据进行封装。 通过 type struct {} 格式定义结构体； type User struct { Name string Age int IsActive bool } 定义后的结构体就可以作为类型使用； hvkcoder := User{Name: "hvkcoder", Age: 18, IsActive: true} fmt.Println(hvkcoder) // {hvkcoder 18 true} 或 hvkcoder := User{...阅读全文

golang 冒泡排序算法

package main import "fmt" func main() { arr := []int{7, 13, 4, 5, 8, 1, 11, 9} fmt.Println("排序前", arr) length := len(arr) - 1 for i := length; i >= 0; i-- { for j := 0; j <= i - 1; j++ { if arr[j] > arr[j+1] { arr[j], arr[j+1] = arr[j+1], arr[j] } } } fmt.Println("排序后",arr) } 排序前 [7 13 4 5 8 1 11 9] 排序后 [1 4 5 7 8 9 11 13...阅读全文

算法篇序章

1.为什么要学数据结构和算法 IT开发工作中，大部分人是从业务开发为出发点的，而业务开发首要的是需求、功能的实现。在项目的里程碑、发版deadline等目标的驱动下，开发同学们往往挣扎于业务苦海，少有时间去思考性能优化和底层调用，往往一套框架和工具拿来即用，CURD不要太舒服。这样的结果就是一方面，第三方API和框架工具的使用大大提升了开发人员的开发效率，但是另一方面，许多开发人员对底层原理和数据结构知之甚少，一旦工具调用出问题则一脸懵B，所谓的开发工程师，无非是API调用工程师。 工作多年，我经历了多次线上生产的性能问题，这些经历生产上一些性能问题往往都是开发同学在对代码细节上考虑不周引起的，而这些操作往往都是对底层逻辑不熟悉导致的，掌握好这些基础写出更加优秀的程序，排查问题时也知道所以然...阅读全文

golang 归并排序，快速排序， 堆排序

归并排序 在这里插入图片描述 func sortArray(nums []int) []int { if len(nums) <= 1 { return nums } partA := sortArray(nums[:len(nums)/2]) partB := sortArray(nums[len(nums)/2:]) temp := make([]int, len(partA) + len(partB)) aPointer := 0 bPointer := 0 i := 0 for aPointer < len(partA) && bPointer < len(partB) { if partA[aPointer] < partB[bPointer] { temp[i] = partA[...阅读全文

Let’s Encrypt证书吊销事故的思考

title: "Let’s Encrypt证书吊销事故的思考" date: 2020-03-28T00:11:54+08:00 description: "如何保障代码的安全性？" featured_image: "" categories: "其它" tags: [] 前段时间一则新闻引爆了程序界：《一行Golang代码引发的血案——全网最详细分析2020年3月Let’s Encrypt证书吊销事故》。 这个事故的原因上文已经说得很清楚了，这里摘抄一下： 那么这个软件到底出现了什么问题才会导致如此滑稽的故障？我翻看着Let's Encrypt最近的commit，找到了一个Pull Request：#4690。看完这个Pull Request后，我马上意识到问题所在：Golang最经典的错误...阅读全文

Golang实现整型栈

package main import ( "fmt" "errors" ) type Stack struct { Size int Top int arr [5]int } const INT_MAX = int(^uint(0) >> 1) func (self *Stack) Push(ele int) (err error) { if self.Top == self.Size - 1 { err = errors.New("Stack full error!!") return } self.Top++ self.arr[self.Top] = ele return } func (self *Stack) Pop() (val int, err error) { val = -...阅读全文

lesson-1：go 第一个程序

什么是 GO 程序 go 程序是一段简单的 UTF-8 编码的以 .go 结尾的文件。 GO 程序结构 package main // 创建一个 main 包，使用关键字 package import "fmt" // 从 Go 标准库中引入 fmt 包，使用关键字 import func main() { // 入口函数 fmt.Println("hello go") // fmt包中 Println 函数 } Go 程序都必须以一个包开头，必须包含一个 main 函数。main 函数是程序的入口函数。 $ go run ./hello.go // 执行 hello.go 文...阅读全文

第一个 Go 程序

我们来编写第一个 Go 程序 hello.go（Go语言源文件的扩展是 .go），代码如下： package main import "fmt" func main() { fmt.Println("Hello, World!") } 执行以上代码输出 $ go run hello.go Hello, World! 本文来自木庄网络博客> 第一个 Go 程...阅读全文

leetcode_392

Golang: 思路：这题乍一看蛮像什么最长公共子序列的，实际上，完全不是。只要你不会先入为主的认为它不简单，就可以很轻松的找到这题的诀窍。即，只要s是t的子序列，那么s的所有元素，都会在t中依次出现。 实现：于是这题就变成了道双指针问题，a指针指向s中的元素，b指针指向t中的元素，每当s和t符合，s++，t++。是子序列的话，s最终会走到len(s),不是的话，t会最终走到len(t)。 func isSubsequence(s string, t string) bool { if len(s)==0 { return true } if len(t)==0 { return false } i,j:=0,0 for i阅读全文

leetcode_889

Golang: 思路：因为前序和后序是没有办法构建一个唯一的二叉树序列的，所以需要在某些方面自定规则，比如[1，2],[2,1]，这里将这种序列定义为一个左子树 代码如下： func constructFromPrePost(pre []int, post []int) *TreeNode { node:=&TreeNode{Val: pre[0]} //长度至少要大于1才能构建子树 if len(pre)>1{ i:=0 for i阅读全文

（二）Golang的变量

为什么需要变量： 变量是程序的基本组成单位不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位，比如： func getVal(num1 int, num2 int) (int, int) {sum := num1 + mum2sub := num1 - num2return sum, sub} func main() {sum, sub := getVal(30, 30)fmt.Println("sum=", sum, "sub=", sub)sum2, _ := getVal(10, 30)fmt.Println("sum=", sum2)...阅读全文

Golang 选择排序

package main import "fmt" func SelectSort(arr *[5]int) { //1.先将最大值和arr[j]交换 for j := 0; j < len(arr)-1; j++ { max := arr[j] //假设最大值为 arr[j] maxIndex := j //2.遍历比较 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 time,...阅读全文

Golang 插入排序

func InsertSort(arr *[5]int) { for i := 1; i < len(arr); i++ { 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 time %v\n", i, *arr) } } func main() { arr := ...阅读全文

leetcode_429

Golang: 思路：广度优先实现层序遍历 代码如下： func levelOrder(root *Node) [][]int { var res [][]int var arr[]*Node if root!=nil{ arr=append(arr,root) for len(arr)!=0{ temp:=len(arr) var level []int for i:=0;i阅读全文

每日算法-排序-冒泡排序

冒泡排序的特点是调整相邻两个对象的位置，每进行一次内循环就可以将最大值调整到最后。时间复杂度是O(n^2) package main import "fmt" func popsort(a []int) []int{ for i:=0;ia[j+1]{ a[j],a[j+1]=a[j+1],a[j] } } } return a } func main(){ a := []int{8,5,2,9,3,4,1,7,6} fmt.Printf("%v",popsort(a)) ...阅读全文

leetcode_98

Golang: 思路：依旧是中序遍历，如果数组是递增的，那么二叉搜索树是正确的 代码如下： func isValidBST(root *TreeNode) bool { arr := inOrderValDFS(root) for i := 1; i < len(arr); i++ { if arr[i] <= arr[i-1] { return false } } return true } func inOrderValDFS(root *TreeNode) []int { var stack []*TreeNode var res []int for len(stack) != 0 || root != nil { for root != nil { stack = append(st...阅读全文

leetcode_1207

Golang: 思路：先对数组进行排序，然后计算每个元素出现了几次，存进map里，注意，这里map只是当作一个set来使用的，判断有没有出现重复而已。 代码如下： func uniqueOccurrences(arr []int) bool { if len(arr)<=1 { return true } sort.Ints(arr) m:=make(map[int]int) temp:=1 for i:=1;i阅读全文

leetcode_637

Golang: 思路：二叉树，层序遍历即可 代码如下： func averageOfLevels(root *TreeNode) []float64 { var res []float64 if root!=nil{ stack:=[]*TreeNode{root} for len(stack)!=0{ level:=len(stack) num:=0 for i:=0;i阅读全文

leetcode_143

Golang: 思路：链表，这题最简单的思路是，链表存进数组，然后一次性解决。再复杂一点就是，链表从中间分开，后半部分反转，然后再和前半部分依照特定规律合并。这里给简单思路，个人觉得这题没必要追求空间复杂度。 代码如下： func reorderList(head *ListNode) { node:=head if node==nil||node.Next==nil||node.Next.Next==nil{ return } var arr []*ListNode arr=append(arr, head) length:=1 for node.Next!=nil{ length++ node=node.Next arr=append(arr, node) } for i:=0;i阅读全文

leetcode_623

Golang: 思路：还是通过层序遍历的方式来实现 代码如下： func addOneRow(root *TreeNode, v int, d int) *TreeNode { if d==1{ return &TreeNode{Left:root,Val:v} } if root!=nil{ stack:=[]*TreeNode{root} depth:=1 for depth阅读全文