输入：
["CQueue","appendTail","deleteHead","deleteHead"]
[[],[3],[],[]]
输出：[null,null,3,-1]

输入：
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]

/**
 * outStack 不为空：弹出元素
 * outStack 为空：将 inStack 元素依次弹出，放入到 outStack 中（在数据转移过程中，顺序已经从后入先出变成了先入先出）
 */
var CQueue = function() {
    this.inStack = []
    this.outStack = []
};

/**
 * @param {number} value
 * @return {void}
 */
CQueue.prototype.appendTail = function(value) {
    this.inStack.push(value)
};

/**
 * @return {number}
 */
CQueue.prototype.deleteHead = function() {
    const { inStack, outStack} = this

    // 如果要出的栈内没有元素，那么直接先把入栈内的元素，添加到出栈。然后再删除
    if(!outStack.length) {
        while(inStack.length) {
            outStack.push(inStack.pop())
        }
    }

    return outStack.pop() || -1
};

               5
              / \
             4   8
            /   / \
           11  13  4
          /  \      \
         7    2      1

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} sum
 * @return {boolean}
 */
var hasPathSum = function(root, sum) {
  // 根节点为空
  if (root === null) return false;

  // 只有一个根节点，主要是这里的两个判断
  if (root.left === null && root.right === null && root.val === sum) return true;

  // 把总和减去当前值递归下去
  const left = hasPathSum(root.left, sum - root.val);
  const right = hasPathSum(root.right, sum - root.val);
  return left || right;
};

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} sum
 * @return {boolean}
 */
var hasPathSum = function(root, sum) {
  if (root === null) return false;
  let stack = [root];
  let sumStack = [sum - root.val];
  while (stack.length > 0) {
    let node = stack.pop();
    let curSum = sumStack.pop();
    if (node.left === null && node.right === null && curSum === 0) {
      return true;
    }
    if (node.right !== null) {
      stack.push(node.right);
      sumStack.push(curSum - node.right.val);
    }
    if (node.left !== null) {
      stack.push(node.left);
      sumStack.push(curSum - node.left.val);
    }
  }
  return false;
};

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} k
 * @return {ListNode}
 */

 var getKthFromEnd = function(head, k) {
    if(!head || !k) return null

    let front = head
    let behind = head
    let index = 1

    while(front.next) {
        index++;

        front = front.next
        if(index > k) {
            behind = behind.next
        }
    }

    return (k <= index) && behind
};

describe('加法函数测试', () => {
  before(() => {// 在本区块的所有测试用例之前执行
  });

  after(() => {// 在本区块的所有测试用例之后执行
  });

  beforeEach(() => {// 在本区块的每个测试用例之前执行
  });

  afterEach(() => {// 在本区块的每个测试用例之后执行
  });


  it('1加1应该等于2', () => {
     expect(add(1, 1)).toBe(2);
  });
  it('2加2应该等于4', () => {
      expect(add(2, 2)).toBe(42);
  });
});

/* eslint-env jest */
import { shallow } from 'enzyme';
import React from 'react';
import { OrderManage } from '../../components/purchaser/OrderManege';

const setup = ({ ...props }) => {
  const wrapper = shallow(<OrderManage {...props} />);
  return {
    props,
    wrapper,
  };
};
describe('OrderManage', () => {
  it('role is operator', () => {
    const { wrapper } = setup({
      role: 'operator',
      isFetching: true,
      fetchOrdersByStatuses: () => {}, // 直接设为空函数　　　 getData: jest.fn(), // Jest 提供的mock 函数
    });
    const params = {
      node: {
        id: 2,
      },
    };
    expect(wrapper.instance().handlePageChange(1));
    expect(wrapper.instance().OrderManagementLink(params));
    expect(wrapper.find('.loader')).toHaveLength(1);
    expect(wrapper.find('.order-simpleGrid')).toHaveLength(0);
    expect(wrapper.type()).toEqual('div');
  });
});

<Input value={value} onChange={e => this.handleChange(e)}/>

it('can save value and cancel', () => {
   const value = 'edit'
   const {wrapper, props} = setup({
      editable: true
   });
   wrapper.find('input').simulate('change', {target: {value}});
   wrapper.setProps({status: 'save'});
   expect(props.onChange).toBeCalledWith(value);
})

wrapper.find('button').simulate('click')；

wrapper.find('input').simulate('keyup')；

expect(props.onClick).toBeCalled()；// onClick方法被调用

expect(props.onClick).not.toBeCalled() // onClick方法没被调用

 /* eslint-env jest */
import { shallow } from 'enzyme';
import sinon from 'sinon';
import { App } from '../App';


it('componentWillMount', () => {
  sinon.spy(App.prototype, 'componentWillMount');
  shallow(<App />);
  expect(App.prototype.componentWillMount.calledOnce).toBeTruthy();
});

it('componentWillReceiveProps', () => {
  let wrapper = shallow(<App role={''} />);
  sinon.spy(App.prototype, 'componentWillReceiveProps')
  wrapper.setProps({
    role: 'admin'
  });
 expect(App.prototype.componentWillReceiveProps.calledOnce).toBeTruthy();
})

import renderer from 'react-test-renderer'

it('App -- snapshot', () => {
   const renderedValue = renderer.create(<App />).toJSON()
   expect(renderedValue).toMatchSnapshot()
})

export class Card extends React.Component {
  constructor (props) {
    super(props)

    this.cardType = 'initCard'
  }

  changeCardType (cardType) {
    this.cardType = cardType
  }
  ...
}

it('changeCardType', () => {
  let component = shallow(<Card />)
  expect(component.instance().cardType).toBe('initCard')
  component.instance().changeCardType('testCard')
  expect(component.instance().cardType).toBe('testCard')
})

  const findRepeatNumber = (nums) => {
    // 先排序
    nums.sort((a, b) => a - b)

    for(let i = 0, len = nums.length; i < len-1; i++) {
      // 比较前后的值是否相同
      if(nums[i] === nums[i+1]) {
        return nums[i]
      }
    }
  }

const findRepeatNumber = (nums) => {
  // 用来存放是否遍历过的数组的项
  const obj = {}
  for(let i = 0; i < nums.length; i++) {
    // 数组的项是否已经是对象obj的键值了
    if(obj[nums[i]]) {
      return nums[i]
    } else {
      obj[nums[i]] = 1
    }
  }
}

const findRepeatNumber = (nums) => {
  for(let i = 0; i < nums.length; i++) {
    while(nums[i] !== i) {
      if(nums[i] === nums[nums[i]]) {
        return nums[i]
      }

      // 交换数组两个位置上的项，这里是i 和 num[i] 交换
      let temp= nums[i]
      nums[i] = nums[temp]
      nums[temp] = temp
    }
  }
}

const cuttingRope = function(num) {
    if(num < 2) return 0
    if(num === 2) return 1
    if(num === 3) return 2

    const products = []
    products[0] = 0
    products[1] = 1
    products[2] = 2
    products[3] = 3

    let max = 0
    for(let i = 4; i <= num; ++i) {
        max = 0;

        // 循环当前可以切段的所有结果，遍历一一比较求最大乘积
        for(let j = 1; j <= i/2; ++j) {
            let product = products[j] * products[i - j]

            if(max < product) {
                max = product;
                products[i] = max
            }
        }
    }

    max = products[num]

    return max
};

const cuttingRope = function(num) {
    if (n === 2) return 1;
    if (n === 3) return 2;

    const a = Math.floor(n / 3);

    const b = n % 3;

    // n是3的倍数
    // 绳子刚好是3的倍数
    if (b === 0) return Math.pow(3, a);

    // 当剩下的绳子为4时
    if (b === 1) return Math.pow(3, a - 1) * 4;

    // 当剩下的绳子为2时
    return Math.pow(3, a) * 2;
};

<style>
    .left {
        float: left;
        width: 500px;
        height: 200px;
        background: red;
    }

    .right {
        height: 200px;
        background: #FF6633;
        overflow: auto;
    }
</style>

.parent {
    display: flex;
}
.left {
    width: 200px;   /** 或者使用flex-basis: 200px; **/
    height: 200px;
    background: red;
}
.right {
    flex: 1;
    height: 200px;
    background: blue;
}

.left{
    float: left;
    background: red;
    width: 500px;
    height: 500px;
}
.right{
    background: #FF6633;
    margin-left: 500px;
    height: 200px;
}

.parent{
    position: relative;
}
.left {
    position: absolute;
    background: red;
    width: 500px;
    height: 200px;
    left: 0;
    top: 0;
}
.right {
    margin-left: 500px;
    background: #FF6633;
    height: 200px;
}

var Event=new Vue();
Event.$emit(事件名,数据);
Event.$on(事件名,data => {});

function quickSort(arr) {
    if(arr.length <= 1) return arr
    
    let cur = arr.splice(0, 1)
    let leftArr = [];
    let rightArr = [];
    
    for(let i = 0, len = arr.length; i < len; i++) {
        if(arr[i] < cur) {
            leftArr.push(arr[i])
        } else {
            rightArr.push(arr[i])
        }
    }
    
    return quickSort(leftArr).concat(cur, quickSort(rightArr))
}

// 以640的设计稿为例最终的设置html font-size代码如下，布局时拿设计稿标注的尺寸除以100，就是rem的值，相当简单啊

var deviceWidth = document.documentElement.clientWidth;
if(deviceWidth > 640) deviceWidth = 640;
document.documentElement.style.fontSize = deviceWidth / 6.4 + 'px';

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

   3
   / \
  9  20
     / \
   15   7

       1
      / \
     2   2
    / \
   3  3
  / \
 4   4

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isBalanced = function(root) {
    function balanced(node) {
      if (!node) {
        return 0;
      }
      const left = balanced(node.left);
      const right = balanced(node.right);
      if (left == -1 || right == -1 || Math.abs(left - right) > 1) {
        return -1;
      }
      return Math.max(left, right) + 1;
    }

    return balanced(root) !== -1
};

ssh root@182.92.237.90

ssh plane

yum install git

git config --global user.name plane
git config --global user.email 18211495117@163.com

$ ssh -T git@github.com
git@github.com: Permission denied (publickey).

$ cat /etc/centos-release
CentOS Linux release 8.1.1911 (Core)

$ free -h
total        used        free      shared  buff/cache   available
Mem:          3.6Gi       164Mi       2.9Gi       0.0Ki       483Mi       3.2Gi
Swap:            0B          0B          0B

# 查看 cpu 的核心数
$ cat /proc/cpuinfo

# 查看
$ top

$ htop

$ df -h
文件系统        容量  已用  可用 已用% 挂载点
devtmpfs        1.8G     0  1.8G    0% /dev
tmpfs           1.8G     0  1.8G    0% /dev/shm
tmpfs           1.8G  464K  1.8G    1% /run
tmpfs           1.8G     0  1.8G    0% /sys/fs/cgroup
/dev/vda1        40G  2.7G   38G    7% /
tmpfs           364M     0  364M    0% /run/user/0

$ uptime
23:28:05 up 42 min,  2 users,  load average: 0.00, 0.00, 0.00

$ who -u
root     pts/0        2020-08-29 22:46  旧�       1220 (119.123.224.176)
root     pts/1        2020-08-29 23:09  旧�       1316 (119.123.224.176)

yum install -y yum-utils device-mapper-persistent-data lvm2

# 安装 docker 官方的镜像源
$ yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 如果在国内，安装阿里云的镜像
$ yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 安装 docker
$ yum install -y docker-ce

# 安装指定版本号的 docker，以下是 k8s 官方推荐的 docker 版本号 (此时，k8s 的版本号在 v1.16)
$ yum install -y docker-ce-18.06.2.ce

$ systemctl enable docker
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.

$ systemctl start docker

错误：
 问题: package docker-ce-3:19.03.12-3.el7.x86_64 requires containerd.io >= 1.2.2-3, but none of the providers can be installed

yum install https://download.docker.com/linux/fedora/30/x86_64/stable/Packages/containerd.io-1.2.6-3.3.fc30.x86_64.rpm

$ docker --version
Docker version 18.06.2-ce, build 6d37f41

# 查看更详细的版本号信息
$ docker version

# 查看docker的详细配置信息
$ docker info

sudo curl -L "https://get.daocloud.io/docker/compose/releases/download/1.24.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

docker-compose version

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

var threeSum = function(nums) {
    let res = []
    for (let i = 0; i < nums.length - 2; i++) {
        for (let j = i + 1; j < nums.length - 1; j++) {
            for (let k = j + 1; k < nums.length; k++) {
                if (nums[i] + nums[j] + nums[k] === 0) {
                    res.push([nums[i], nums[j], nums[k]])
                }
            }
        }
    }
    return res
}

var threeSum = function(nums) {
        let res = []
        let hash = {}
        for (let i = 0; i < nums.length - 2; i++) {
            for (let j = i + 1; j < nums.length - 1; j++) {
                if (hash[nums[j]] !== undefined) {
                    res.push([nums[j]].concat(hash[nums[j]]))
                    hash[nums[j]] = undefined
                } else {
                    let mark = 0 - nums[i] - nums[j]
                    hash[mark] = [nums[i], nums[j]]
                }
            }
        }
        return res
}

输入：s = "We are happy."
输出："We%20are%20happy."

0 <= s 的长度 <= 10000

/**
 * @param {string} s
 * @return {string}
 */
var replaceSpace = function(s) {
    return s.replace(/\s /g, '%20')
};

var replaceSpace = function(s) {
    return s.split(/\s/).join('%20')    
};

输入: "()"
输出: true

输入: "()[]{}"
输出: true

输入: "(]"
输出: false

输入: "([)]"
输出: false

输入: "{[]}"
输出: true

/**
 * @param {string} s
 * @return {boolean}
 */
// 可以使用栈 
var isValid = function(s) {
    const map = {
        "(": ")",
        "[": "]",
        "{": "}"
    }

    let leftArr = []

    for(let ch of s) {
        if(map[ch]) {
            leftArr.push(ch);   // 为左括号时，顺序保存
        } else {
            // 右括号时，与数组末尾匹配
            if(ch != map[leftArr.pop()]) {
                return false
            }
        }
    }

    return !leftArr.length  // 防止全部为左括号或有多余的左括号
};

var isValid = function (s) {
    while (s.length) {
        var temp = s;

        // 把有效的括号抵消
        s = s.replace('()', '').replace('[]', '').replace('{}', '');

        // 判断抵消前和抵消后是否相等，相等则证明抵消不了有效括号，返回 false
        if (s == temp) return false
    }
    return true;
};

作者：rhinoc
链接：https://leetcode-cn.com/problems/valid-parentheses/solution/javascript-you-xiao-de-gua-hao-by-rhinoc/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

输入：[3,4,5,1,2]
输出：1

输入：[2,2,2,0,1]
输出：0

var minArray = function(numbers) {
  if(!numbers || numbers.length <= 0) return 0

  let left = 0
  let right = numbers.length - 1

  while(left < right) {
    let indexMid = Math.floor((left + right)/2)

    // 数组或者子数组有序的时候
    if(numbers[left] < numbers[right]) {
        return numbers[left]
    }

    // 左子数组有序，最小值在右边
    // 那么mid肯定不可能是最小值（因为numbers[mid]大于numbers[left]）
    if(numbers[left] < numbers[indexMid]) {
      left = indexMid + 1
    } else if(numbers[indexMid] < numbers[right]) {
      // 右子数组有序，最小值在左边
      // 这里right=mid因为最小值可能就是numbers[mid]
      right = indexMid;
    } else {
        // 无法判断
        ++left
    }
  }

  return numbers[left]
};

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]

给定 target = 5，返回 true。
给定 target = 20，返回 false。

var findNumberIn2DArray = function(matrix, target) {
    if(!matrix) return false

    // 行
    let rows = matrix.length
    // 列
    let cols = matrix[0].length

    if(rows >= 0 && cols >= 0) {
        // 取右上角的值做比较
        let row = 0;
        let col = cols - 1;

        while(row < rows && col >= 0) {
            if(matrix[row][col] === target) {
                return true
            } else if(matrix[row][col] > target) {
                --col;
            } else {
                ++row;
            }
        }
        
    }

    return false
};

给定 matrix = 
[
  [1,2,3],
  [4,5,6],
  [7,8,9]
],

[
  [7,4,1],
  [8,5,2],
  [9,6,3]
]

[
  [ 5, 1, 9,11],
  [ 2, 4, 8,10],
  [13, 3, 6, 7],
  [15,14,12,16]
]

[
  [15,13, 2, 5],
  [14, 3, 4, 1],
  [12, 6, 8, 9],
  [16, 7,10,11]
]

[
  [1,2,3],
  [4,5,6],
  [7,8,9]
],

[
  [1,4,7],
  [2,5,8],
  [3,6,9]
],

[
  [7,4,1],
  [8,5,2],
  [9,6,3]
]

const rotate = (matrix) =>{
    for(let i = 0; i < matrix.length; i++){
        for (let j = i; j < matrix[i].length; j++){
            [matrix[i][j],matrix[j][i]] = [matrix[j][i],matrix[i][j]]
        }
    }
    matrix.forEach(row=> row.reverse())
};

function indexOf(str, a, start = 0) {
   if(start<0) start+=str.length;
   if(start>=str.length) return -1;

   const reg = new RegExp(`${a}`, 'gi')
   reg.lastIndex = start
   const result = reg.exec(str)
   return result ? result.index : -1
}

function indexOf(str, a, start = 0) {
    if(start<0) start+=str.length;
    if(start>=str.length) return -1;

    for (let i = start, len = str.length; i < len; i++) {
        if (str[i] == a) return i;
    }
    return -1;
}

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

var twoSum = function(nums, target) {
    for(let i = 0, len = nums.length; i< len; i++) {
        let index = nums.indexOf(target - nums[i])
        if(index > -1 && index !== i) {
            return [i, index]
        }
    }
};

var twoSum = function(nums, target) {
    let obj = {};
    for(let i = 0, len = nums.length; i< len; i++) {
        let num = target - nums[i]
        
        if(obj.hasOwnProperty(num)) {
            return [i, obj[num]]
        }
        obj[nums[i]] = i
    }
};

F(0) = 0,   F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.

// 递归
const fib = (n) => {
    if(n === 0) return 0

    if(n === 1) return 1

    return fib(n - 1) + fib(n - 2)
}

f(9) = f(8) + f(7)
那么
f(8) = f(7) + f(6)

// 在动态规划的一种做法中，可以借助“备忘录”来实现结果的缓存，避免重复计算
const fib = (n) => {
    // 备忘录
    const cache = {
        0: 0,
        1: 1
    };
    return Fibonacci(n);

    function Fibonacci(n) {
        if (cache[n] !== undefined) {
            return cache[n];
        }

        cache[n] = Fibonacci(n - 1) + Fibonacci(n - 2);
        return cache[n];
    }
};

const fib = (n) => {
    // 备忘录
    const cache = {
        0: 0,
        1: 1
    };

    if(n < 2) {
        return cache[n]
    }

    let fibNone = 1
    let fibNtwo = 0
    let fibN = 0

    for(let i = 2; i <= n; i++) {
        fibN = fibNone + fibNtwo

        fibNtwo = fibNone
        fibNone = fibN
    }

    return fibN
};

    3
   / \
  9  20
    /  \
   15   7

[
  [15,7],
  [9,20],
  [3]
]

var levelOrderBottom = function(root) {
    if(!root) return []
    let res = [], 
        queue = [root]
    while(queue.length) {
        let curr = [],
            temp = []
        while(queue.length) {
            let node = queue.shift()
            curr.push(node.val)
            if(node.left) temp.push(node.left)
            if(node.right) temp.push(node.right)
        }
        res.push(curr)
        queue = temp
    }
    return res.reverse()
};

var levelOrderBottom = function(root) {
    const res = []
    var dep = function (node, depth){
        if(!node) return
        res[depth] = res[depth]||[]
        res[depth].push(node.val)
        dep(node.left, depth + 1)
        dep(node.right, depth + 1)
    }
    dep(root, 0)
    return res.reverse()   
};

var levelOrderBottom = function(root) {
    const result = []
    dep(root, 0)
    function dep(root,num){
        if(!root) return
        result[num] = result[num]||[]
        result[num].push(root.val)
        dep(root.left, num+1)
        dep(root.right, num+1)
    }
    return result.reverse()
    
};

function ListNode(val) {
    this.val = val;
    this.next = null;
}

const printReverseListNode = (head) => {
    if (!head) return []

    // 栈用来存放已经遍历过的数组
    const stack = []
    let curNode = head

    while(curNode) {
        stack.push(curNode.val)

        curNode = curNode.next
    }

    return stack.reverse()
}

const printReverseListNode = (head) => {
    if (!head) return []
    const stack =[]

    const getReverseListNode = (head) => {
        if(head) {
            if(head.next !== null) {
                printReverseListNode(head.next)
            }
            stack.push(head.val)
        }
    }

    getReverseListNode(head)
    return stack
}

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
/**
 * 迭代
 */
var reverseList = function(head) {
    if (!head || !head.next) return head;

    let cur = head;
    let pre = null;

    while(head && head.next) {
        // 获取当前节点的下一个节点
        pre = head.next;

        // 使当前节点的下一个节点指向，下下个节点即：head.next = head.next.next
        head.next = pre.next;

        // 反转节点。使下一个节点的下个节点指向当前节点
        pre.next = cur;

        // 使下一个节点赋值为当前节点
        cur = pre;
    }

    return cur;
};

/**
 * 递归
 */
var reverseList = function(head) {
  // 递归结束条件
  if (head === null || head.next === null) {
    return head
  }

  // 递归反转 子链表
  let newReverseList = reverseList(head.next)
  // 获取原来链表的第2个节点newReverseListTail
  let newReverseListTail = head.next
  // 调整原来头结点和第2个节点的指向
  newReverseListTail.next = head
  head.next = null

  // 将调整后的链表返回
  return newReverseList
}

s = "abaccdeff"
返回 "b"

s = "" 
返回 " "

/**
 * @param {string} s
 * @return {character}
 */
const firstUniqChar = (s) => {
  if(!s) return " "

  let list = []
  let map = {}

  for(let i = 0, len = s.length; i < len; i++) {
    map[s[i]] = map[s[i]] === undefined ? 1 : 0
  }

  for(let item in map) {
      if(map[item] === 1) {
          return item
      }
  }

  return  " "
}

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {boolean}
 */
/**
 * 快慢指针
 * slow每次移动一步，fast每次移动两步
 */
var hasCycle = function(head) {
    let slow = head
    let fast = head

    while(slow && fast && fast.next) {
        slow = slow.next
        fast = fast.next.next

        if(slow === fast) {
            return true
        }
    }

    return false
};

/**
 * 哈希表
 */
var hasCycle = function(head) {
    if (!head) return false;

    const map = new Map();
    let node = head;
    map.set(node, true);

    while (node.next) {
        // 判断哈希表是否已经存在链表节点
        if (map.get(node.next)) {
            return true;
        }
        map.set(node.next, true);
        node = node.next;
    }
    // map.clear()
    return false;
};

var findNumberIn2DArray = function(matrix, target) {
    // 多少行
    const rowLength = matrix.length

    if(!rowLength) return false

    // 多少列
    const colLength = matrix[0].length

    if(!colLength) return false

    for(let i = 0; i < rowLength; i++) {
        for(let j = 0; j < colLength; j++) {
            if(matrix[i][j] === target) {
                return true
            }
        }
    }

    return false
};

var findNumberIn2DArray = function(matrix, target) {
    const rowLength = matrix.length
    if(!rowLength) {
        return false
    }

    const colLength = matrix[0].length
    if(!colLength) {
        return false
    }

    let row = 0, col = colLength - 1;

    while(row < rowLength && col >= 0) {
        if(matrix[row][col] === target) {
            // 第一种情况
            return true
        } else if(matrix[row][col] > target) {
            // 第三种情况
            --col
        } else {
            // 第二种情况
            ++row
        }
    }

    return false
};

输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3 

/**
 * @param {number[]} nums
 * @return {number}
 */
// 解法一
let findRepeatNumber = (nums) => {
    nums.sort((a, b) => a - b)

    for(let i = 0, len = nums.length; i < len-1; i++) {
      if(nums[i] === nums[i+1]) {
        return nums[i]
      }
    }
}

// 解法二
let findRepeatNumber = (nums) => {
  const obj = {}
  for(let i = 0; i < nums.length; i++) {
    if(obj[nums[i]]) {
      return nums[i]
    } else {
      obj[nums[i]] = 1
    }
  }
}

// 解法三
const findRepeatNumber = (nums) => {
  for(let i = 0; i < nums.length; i++) {
    while(nums[i] !== i) {
        console.log(nums[i], i)
      if(nums[i] === nums[nums[i]]) {
        return nums[i]
      }

      // 交换数组两个位置上的项，这里是i 和 num[i] 交换
      let temp= nums[i]
      nums[i] = nums[temp]
      nums[temp] = temp
    }
  }
}

// 递归版本
const preOrderTraverse = (root) => {
    let list = []

    const preOrder = (node) => {
        if(node !== null) {
            // 先访问根节点
            list.push(node.val)
            // 再访问左节点
            preOrder(node.left)
            // 最后访问右节点
            preOrder(node.right)
        }
    }
    preOrder(root)

    return list
}

// 非递归版本
const preOrderTraverseUnRecur = (root) => {
    let list = [];
    let stack = [root];

    while(stack.length !== 0) {
        const curNode = stack.pop()

        const left = curNode.left
        const right = curNode.right

        // 第一步的时候，先访问的是根节点
        list.push(curNode.val)

        if(right) {
            stack.push(right)
        }

        // 因为pop是取出最后一个元素，所以我们要确保首先拿到的是左节点
        if(left) {
            stack.push(left)
        }
    }
}

// 递归版本
const inOrderTraverse = (root) => {
    let list = []

    const inOrder = (node) => {
        if(node !== null) {
            inOrder(node.left)
            list.push(node.val)
            inOrder(node.right)
        }
    }

    inOrder(root)

    return list
}

// 非递归版本
const inOrderTraverseUnRecur = (root) => {
    let list = []
    // 借助了栈，先进后出的概念
    let stack = []
    let head = root

    while(stack.length !== 0 || head !== undefined) {
        while(head !== undefined) {
            stack.push(head)
            head = head.left
        }

        if(stack.length !== 0) {
            head = stack.pop()
            list.push(head.val)
            head = head.right
        }
    }

    return list
}

// 递归
const postOrderTraverse = (root) => {
    let list = []

    const postOrder = (node) => {
        if(!node) {
            postOrder(node.left)
            postOrder(node.right)
            list.push(node.val)
        }
    }

    postOrder(root)

    return list
}

// 非递归
const postOrderTraverseUnRecur = (root) => {
    let list = []
    if(root !== undefined) {
        let s1 = []
        let s2 = []

        s1.push(root)

        while(s1.length !== 0) {
            head = s1.pop()
            s2.push(head)

            if(head.left !== undefined) {
                s1.push(head.left)
            }

            if(head.right !== undefined) {
                s1.push(head.right)
            }
        }

        while(s2.length !== 0) {
            var item = s2.pop()
            list.push(item.val)
        }
    }

    return list
}

    1
   / \
  2   2
 / \ / \
3  4 4  3

    1
   / \
  2   2
   \   \
   3    3