func eraseOverlapIntervals(intervals [][]int) int {
    // 剔除长度为 0 的情况
    if len(intervals) == 0 {
        return 0
    }

    var resIntervals = [][]int{}

    // 按照结束时间排序
    startTimes, endTimes := sortIntervals(intervals)
    // 排在第一个的，是一定要选定的
    resIntervals = append(resIntervals, []int{startTimes[0], endTimes[0]})
    
    currentEndTime := endTimes[0]
    for i := 1; i < len(endTimes); i++ {
        // 在已排序好的结构中，选择开始时间比当前结束时间大的，作为下一个选定对象
        if currentEndTime <= startTimes[i] {
            resIntervals = append(resIntervals, []int{startTimes[i], endTimes[i]})
            currentEndTime = endTimes[i]
        }
    }

    return len(intervals) - len(resIntervals)
}

func sortIntervals(intervals [][]int) (startTimes []int, endTimes[]int) {
    // 这里使用选择排序算法，把 intervals 按照结束时间排序
    for i := 1; i < len(intervals); i++ {
        key := intervals[i]
        var j = i-1

        for j >= 0 && key[1] < intervals[j][1] {
            intervals[j+1] = intervals[j]
            j--
        }
        intervals[j+1] = key
    }

    for i := 0; i < len(intervals); i++ {
        startTimes = append(startTimes, intervals[i][0])
        endTimes = append(endTimes, intervals[i][1])
    }
    
    return
}

func ReverseList( pHead *ListNode ) *ListNode {
    // 排除极端情况
    // 当然，这也是递归调用的终止条件
    if pHead == nil || pHead.Next == nil {
        return pHead
    }
    
    // 递归拿到最后一个元素
    newHead := ReverseList(pHead.Next)
    
    // 执行反转，让其下一个元素，倒指向其本身
    // 此时的 pHead 已经不是原来的 pHead 了，而是倒数第二个元素、倒数第三个元素 ... 
    pHead.Next.Next = pHead
    
    // 置空本身的 next 属性（会有下一个元素帮其重新指向正确的元素）
    pHead.Next = nil
    
    // 新链表的表头在最后一次递归中获取到
    // 该变量一直没变，层层往上抛
    return newHead
}

// 没用说使用了递归方法就不能使用全局变量
// 能帮助理清思路
var lastNode *ListNode

func reverseKList(head *ListNode, k int) *ListNode {
	// 当 k == 1 的时候，说明递归深度已经到头了
	if k <= 1 {
		lastNode = head.Next
		return head
	}

	// 拿到第 K 个节点
	KthNode := reverseKList(head.Next, k-1)

	// 反转链表
	head.Next.Next = head

	// 设置每轮反转后，元素的默认 next 值
	// 如果它不是最初的 head 的话，会有下一轮来修改它的 next
	// 如果是最初的 head，则它指向 k+1 元素
	head.Next = lastNode

	// 返回第 K 个节点，因为它将作为新的 head
	return KthNode
}

func reverseBetween(head *ListNode, m int, n int) *ListNode {
	// 直到 m == 1，就开始按照反转前 n 个的思路操作
	if m == 1 {
		reverseKList(head, m-n)
	}

	// 如果匹配不到 m==1，保持原有序列不变
	head.Next = reverseBetween(head.Next, m-1, n-1)

	// 返回最初的 head
	return head
}

var lastNode *ListNode

func reverseKList(head *ListNode, k int) *ListNode {

	if k <= 0 {
		lastNode = head.Next
		return head
	}

	KthNode := reverseKList(head.Next, k-1)
	head.Next.Next = head
	head.Next = lastNode

	return KthNode
}

type Node struct {
	Val    int
	Parent *Node
	Left   *Node
	Right  *Node
}

type BST struct {
	Root *Node
}

func deleteNode(root *TreeNode, key int) *TreeNode {
    // 排除特殊条件
    if root == nil {
        return nil
    }

    if root.Val == key {
        // 已找到，开始删除
        if root.Left == nil {
            // 没有左孩子，右孩子替上
            return root.Right
        }

        if root.Right == nil {
            // 没有右孩子，左孩子替上
            return root.Left
        }
        
        // 找到后驱节点
        min := root.Right
        for min != nil && min.Left != nil {
            min = min.Left
        }
        
        // 用后驱节点的值修改本节点
        root.Val = min.Val
        // 删除后驱节点
        root.Right = deleteNode(root.Right, min.Val)

    }else if root.Val > key {
        // 比节点值小，转向左子树查找
        root.Left = deleteNode(root.Left, key)
    }else if root.Val < key {
        // 比节点值大，转向右子树查找
        root.Right = deleteNode(root.Right, key)
    }

    return root
}

func insertIntoBST(root *TreeNode, val int) *TreeNode {
    // 记录原始的根节点
    originHead := root
    var newNode = &TreeNode{Val: val}

    // 找到要插入的位置
    var p *TreeNode
    for root != nil {
        p = root
        if root.Val > val {
            root = root.Left
        }else {
            root = root.Right
        }
    }
    
    if p == nil {
        return newNode
    }else if p.Val > val {
        p.Left = newNode
    }else{
        p.Right = newNode
    }

    return originHead
}

func searchBST(root *Node, val int) *Node {
    if root == nil || root.Val == val {
        return root
    }

    if root.Val > val {
        return searchBST(root.Left, val)
    }else {
        return searchBST(root.Right, val)
    }
}

func searchBST(root *TreeNode, val int) *TreeNode {
    for root != nil && root.Val != val {
        if root.Val > val {
            root = root.Left
        }else {
            root = root.Right
        }
    }

    return root
}

func (b *BST) Minimum() *Node {
	var n = b.Root

	for n != nil && n.Left != nil {
		n = n.Left
	}

	return n
}

func (b *BST) Maximun() *Node {
	var n = b.Root

	for n != nil && n.Right != nil {
		n = n.Right
	}

	return n
}

package main

import "fmt"

func main() {
	var arr = []int{-2, 1}
	result := maxSum(arr)

	fmt.Println(result)
}

func maxSum(arr []int) int {
	var sum = arr[0]

	// 遍历每个元素
	for i := 0; i < len(arr); i++ {

		// 从第一层元素(包括它自己，因为可以是一个元素的数组)，向后遍历
		for j := i; j < len(arr); j++ {

			// 求 arr[i, j] 子数组元素的和
			var k = i + 1
			var tmpSum = arr[i]
			for k <= j {
				tmpSum += arr[k]
				k++
			}

			if tmpSum > sum {
				sum = tmpSum
			}

		}
	}

	return sum
}

package main

import "fmt"

func main() {

	var a string = "abc123"
	var b string = "bc1234"
	res := longestCommonStr(a, b)

	fmt.Println(res)

}

func longestCommonStr(a, b string) string {
	var maxLen int
	var from, to int
	// 遍历 a 的每一个字符
	for i := 0; i < len(a); i++ {

		// 遍历 b 的每一个字符
		for j := 0; j < len(b); j++ {
			if a[i] == b[j] {

				fmt.Printf("Match at %c\n", a[i])

				var matchLen int = 1
                
                // 把两个变量重新赋值（不要影响到两层循环遍历大局），开启 “携手并进”
				var p, q = i, j
                // 带判断条件的 for 循环
				for p+1 < len(a) && q+1 < len(b) && a[p+1] == b[q+1] {
					matchLen++
					p++
					q++
				}
                
                // 记录下每次符合条件的场景
				if matchLen > maxLen {
					maxLen = matchLen
					from = i
					to = p
				}

				fmt.Printf("From %d\tto %d\n", from, to)
			}
		}
	}

	return string([]byte(a)[from : to+1])
}

for i := 0; ; i++ {
    if (xxx) {
        break
    }
}

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) [][]int {
    // 构建结果数组，如果二叉树为空，则直接返回结果
    var result = [][]int{}
    if root == nil {
        return result
    }

    for k := 0; ; k++ {
        // 把第 k 层的元素撞到 tmp slice 中
        var tmp = []int{}
        kLevel(root, &tmp, k)

        // 当这一次元素数量为空，那就停止遍历，结束
        if len(tmp) == 0 {
            break
        }

        // 如果不为空，把这一层元素加到结果数组中
        result = append(result, tmp)
    }

    return result
}

// 把以 root 为根的二叉树的第 k 层装到  items 里面
func kLevel(root *TreeNode, items *[]int, k int){
    if root == nil {
        return
    }

    if k == 0 {
        // 开始装元素
        *items = append(*items, root.Val)
    } else {
        // 不属于这一层，就往下递归
        k--
        kLevel(root.Left, items, k)
        kLevel(root.Right, items, k)
    }
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func swapPairs(head *ListNode) *ListNode {
    // 链表个数为偶数个，最后一个为 nil
    // 或者为奇数个的时候，此时已是最后一个，node.Next == nil
    // 此种场景不做操作
    if head == nil ||  head.Next == nil {
        return head
    }


    newHead := head.Next

    // 指向下一轮的头结点
    head.Next = swapPairs(newHead.Next)

    // 反转相邻结点
    newHead.Next = head

    // 每次返回链表头结点，为下一轮递归操作做准备
    return newHead
}

package main

func main() {
	var arr = []int{2, 3, 13, 2, 2, 45, 2, 2}
	result := marjorElement(arr)

	println(result)
}

func marjorElement(arr []int) int {
	var temp = arr[0]
	var mount = 1

	for i := 1; i < len(arr); i++ {
		if temp == arr[i] {
			mount++
		} else {
			mount--
		}

		if mount <= 0 {
			temp = arr[i]
			mount = 1
		}
	}

	return temp
}

func majorityElement(nums []int) int {
    tmp := nums[0]
    var amount = 1

    for i := 1; i < len(nums); i++ {
        if tmp == nums[i] {
            amount++
        }else{
            amount--
        }

        if amount == 0 {
            tmp = nums[i]
            amount = 1
        }
    }

    var elAmount = 0

    for i := 0; i < len(nums); i++ {
        if nums[i] == tmp {
            elAmount++
        }

        if elAmount > len(nums) / 2 {
            return tmp
        }
    }

    return -1
}

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func diameterOfBinaryTree(root *TreeNode) int {
    var max int

    var depth func(*TreeNode) int
    depth = func(n *TreeNode) int {
        // 空节点的深度一定为 0
        if n == nil {
            return 0
        }

        ld := depth(n.Left)
        rd := depth(n.Right)

        // 直径就是左右子树的深度之和
        // 辗转求出最大值
        distance := ld + rd
        if distance > max {
            max = distance
        }

        // 子树的深度，一定是左右子树最大的那个基础上再加 1
        if ld > rd {
            return ld + 1
        }

        return rd + 1
    }

    depth(root)

    return max
}

func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
      lowestCommonAncestor(root.Left, p, q)
      lowestCommonAncestor(root.Right, p, q)
}

/**
 * Definition for TreeNode.
 * type TreeNode struct {
 *     Val int
 *     Left *ListNode
 *     Right *ListNode
 * }
 */
func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
    // 递归结束条件
    if root == nil {
        return nil
    }
    if p == root || q == root {
		return root
	}

    // 求解子问题
    lRes := lowestCommonAncestor(root.Left, p, q)
    rRes := lowestCommonAncestor(root.Right, p, q)

    // 用子问题来还原原问题的解
    if lRes == nil && rRes == nil {
        return nil
    }

    if lRes != nil && rRes != nil {
        return root
    }

    if lRes == nil {
        return rRes
    }

    return lRes
}

/*
	归并排序思路：
	1. 把原数组递归拆分成仅有一个元素的小数组
	2. 不断两两合并
*/
func mergeSort(nums []int, p, r int) {
	if r > p {
		q := (p + r) / 2

		// 把原数组拆分为 [p, q] & [q+1, r]
		mergeSort(nums, p, q)
		mergeSort(nums, q+1, r)
		merge(nums, p, q, r)
	}
}

/*
	merge 操作
	1. 把数组 [p, q] [q+1, r] 合并成一个有序数组
*/
func merge(nums []int, p, q, r int) {
	// 声明左右两个数组，分别存放 [p, q] & [q+1, r]
	// 长度比需要的长度加一，因为要存入哨兵元素
	var leftArr = make([]int, q-p+1+1)
	var rightArr = make([]int, r-q+1)

	// 填充两个数组
	for i := 0; i < len(leftArr)-1; i++ {
		leftArr[i] = nums[i+p]
	}
	leftArr[q-p+1] = math.MaxInt64
	for i := 0; i < len(rightArr)-1; i++ {
		rightArr[i] = nums[i+1+q]
	}
	rightArr[r-q] = math.MaxInt64

	//	有序合并两个数组，并放入到 nums 数组的指定序列内
	var a, b int
	for i := p; i <= r; i++ {
		if leftArr[a] < rightArr[b] {
			nums[i] = leftArr[a]
			a++
		} else {
			nums[i] = rightArr[b]
			b++
		}
	}
}

func findMaxSubArray(nums []int, low, high int) (from, to, sum int) {
	// base case
	if low == high {
		return low, high, nums[low]
	}

	mid := (low + high) / 2

	lLow, lHigh, lSum := findMaxSubArray(nums, low, mid)
	rLow, rHigh, rSum := findMaxSubArray(nums, mid+1, high)
	cLow, cHigh, cSum := findCrossMaxArray(nums, low, mid, high)

	if lSum >= rSum && lSum >= cSum {
		return lLow, lHigh, lSum
	}

	if rSum >= lSum && rSum >= cSum {
		return rLow, rHigh, rSum
	}

	return cLow, cHigh, cSum
}

func findCrossMaxArray(nums []int, low, mid, high int) (l, r, sum int) {
	var lSum int = math.MinInt64
	l = mid
	// mid 元素一定要包含在内
	for i := mid; i >= low; i-- {
		// 这里的 sum 是每次都要加新元素的，因为要是连续子数组
		sum += nums[i]
		if sum > lSum {
			lSum = sum
			l = i
		}
	}

	var rSum int = math.MinInt64
	sum = 0
	for i := mid + 1; i <= high; i++ {
		sum += nums[i]
		if sum > rSum {
			rSum = sum
			r = i
		}
	}

	return l, r, lSum + rSum
}

func maxSubArray(nums []int) int {
	// 数组长度为 0 时直接返回
	if len(nums) == 0 {
		return 0
	}

	// 因为是连续的，所以要有一个 endWithArr[i] 表示以 arr[i] 结尾的最大子数组和
	// 因为已特定数结尾并不一定最大，可能是中间的一段，还需要有一个全局的 all[i] 表示 arr[0:i] 最大子数组和
	var endWith = make([]int, len(nums))
	var all = make([]int, len(nums))
	endWith[0] = nums[0]
	all[0] = nums[0]

	// 依次找出每个子问题（子数组）的最优解
	// 从 nums[0:i] 0<i<len
	for i := 1; i < len(nums); i++ {
		endWith[i] = max(nums[i], nums[i]+endWith[i-1])
		all[i] = max(endWith[i], all[i-1])
	}

	return all[len(nums)-1]
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func lengthOfLIS(nums []int) int {
	// 排除数组长度为 0 & 1 的情况
	if len(nums) == 0 {
		return 0
	}
	if len(nums) == 1 {
		return 1
	}

	// 最大长度，辗转比较，得出最大值
	var maxLen int = 1

	// 最长递增子序列数据记录， LIS[i] 表示截止到 i 元素，最长自增子序列的长度
	var LIS = make([]int, len(nums))
	// 初始化第 0 个元素
	LIS[0] = 1

	// 从第 1 个元素开始
	for i := 1; i < len(nums); i++ {
		// 和 i 之前的每个数都比较一下，如果比它大，就考虑加入它的 LIS
		LIS[i] = 1
		for j := 0; j < i; j++ {
			// 比该数字大，并且加入后 LIS 比以前更长，就加入进入
			if nums[i] > nums[j] && LIS[j]+1 > LIS[i] {
				LIS[i] = LIS[j] + 1
			}
		}

		// 辗转比较出最大值
		if LIS[i] > maxLen {
			maxLen = LIS[i]
		}
	}

	return maxLen
}

package main

import (
	"fmt"
)

func main() {
	var arr = []int{12, 3, 1, 2, 3, 12, 31, 4, 34}
	result := kbig(arr, 2)

	fmt.Println(result)
}

func kbig(arr []int, k int) []int {
	// 此时说明 arr 数组被弃用，不在结果之列
	if k <= 0 {
		return []int{}
	}

	// arr 数组被全部采用，不用再做计算了
	if len(arr) <= k {
		return arr
	}

	setA, setB := partition(arr)

	fmt.Println(setA, setB)

	return append(kbig(setA, k), kbig(setB, k-len(setA))...)
}

func partition(arr []int) (a, b []int) {
	var key = arr[len(arr)-1]

	for i := 0; i < len(arr)-1; i++ {
		if arr[i] > key {
			a = append(a, arr[i])
		} else {
			b = append(b, arr[i])
		}
	}

	/*
		二分法如果分组失败，就会陷入无限递归分组，需要避免这种情形
                例如对 [1, 2, 3, 99] 做拆分，如果不把 99 放入到长度较小的子数组中，则分组将无限循环进行下去
	*/
	if len(a) < len(b) {
		a = append(a, key)
	} else {
		b = append(b, key)
	}
	return
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func kthToLast(head *ListNode, k int) int {
    var slowP = head

    for k > 1 && head.Next != nil {
        head = head.Next
        k--
    }

    for head.Next != nil {
        head = head.Next
        slowP = slowP.Next
    }

    return slowP.Val
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeNthFromEnd(head *ListNode, n int) *ListNode {
    var dummyNode = &ListNode{Next: head}
    var slowP = dummyNode

    for n > 1 {
        head = head.Next
        n--
    }
    
    // for 循环后，slowP 的下一个节点就是倒数第 n 个节点
    for head != nil && head.Next != nil{
        head = head.Next
        slowP = slowP.Next
    }

    // delete nth node
    slowP.Next = slowP.Next.Next

    return dummyNode.Next
}

type Codec struct {
    
}

func Constructor() Codec {
    return Codec{}
}

// Serializes a tree to a single string.
func (this *Codec) serialize(root *TreeNode) string {
    if root == nil {
        return "#"
    }

    lStr := this.serialize(root.Left)
    rStr := this.serialize(root.Right)
    
    // 返回前序遍历字符串
    return fmt.Sprintf("%d,%s,%s", root.Val, lStr, rStr)
}

// Deserializes your encoded data to tree.
func (this *Codec) deserialize(data string) *TreeNode {    
    valStrArr := strings.Split(data, ",")

    return doDeserialize(&valStrArr)
}

func doDeserialize(valsArr *[]string) *TreeNode {
    // 第一个元素即为根元素
    vals := *valsArr
    val := vals[0]
    if val == "#" {
        newArr := vals[1:]
        *valsArr = newArr
        return nil
    }

    valInt, _ := strconv.Atoi(val)

    node := &TreeNode{Val: valInt}
    
    // 去除已经被使用的元素
    newArr := vals[1:]
    *valsArr = newArr
    // 前一部分属于左子树
    node.Left = doDeserialize(valsArr)
    
    // 后一部分属于右子树
    node.Right = doDeserialize(valsArr)

    return node
}

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func findDuplicateSubtrees(root *TreeNode) []*TreeNode {
    var res = []*TreeNode{}
    if root == nil {
        return res
    }

    var memo = make(map[string]int)
    recordSubtree(root, memo, &res)

    return res
}


func recordSubtree(n *TreeNode, memo map[string]int, res *[]*TreeNode) string{
    if n == nil {
        return "#"
    }

    lStr := recordSubtree(n.Left, memo, res)
    rStr := recordSubtree(n.Right, memo, res)
    treeStr := fmt.Sprintf("%s,%s,%d", lStr, rStr, n.Val)

    if  _, ok := memo[treeStr]; !ok {
        memo[treeStr] = 1
    }else {
        if memo[treeStr] == 1 {
            *res = append(*res, n)
            memo[treeStr]++
        }
    }

    return treeStr
}

func maxHeapify(originData, indexArr []int, i int) {
	var largest = i
	l, r := left(i), right(i)
	heapsize := len(indexArr)

	if l < heapsize && originData[indexArr[l]] > originData[indexArr[largest]] {
		largest = l
	}
	if r < heapsize && originData[indexArr[r]] > originData[indexArr[largest]] {
		largest = r
	}

	if largest != i {
		indexArr[i], indexArr[largest] = indexArr[largest], indexArr[i]
		maxHeapify(originData, indexArr, largest)
	}
}

func buildMaxHeap(originData, indexArr []int) {
	for i := len(indexArr)/2 - 1; i >= 0; i-- {
		maxHeapify(originData, indexArr, i)
	}
}

func maxSlidingWindow(nums []int, k int) []int {
	var res = []int{}

	// 填入窗口初始值
	var windowArr = []int{}
	for i := 0; i < k; i++ {
		windowArr = append(windowArr, i)
	}

	// 构建最大堆
	buildMaxHeap(nums, windowArr)

	// 放入第一个元素
	res = append(res, nums[windowArr[0]])

	for i := k; i < len(nums); i++ {

		// 向堆内插入新元素
		windowArr = append(windowArr, i)
		elIndex := len(windowArr) - 1

		// 如果比其父节点值大，那就替换其父节点，保持最大堆性质
		for elIndex >= 0 && nums[windowArr[parent(elIndex)]] < nums[windowArr[elIndex]] {
			windowArr[parent(elIndex)], windowArr[elIndex] = windowArr[elIndex], windowArr[parent(elIndex)]
			elIndex = parent(elIndex)
		}

		// 从第 0 个元素开始，剔除不在窗口内的元素，直到最大值属于当前窗口
		for windowArr[0] <= i-k {
			windowArr[0], windowArr[len(windowArr)-1] = windowArr[len(windowArr)-1], windowArr[0]
			windowArr = windowArr[0 : len(windowArr)-1]

			// maxHeapfiy 保持最大堆的性质
			maxHeapify(nums, windowArr, 0)
		}

		res = append(res, nums[windowArr[0]])
	}

	return res
}

func parent(i int) int {
	return (i - 1) / 2
}
func left(i int) int {
	return (i+1)*2 - 1
}
func right(i int) int {
	return (i + 1) * 2
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func isPalindrome(head *ListNode) bool {
    // 处理极端空链表情况
    if head == nil {
        return true
    }
    
    // 记录下 head 指针
    var firstNode = head
    
    // 快慢指针找中点
    var fast, slow *ListNode = head, head
	for fast.Next != nil {
		if fast.Next.Next != nil {
			fast = fast.Next.Next
			slow = slow.Next
		} else {
			// 链表长度为偶数
			break
		}
	}
    
    // 慢指针之后开始反转
    tailNode := reverse(slow.Next)
    
    
    // 比对是否是回文
    var allSame bool = true
	for firstNode != nil && tailNode != nil {
		if firstNode.Val != tailNode.Val {
			allSame = false
			break
		}

		firstNode = firstNode.Next
		tailNode = tailNode.Next
	}

	return allSame
}

func reverse(head *ListNode) *ListNode {
	if head == nil || head.Next == nil {
		return head
	}

	newHead := reverse(head.Next)
	head.Next.Next = head
	head.Next = nil

	return newHead
}

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isValidBST(root *TreeNode) bool {
    return isValidWithContext(root, nil, nil)
}


func isValidWithContext(root, min, max *TreeNode) bool {
    if root == nil {
        return true
    }

    if min != nil && root.Val <= min.Val{
        return false
    }

    if max != nil && root.Val >= max.Val{
        return false
    }

    return isValidWithContext(root.Left, min, root) && isValidWithContext(root.Right, root, max)
}

package main

func main() {
	maxDivisor := gcd(10000004, 400000)

	println(maxDivisor)
}

// 求两个数的最大公约数
func gcd(a, b int) int {
	a, b = order(a, b)
	if a%b == 0 {
		return b
	}

	var r = a % b
	return gcd(b, r)
}

func order(a, b int) (int, int) {
	if a > b {
		return a, b
	}

	return b, a
}

package main

/*
	寻找数组中的最大值和最小值
*/

var arr = []int{90, 23, 4, 23, 5, 4, 234, 6, 65, 47, 89, 89, 6, 56, 0, 8}

func main() {
	max, min := findMaxAndMin(arr)

	println(max, min)
}

func findMaxAndMin(arr []int) (max, min int) {
	// empty input
	if len(arr) == 0 {
		return 0, 0
	}

	// only has one element
	if len(arr) <= 1 {
		return arr[0], arr[0]
	}

	max, min = compare(arr[0], arr[1])

	for i := 2; i < len(arr); i += 2 {
		if i+1 < len(arr) {
			relativeMax, relativeMin := compare(arr[i], arr[i+1])
			max, _ = compare(max, relativeMax)
			_, min = compare(min, relativeMin)
		} else {
			lastEl := arr[i]
			max, _ = compare(max, lastEl)
			_, min = compare(min, lastEl)
		}
	}

	return
}

func compare(a, b int) (max, min int) {
	if a > b {
		return a, b
	} else {
		return b, a
	}
}

func lengthOfLongestSubstring(s string) int {
    if len(s) == 0 {
        return 0
    }
    var maxLen int = 1

    // 定义左、右两个指针
    var left, right int

    // 记录当前窗口内的内容
    var window = make(map[byte]int)
    window[s[0]] = 1


    for right < len(s)-1 {
        // 右游标一直走到尽头
        right++
        window[s[right]]++

        // 不再满足条件
        for window[s[right]] > 1 {
            // 左游标向右移动
            window[s[left]]--
            left++
        }

        // 辗转求出符合条件的最大长度
        if right - left + 1 > maxLen {
            maxLen = right - left + 1
        }
    }

    return maxLen
}

func longestCommonSubStr(a, b string) string {
	var maxLen int

	// 初始化 dp 二维数组
	// 确定了二维数组的长度和每个元素的长度，基础值为 0
	var dp = make([][]int, len(a)+1)
	for i := range dp {
		dp[i] = make([]int, len(b)+1)
	}

	var endAt int

	// 遍历 a 的每一个字符(纵坐标)
	for i := 0; i < len(a); i++ {
		// 遍历 b 的每一个字符（横坐标）
		for j := 0; j < len(b); j++ {
            
			if a[i] == b[j] {
			    // 公共子串在二维数组上的表现为连续的并且
			    // 斜率为 1 的对角线
				dp[i+1][j+1] = dp[i][j] + 1

				if dp[i+1][j+1] > maxLen {
					endAt = i
					maxLen = dp[i+1][j+1]
				}
			}

		}
	}

	return a[endAt-maxLen+1 : endAt+1]
}

func longestCommonSubsequence(str1, str2 string) int {
	var maxLen int

	m, n := len(str1), len(str2)

	// 构建二维数组
	var dp = make([][]int, m+1)
	for i := range dp {
		dp[i] = make([]int, n+1)
	}

	// str1 作为纵坐标
	for i := 0; i < m; i++ {
		// str2 作为横坐标
		for j := 0; j < n; j++ {
			if str1[i] == str2[j] {
				dp[i+1][j+1] = dp[i][j] + 1
			} else {
				dp[i+1][j+1] = max(dp[i+1][j], dp[i][j+1])
			}

			if dp[i+1][j+1] > maxLen {
				maxLen = dp[i+1][j+1]
			}
		}
	}

	return maxLen
}

func max(a, b int) int {
	if a > b {
		return a
	}

	return b
}

package main

import "fmt"

func main() {
	var arr = []int{-8, -4, -3, 0, 1, 2, 4, 5, 8, 9}
	result := twoSum(arr, 10)

	fmt.Println(result)
}

func twoSum(arr []int, k int) [][]int {
	var result = [][]int{}

	var prePos, endPos = 0, len(arr) - 1

	for prePos < endPos {
		sum := arr[prePos] + arr[endPos]

		if sum == k {
			item := []int{arr[prePos], arr[endPos]}
			result = append(result, item)
			// 当找到满足条件的值后，前置下标加一
			// 查询继续向下走
			prePos++
		} else {
			if sum < k {
			    // 和小于 k，则前置下标向后移动
				prePos++
			} else {
			    // 和大于 k, 则后置下标向前移动
				endPos--
			}
		}
	}

	return result
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */


func reverseKGroup(head *ListNode, k int) *ListNode {
    if head == nil {
		return head
	}

	// 找出区间段
	startNode := head
	var endNode *ListNode = head
	
	// 因为 k 接下来还要用它，所以要定义新的变量
	var i = k
	for i > 0 {
		i--
		if endNode == nil {
			return head
		}
		endNode = endNode.Next
	}

	// 递归执行反转，从 startNode 开始，到 endNode 结束，左开右闭
	newHead := reverse(startNode, endNode)

	// 反转下一轮
	startNode.Next = reverseKGroup(endNode, k)
	return newHead

}

// 反转从 a 到 b 的元素
func reverse(a, b *ListNode) *ListNode {
	var pre, cur, next *ListNode

	pre = nil
	cur = a
	next = a

	for cur != b {
		next = cur.Next
		cur.Next = pre
		pre = cur
		cur = next
	}

	return pre
}

func subarraySum(nums []int, k int) int {
    var res int

    // 构建前缀数组
    var preArr = make([]int, len(nums)+1)
    preArr[0] = 0
    for i := 0; i < len(nums); i++ {
        preArr[i+1] = preArr[i]+nums[i]
    }

    for i := 1; i < len(preArr); i++ {
        for j := 0; j < i; j++ {
            if preArr[i] - preArr[j] == k{
                res++
            }
        }
    }

    return res
}

func subarraySum(nums []int, k int) int {
    var res int

    var sumi int
    var hash = make(map[int]int)
    
    // 便于求解从第 0 位到元素本身的和
    hash[0] = 1
    for i := 0; i < len(nums); i++ {
        sumi += nums[i]
        // 要找的元素
        sumj := sumi-k
        if count, ok := hash[sumj]; ok {
            res += count
        }
        
        // 元素本身加入到 map
        hash[sumi] = hash[sumi]+1
    }


    return res
}

func smallestK(arr []int, k int) []int {
    // 本质上是一个减缩版本的 heap sort
	var res = make([]int, k)
	
	// 针对整个数组构建最大堆
	buildMinHeap(arr)

	var heapSize = len(arr)
	for i := 0; i < k; i++ {
		res[i] = arr[0]
        
        // 把最大值与最后一个元素交换
		arr[0], arr[heapSize-1] = arr[heapSize-1], arr[0]
		// 缩减堆的大小
		heapSize--
		// 重新保持最小堆性质
		minHeapify(arr, heapSize, 0)
	}

	return res
}

func buildMinHeap(nums []int) {
    // 因为从数组的 n/2+1 后都是叶节点，所以仅需对 [0, n/2] 做 minHeapify 操作，并且是倒序来的
	for i := len(nums) / 2; i >= 0; i-- {
		minHeapify(nums, len(nums), i)
	}
}

// minHeapify 保持最小堆性质
func minHeapify(nums []int, heapSize, i int) {
	var min int = i

	l, r := left(i), right(i)
	if l < heapSize && nums[min] > nums[l] {
		min = l
	}

	if r < heapSize && nums[min] > nums[r] {
		min = r
	}
	if i != min {
	    // 如果左孩子 OR 右孩子比父节点小，交换之
		nums[i], nums[min] = nums[min], nums[i]
		
		// 继续下沉，保持最小堆性质
		minHeapify(nums, heapSize, min)
	}
}

// 工具函数，快速定位到父节点、左孩子、右孩子（index from 0）
func parent(i int) int {
	return (i - 1) / 2
}
func left(i int) int {
	return (i+1)*2 - 1
}
func right(i int) int {
	return (i + 1) * 2
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func swapPairs(head *ListNode) *ListNode {
    var result = &ListNode{0, head}
    tmp := result

    for tmp.Next != nil && tmp.Next.Next != nil {
        // 把两个节点声明出来，不然思维跟不上，都是 next next next
        node1 := tmp.Next
        node2 := tmp.Next.Next
        
        // 和上一轮串起来
        tmp.Next = node2

        // 在链表反转之前，为下轮做准备
        // 下一轮会用到 node1, node2，以及上一轮的尾节点
        // 如果下一轮为 nil 或 奇数个值，也没有关系，正好满足了 “如不足两个则不作操作”
        node1.Next = node2.Next
        
        // 链表反转
        node2.Next = node1

        // 把这轮的尾元素给到下一轮
        tmp = node1
    }

    return result.Next
}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    if l1 == nil {
        return l2
    }

    if l2 == nil {
        return l1
    }

    var lastLoopAddVal int
    var lastLoopNode = &ListNode{}

    var head = lastLoopNode
    for l1 != nil || l2 != nil || lastLoopAddVal != 0 {
        if l1 != nil {
            lastLoopAddVal += l1.Val
            l1 = l1.Next
        }

        if l2 != nil {
            lastLoopAddVal += l2.Val
            l2 = l2.Next
        }

        newNode := &ListNode{Val: lastLoopAddVal%10}
        lastLoopAddVal = lastLoopAddVal/10


        lastLoopNode.Next = newNode
        lastLoopNode = newNode
    }

    return head.Next
}

type LRUCache struct {
	Cap   int
	Cache map[int]*Item
	Link  DLink
}

// 定义带哨兵的双向链表
type DLink struct {
	Nil *Item
}

func newDLink() DLink {
	nilItem := &Item{}
	nilItem.Pre = nilItem
	nilItem.Next = nilItem
	return DLink{Nil: nilItem}
}

func (l DLink) addItem(n *Item) {
	n.Next = l.Nil.Next
	l.Nil.Next.Pre = n

	l.Nil.Next = n
	n.Pre = l.Nil
}
func (l DLink) delItem(n *Item) {
	n.Pre.Next = n.Next
	n.Next.Pre = n.Pre
}

// 定义元素结构
type Item struct {
	Key       int
	Val       int
	Pre, Next *Item
}

func Constructor(capacity int) LRUCache {
	lru := LRUCache{
		Cap:   capacity,
		Link:  newDLink(),
		Cache: make(map[int]*Item),
	}
	return lru
}

func (this *LRUCache) Get(key int) int {
	if item, ok := this.Cache[key]; !ok {
		return -1
	} else {
		this.Link.delItem(item)
		this.Link.addItem(item)
		return item.Val
	}
}

func (this *LRUCache) Put(key int, value int) {
	if item, ok := this.Cache[key]; !ok {
		// 该节点未存在
		newItem := &Item{Key: key, Val: value}
		if this.Cap == len(this.Cache) {
			// 删除过时元素（一定要先删 Map 再删节点，因为要删哪个 cache 是由链表最后一个元素决定的）
			delete(this.Cache, this.Link.Nil.Pre.Key)
			this.Link.delItem(this.Link.Nil.Pre)
		}
		this.Cache[key] = newItem
		this.Link.addItem(newItem)
	} else {
		// 已经存在
		item.Val = value
		this.Link.delItem(item)
		this.Link.addItem(item)
	}
}

func maxSlidingWindowPro(nums []int, k int) []int {
	var res = make([]int, len(nums)-k+1)

	// 装的是元素的 index
	var stack = []int{}
	push := func(i int) {
	    // 移除当前窗口内比 nums[i] 小的数值，在新窗口内，比其小的值，已没有用武之地了
		for len(stack) > 0 && nums[i] > nums[stack[len(stack)-1]] {
			// 移除 stack 上最后一个元素
			stack = stack[0 : len(stack)-1]
		}
		
		// 最后把元素添加到队列的最后一位
		stack = append(stack, i)
	}

	// 前 k 个元素放入 stack 内
	for i := 0; i < k; i++ {
		push(i)
	}

	res[0] = nums[stack[0]]

	for i := k; i < len(nums); i++ {
		push(i)

		// 如果最大元素不在窗口内，则删除掉
		for stack[0] <= i-k {
			stack = stack[1:]
		}

		// 将本轮窗口内的最大值，放入到结果数组中
		res[i-k+1] = nums[stack[0]]
	}

	return res
}

type Node struct {
	Key  int
	Val  int
	Pre  *Node
	Next *Node
}

type LinkedList struct {
	Nil *Node
}

func NewLinkList() LinkedList {
	nilNode := &Node{}
	// 空链表情形，L.nil.next & L.nil.pre 均指向 L.nil
	nilNode.Pre = nilNode
	nilNode.Next = nilNode

	l := LinkedList{
		Nil: nilNode,
	}

	return l
}

func (l LinkedList) DelNode(n *Node) {
        // 代码更加清晰、简洁，无需关心空指针
	n.Pre.Next = n.Next
	n.Next.Pre = n.Pre
}

func (l LinkedList) AddNode(n *Node) {
        // 和头部元素连接
	n.Next = l.Nil.Next
	l.Nil.Next.Pre = n
	
	// 和 Nil 元素连接
	l.Nil.Next = n
	n.Pre = l.Nil
}

func (l LinkedList) Search(key int) *Node {
	var n *Node = l.Nil.Next

	for n != nil && n != l.Nil {
		if n.Key == key {
			break
		}

		n = n.Next
	}

	return n
}