学习算法第二天，感觉自己真的是个憨憨，看半天解释都看不懂
总结了一下，我的刷题速度有平均半个小时一道题，脑子真的不够用,
刷题好慢，有大佬指导一下吗，分享点经验啥的
reverse-linked-list
翻转链表
var reverseList = function(head) {
let pre = null;
let cur = head;
while(cur) {
let temp = cur.next;
cur.next = pre;
pre = cur;
cur = temp;
}
return pre;
};
复制代码是否是合法的IPv4，IPv6
感觉自己是个憨憨，调试了接近30分钟,
但总算看到了进步，毕竟是没看答案，做出来了
ip4和ip6区分开，然后进行判断
function ipV4(ip) {
const arr = ip.split(’.’);
if(arr.length !== 4) {
return false;
}
for (let i = 0; i < arr.length; i++) {
const bool = arr[i] >= 0 && arr[i] <= 255;
const firStr = arr[i].substring(0, 1);
const second = arr[i].substring(1, 2);
if (second && parseInt(firStr) === 0) {
return false;
}
if (arr[i] == ‘’) {
return false;
}
if (!bool || /[^0-9]/gi.test(arr[i])) {
return false;
}
}
return true;
}

function ipV6(ip) {
const arr = ip.split(’:’);
if (arr.length !== 8) {
return false;
}
for (let i = 0; i < arr.length; i++) {
const bool2 = arr[i].length > 4;
const bool1 = /[^a-f0-9]/gi.test(arr[i]);
if (arr[i] === ‘’) {
return false;
}
if (bool2 || bool1) {
return false;
}
}
return true;
}

var validIPAddress = function(IP) {
const IsIpV4 = IP.includes(’.’);
if (IsIpV4) {
return ipV4(IP) ? ‘IPv4’ : ‘Neither’
} else {
return ipV6(IP) ? ‘IPv6’ : ‘Neither’
}
};
复制代码longest-substring-without-repeating-characters
这道题还是不会，学习了用两个指针的这种方法
function lengthOfLongestSubstring(s) {
let max = 0;
let start = 0;
let st = {};
for (let end = 0; end < s.length; end++) {
const key = s[end];
if (st[key]) {
start = Math.max(st[key], start)
}
max = Math.max(max, end - start + 1);
st[key] = end + 1;
}
return max;
}
复制代码merge-two-sorted-lists
写了这道题让我走出了一个误区，就是给我一个链表我要是给next赋值，并不是放在最后面，是直接把这个链表的next值改了，如果是原来长度是5，现在给next赋值以后，他的长度就是2了，要走出这个误区
var mergeTwoLists = function(l1, l2) {
const list = new ListNode(0);
let prev = list;
while(l1 && l2) {
let temp;
if (l1.val > l2.val) {
prev.next = l2;
l2 = l2.next;
} else {
prev.next = l1;
l1 = l1.next;
}
prev = prev.next;
}

if (l1) prev.next = l1;
if (l2) prev.next = l2;
return list.next;
};
复制代码validate-binary-search-tree
var isValidBST = function(root) {
const stack = [{
root,
lower: -Infinity,
upper: Infinity,
}];
while (stack.length > 0) {
const params = stack.shift();
root = params.root;
lower = params.lower;
upper = params.upper;
if (!root) {
continue;
}
const val = root.val;
if (val <= lower || val >= upper) {
return false;
}
stack.push({root: root.right, lower: val, upper: upper})
stack.push({root: root.left, lower: lower, upper: val})
}
return true;
};
复制代码best-time-to-buy-and-sell-stock
var maxProfit = function(prices) {
if (prices.length < 2) {
return 0;
}
let max = 0;
let min = prices[0];
for (let i = 0; i < prices.length; i++) {
max = Math.max(max, prices[i] - min);
min = Math.min(prices[i], min)
}
return max;
};
复制代码reverse-integer
学习了怎么取反的方式
var reverse = function(x) {
let res = 0;
const max = Math.pow(2, 31) -1 ;
const min = -Math.pow(2, 31)
while (x !== 0) {
res = res * 10 + x % 10;
x = ~~(x / 10);
}
if (res > max) return 0;
if (res < min) return 0;
return res;
};
复制代码min-stack
仿佛渐入佳境，虽然难度为为简单
就是用两个数组来存储，一个是构造的列表，另外一个降序的列表
var MinStack = function() {
this.values = [];
this.min = [];
};

/**

• @param {number} x
• @return {void}
  */
  MinStack.prototype.push = function(x) {
  const values = this.values;
  values.push(x);
  const min = this.min;
  if (min.length === 0 || x <= min[min.length - 1]) {
  min.push(x)
  }
  };

/**

• @return {void}
  */
  MinStack.prototype.pop = function() {
  const value = this.values.pop();
  const min = this.min;
  if (min[min.length - 1] === value) {
  min.pop();
  }
  };

/**

• @return {number}
  */
  MinStack.prototype.top = function() {
  const values = this.values;
  return values[values.length - 1]
  };
  复制代码diameter-of-binary-tree
  感觉有那么一点递归的意识了加油
  var diameterOfBinaryTree = function(root) {
  let result = 0;
  function deep(root) {
  if (!root) return -1;
  let left = root.left ? deep(root.left) + 1 : 0;
  let right = root.right ? deep(root.right) + 1 : 0;

   result = Math.max(left + right, result);
   return Math.max(left, right);
  

  }
  deep(root);
  return result;
  };
  复制代码merge-sorted-array
  似乎智商又占领高地了
  var merge = function(nums1, m, nums2, n) {
  for (let i = 0; i < n; i++) {
  nums1[m] = nums2[i];
  m += 1;
  }
  nums1.sort((a, b) => {
  return a - b;
  })
  };