周四晚上，一个人在冰冷的办公室加班，外面呼啸的秋风，肆虐而行。

股票最近在下跌，比特币最近在跌。资产的市值不断的在下降

虽然计划在下降中继续加仓，可现在仍然抵不过恐惧的内心。

工作进展缓慢，分红功能还在测试网测试

今天开会，没有发言，我知道自己该发言，可就是张不开嘴。

有点自闭的倾向了

每次心情不好，就严重的怀疑自己整个人。自卑的难受，自闭的难受。

有点想哭，可又好像哭不出来。

用力哭，甚至有点想苦笑。

自己定义的每天996日子，像个苦行僧一样，煎熬。

体会不到工作的快乐、成就和荣誉感

希望这种心情早点过去，也希望这种日子早点过去

今天聊到关于工作中别人给予帮助的事，自己没有那样的经历，不够幸运。

内心更多的是嫉妒和失望。

除了自己要更加努力优秀之外，自己还有其他选择么？

多付出一些时间、多付出一些精力、比别人多努力一些，才能更加优秀

链表反转-基础篇
题目
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例：
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
考察要点

• 链表的熟悉程度
• 迭代法和递归法两种实现思路

• 迭代法：

  • 优点：效率高，运行时间只随循环的增加而增加；无额外开销；
  • 缺点：代码难理解；代码不如递归代码简洁；

• 递归法：

  • 优点：用有限的循环语句实现无限集合；代码易读；大问题转化成小问题，减少代码量；
  • 缺点：递归不断调用函数，浪费空间；容易造成堆栈溢出。
• 复杂度：时间复杂度O(N)，空间复杂度O(1)

解法1：迭代法
通过双指针，遍历 head 指针，通过中间变量，逐步指向新的 head 节点，完成链表反转

type ListNode struct {
   Val  int
   Next *ListNode
}

func reverseList(head *ListNode) *ListNode {
   if head == nil {
      return nil
   }
   var newHead *ListNode
   for head != nil {
      node := head.Next
      head.Next = newHead
      newHead = head
      head = node
   }
   return newHead
}

解法2：递归法
整体思路是递归到最后一个节点，这个节点就是链表反转后的头节点，这里记作 ret，最终只需要返回这个 ret 指针即可，剩余的都是对中间数据进行指针反转。

type ListNode struct {
   Val  int
   Next *ListNode
}

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

   ret := reverseList(head.Next)
   head.Next.Next = head
   head.Next = nil
   return ret
}

链表反转-进阶篇
题目
反转从位置 m 到 n 的链表. 请使用一趟扫描完成反转.
示例：
输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL
考察要点

• m和n之间的反转与基础篇一样
• 在m的边界处理，m-1的next指向n；m的next指向n+1

• 在n的边界处理，n的next指向n-1；
  解法1:迭代法

  func reverseBetween(head *ListNode, m int, n int) *ListNode {
    dummy := ListNode{Val: 0}
    dummy.Next = head
    node := &dummy
    for i := 1; i < m; i++ {
        node = node.Next
    }
    pre := node
    curr := node.Next
    tail := curr
    for i := m; i <= n; i++ {
        nxt := curr.Next
        curr.Next = pre
        pre = curr
        curr = nxt
    }
    tail.Next = curr
    node.Next = pre
    return dummy.Next 
  }

  解法2:递归法

  type ListNode struct {
   Val  int
   Next *ListNode
  }
  
  func rev(root *ListNode) *ListNode {
   if root == nil || root.Next == nil {
      return root
   }
  
   last := rev(root.Next)
   root.Next.Next = root
   root.Next = nil
  
   return last
  }
  func reverseBetween(head *ListNode, left int, right int) *ListNode {
   d := &ListNode{
      Val:  0,
      Next: head,
   }
   h := d
   tmp := head
  
   var leftNode *ListNode
   var rightNode *ListNode
   var prevNode *ListNode
   var nextNode *ListNode
   foundLeft := false
   foundRight := false
   count := 1
   _ = rightNode
   for tmp != nil {
      if foundLeft && foundRight {
         break
      }
  
      if count == left {
         leftNode = d.Next
         d.Next = nil
         prevNode = d
         foundLeft = true
      }
  
      if count == right {
         rightNode = tmp
         nextNode = tmp.Next
         tmp.Next = nil
         foundRight = true
      }
  
      count++
      d = tmp
      tmp = tmp.Next
   }
  
   last := rev(leftNode)
   prevNode.Next = last
   leftNode.Next = nextNode
   return h.Next
  }

键盘装书包里，莫名其妙掏出来之后，win键失灵，已经遇到很多次了

记录下原因吧

上锁：fn+左win
解锁：fn+ 右win

在别人绝望时加仓，在别人疯狂时清仓。

巴菲特说别人恐惧我贪婪，别人贪婪我恐惧。这句话值得深思。

什么时候别人才会恐惧？刚开始下跌或者瀑布下跌，别人还未必恐惧，甚至有点兴奋，觉得这是抄底的时机，因为牛市顶峰刚出站，他们还不相信熊市来临，更相信这是一次普通回调。群里，网上到处都是调侃，加仓的声音，很热闹。

然后随着时间推移，过了半年甚至一年，在持续下跌或者反复横盘震荡过程中，终于很多人没了耐心，开始离场，网上也没有讨论的兴致。

这时候，如果出现一次大的下跌，很多人都是绝望的，这次抄底，绝望中的抄底就是，在别人恐惧中我加仓。

别人贪婪我恐惧，当任何人都觉得可以随便挣钱，身边莫名其妙多了很多人参与，大家盲目乐观，一堆狗屁不值的东西飞上天，这时候就可以考虑离场了，不吃最后一段行情。

我觉着完整的牛市，一波行情能吃到70%就不错了。

按照缠中说禅周线看图，底部中枢买入，顶部第二个中枢离场。不要太贪婪，吃最后一段行情，要不没法全身而退，这是血淋淋的教训。