golang 实现链表反转的升级版

背景

js
func main() {
    // 示例：
    // 1→2→3→4→5→6→7→8
    head := buildList([]int{1, 2, 3, 4, 5, 6, 7, 8})

    k := 3

    fmt.Println("原链表：")
    printList(head)

    newHead := reverseKFromTail(head, k)

    fmt.Println("处理后：")
    printList(newHead)
}

python 回收机制

• 引用计数
  • 每个对象维护一个 ob_refcnt 字段。每当对象被引用时计数加 1，引用失效时减 1。
• 标记清楚
  • 寻找根对象：从全局变量、调用栈等根集合出发。
  • 标记：遍历所有可达对象并打上标记。
  • 清除：遍历内存中所有对象，将没有标记（不可达）的对象销毁。
• 分代回收
  • 将内存对象分为三代（0代、1代、2代）。
  • 0代：新创建的对象。
  • 1代：在一次 GC 中幸存的对象。
  • 2代：多次 GC 后依然存活的常驻对象。
  • 策略：存活时间越久的对象越不可能是垃圾。因此，0代回收最频繁，2代回收频率最低。当某一代的对象数量达到预设阈值（Threshold）时，触发该代及更年轻代的回收。

golang实现快速排序

• 什么是快速排序
  • 从数组中选中一个基准值，递归遍历数组的值和基准值作对比，分为比基准值大的，比基准值小的数组后合并

原地排序版本

js
package main

import "fmt"

func quickSort(nums []int, left, right int) {
    if left >= right {
            return
    }

    pivot := nums[left] // 选最左作为基准
    i, j := left, right

    for i < j {
        // 从右往左找小于 pivot 的
        for i < j && nums[j] >= pivot {
                j--
        }
        // 从左往右找大于 pivot 的
        for i < j && nums[i] <= pivot {
                i++
        }
        nums[i], nums[j] = nums[j], nums[i]
    }

    // 把 pivot 放到正确位置
    nums[left], nums[i] = nums[i], nums[left]

    quickSort(nums, left, i-1)
    quickSort(nums, i+1, right)
}

func main() {
    arr := []int{5, 2, 3, 1, 4}
    quickSort(arr, 0, len(arr)-1)
    fmt.Println(arr)
}

一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和及最大子数组，case： nums = [-2,1,-3,4,-1,2,1,-5,4]​

js
package main

import (
	"fmt"
)

// maxSubArray 求最大连续子数组和
func maxSubArray(nums []int) int {
	if len(nums) == 0 {
		return 0
	}

	currentSum := nums[0]
	maxSum := nums[0]

	for i := 1; i < len(nums); i++ {
		// 当前和要么接着加，要么从当前元素重新开始
		if currentSum < 0 {
			currentSum = nums[i]
		} else {
			currentSum += nums[i]
		}

		// 更新最大值
		if currentSum > maxSum {
			maxSum = currentSum
		}
	}

	return maxSum
}

func main() {
	nums := []int{-2, 1, -3, 4, -1, 2, 1, -5, 4}
	result := maxSubArray(nums)
	fmt.Println("最大连续子数组和为:", result)
}

为什么要使用es

• 先抛出一个问题

如果数据库已经能 like '%关键词%' 查询了，为什么还要 ES？

• 可以总结为三点
  • 海量数据（千万、上亿）
  • 高性能搜索（毫秒级）
  • 复杂搜索需求（全文检索、相关性排序、高亮、分词）

ES的核心概念

elasticsearch	mysql
Index(索引)	database
Document(文档)	row(行)
Field(字段)	column(行)
Mapping	表结构
Shard(分片)	数据拆分
Replic(副本)	数据备份

es为什么写入1秒才能被检索到

因为 Elasticsearch 采用 Near Real-Time 机制。

写入数据后不会立即生成倒排索引，而是先写入内存 buffer 和 translog。 只有在 refresh（默认1秒）时，才会生成 segment，使数据可搜索。

这样设计是为了减少频繁构建索引的开销，提高写入性能。

golang实现

js
type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func deleteNode(root *TreeNode, key int) *TreeNode {
    if root == nil {
        return nil
    }

    if key < root.Val {
        root.Left = deleteNode(root.Left, key)
    } else if key > root.Val {
        root.Right = deleteNode(root.Right, key)
    } else {
        // 找到要删除的节点
        if root.Left == nil {
            return root.Right
        }
        if root.Right == nil {
            return root.Left
        }

        // 左右子树都存在：找右子树最小节点
        minNode := root.Right
        for minNode.Left != nil {
            minNode = minNode.Left
        }

        root.Val = minNode.Val
        root.Right = deleteNode(root.Right, minNode.Val)
    }

    return root
}

js
func dailyTemperatures(temperatures []int) []int {
    n := len(temperatures)
    res := make([]int, n)
    stack := []int{} // 存下标

    for i := 0; i < n; i++ {
        for len(stack) > 0 && temperatures[i] > temperatures[stack[len(stack)-1]] {
            prev := stack[len(stack)-1]
            stack = stack[:len(stack)-1]
            res[prev] = i - prev
        }
        stack = append(stack, i)
    }

    return res
}

题目一

• 给定一个旋转的有序数组，比如{7,8,9,10,1,2,3} // 是{1,2,3,7,8,9,10}旋转之后得到的， // 在数组中查找是否存在元素key。假定数组中不存在重复元素。 golang进行实现