一. 字符串
1. 字符串变形
描述： 对于一个长度为 n 字符串，我们需要对它做一些变形。
首先这个字符串中包含着一些空格，就像"Hello World"一样，然后我们要做的是把这个字符串中由空格隔开的单词反序，同时反转每个字符的大小写。
示例1
输入：
“This is a sample”,16
返回值：
“SAMPLE A IS tHIS”
// 思路：
// 1. 将字符串用split(' ')按照空格符分割成数组
// 2. 将数组翻转，判断每一个项中每一个字母的大小写，如果是大写改为小写，如果是小写改为大写，生成一个新数组
// 3. 将新数组用join拼接成一个字符串
// 4. 注意：
// split():默认按照空格分隔，会把多个空格当成一个分隔符。
// split(' '):按照空格分隔，会把每一个空格都当成一个分隔符。
// split(''):将每一个字符串都分隔。
const str = 'Hello World This Is a Student'
function trans(str, num){
if(str.length != num)return '数组的长度有误！'
const arrReverse = str.split(' ').reverse()
return arrReverse.map(item => {
// 进行大小写的转换
return [...item].map(ele => ele == ele.toLowerCase() ? ele.toUpperCase() : ele.toLowerCase()).join('')
}).join(' ')
}
console.log(trans(str,29)) // sTUDENT A iS tHIS wORLD hELLO
2. 字符串最长公共前缀
描述：给你一个大小为 n 的字符串数组 strs ，其中包含n个字符串 , 编写一个函数来查找字符串数组中的最长公共前缀，返回这个公共前缀。
示例1
输入：[“abc”]
返回值：“abc”
示例2
输入：[“abca”,“abc”,“abca”,“abc”,“abcc”]
返回值：“abc”
// 思路：
// 1. 如果数组长度为0，则返回空字符串
// 2. 如果数组长度为1，则返回数组中的字符串
// 3. 将数组排序，用第一个元素的第一个字符和最后一个元素的第一个字符进行比较
// 4. 如果相同将这个字符保存下来，以此类推将每次的字符串拼接起来，直到比较的两个字符串不相同，终止循环，最后返回拼接后的字符串
const strArr = ["abca","abc","abca","abc","abcc"]
function longestCommonPrefix(strArr){
if(!strArr.length) return ''
if(strArr.length === 1) return strArr[0]
strArr.sort()
const firstStr = strArr[0]
const lastStr = strArr.pop()
let res = ''
for(let i=0;i<firstStr.length;i++){
if(firstStr[i] == lastStr[i]){
res += firstStr[i]
}else{
break
}
}
return res
}
3. 验证ip地址
描述：给定一个ip地址，判断是ip4地址还是ip6地址
IPv4 地址由四组十进制数和点来表示，每个地址包含4个十进制数，其范围为 0 - 255， 用(“.”)分割。比如，172.16.254.1；
同时，IPv4 地址内的数不会以 0 开头。比如，地址 172.16.254.01 是不合法的。
IPv6 地址由8组16进制的数字来表示，每组表示 16 比特。这些组数字通过 (“:”)分割。只支持大小写和0-9的数字，不能出现特殊字符和空格
示例1
输入：“172.16.254.1”
返回值：“IPv4”
说明：这是一个有效的 IPv4 地址, 所以返回 “IPv4”
示例2
输入：“2001:0db8:85a3:0:0:8A2E:0370:7334”
返回值：“IPv6”
说明：这是一个有效的 IPv6 地址, 所以返回 “IPv6”
示例3
输入：“256.256.256.256”
返回值：“Neither”
说明：这个地址既不是 IPv4 也不是 IPv6 地址
// 思路：
// 1. 对输入的字符串先判断是属于ipv4范畴的还是ipv6范畴的
// 2. 如果属于ipv4范畴进行ipv4的判定，如果属于ipv6范畴进行ipv6判定。否则直接返回 Neither
// 3. 对于ipv4的判定：
// （1）先使用split('.')分割成数组，对数组长度判断，如果长度不为4，则返回 Neither。否则对数组里面的每一项是一个字符串进行判断
// （2）如果字符串长度为0或者大于3则返回false，否则对字符串每一项判断
// （3）如果字符串的第一项是'0'则返回false，否则如果不在'0'和'9'之间也返回false
// (4) 将这个字符串转成数字，如果不在0-255之间返回false，否则返回true
// 4. 对于ipv6的判定：
// (1) 先试用split(':')分割成数组，对数组长度判断，如果长度不为8，则返回 Neither，否则对数组里面的每一项是一个字符串进行判断
// (2) 如果字符串长度为0或者大于4则返回false，否则对字符串每一项判断
// （3）如果每一项的字符不在'0'--'9'、 'a'--'z' 、 'A'--'Z'之间则返回false，否则返回true
// 定义判断ipv4的方法：
function checkIPv4(s){
if(s.length === 0 || s.length > 3) return false
if(s[0] === '0') return false
for(let i of s){
if(i > '9' || i < '0') return false
}
return Number(s) <= 255 && Number(s) > 0
}
// 定义判断ipv6的方法：
function checkIPv6(s){
if(s.length === 0 || s.length > 4) return false
for(let j of s){
if(!(j>='0' && j<='9' || j>='a' && j<='f' || j>='A' && j<='F')) return false
}
return true
}
function solve(IP){
if(IP.indexOf('.') != -1){
const arrIpv4 = IP.split('.')
if(arrIpv4.length != 4) return 'Neither'
for(let ip of arrIpv4){
if(!checkIPv4(ip)){
return 'Neither'
}
}
return 'IPv4'
}else if(IP.indexOf(':') != -1){
const arrIpv6 = IP.split(':')
if(arrIpv6.length != 8) return 'Neither'
for(let ip of arrIpv6){
if(!checkIPv6(ip)){
return 'Neither'
}
}
return 'IPv6'
}else{
return 'Neither'
}
}
4. 大数相加
描述：以字符串的形式读入两个数字，编写一个函数计算它们的和，以字符串形式返回。
数据范围：长度小于等于100000，字符串仅由’0’-'9’构成
要求：时间复杂度O(n)
示例1
输入：“1”,“99”
返回值：“100”
说明：1+99=100
示例2
输入：“114514”,“”
返回值：“114514”
// 思路：
// 1. 对于一个很大的数来说不可以直接采用 Number()转成数字再相加，再用String()，因为这时候会丢失精度
// 2. 当两个数位数不一样的时候，分割成数组，在小的那个数前面补位'0',直到对齐
// 3. 从后往前加，做进位处理。如果大于9,则取余数，将余数用unshift()放进一个空数组的前面。同时记录一个变量为1。下次相加的时候加上这个变量
// 如果不大于9，则将这个数放进数组的前面
// 4. 最后将得到的数组用join()方法拼接成一个字符串
function solve(s,t){
const arr1 = s.split('')
const arr2 = t.split('')
let resArr = [], go = 0
while(arr1.length || arr2.length){
let num1 = +arr1.pop() || 0
let num2 = +arr2.pop() || 0
let temp = num1 + num2 + go
if(temp > 9){
temp %= 10
go = 1
}else{
go = 0
}
resArr.unshift(temp)
}
if (go) resArr.unshift(1);
return resArr.join('')
}
二. 堆、栈、队列
1. 用两个栈实现队列
描述：用两个栈来实现一个队列，使用n个元素来完成 n 次在队列尾部插入整数(push)和n次在队列头部删除整数(pop)的功能。 队列中的元素为int类型。保证操作合法，即保证pop操作时队列内已有元素。
数据范围：n<=1000
要求：存储n个元素的空间复杂度为 O(n) ，插入与删除的时间复杂度都是 O(1)
示例1
输入：[“PSH1”,“PSH2”,“POP”,“POP”]
返回值：1,2
说明：BinarySearchTree
“PSH1”:代表将1插入队列尾部
“PSH2”:代表将2插入队列尾部
"POP“:代表删除一个元素，先进先出=>返回1
"POP“:代表删除一个元素，先进先出=>返回2
// 方法一：
// 思路：
// 1. 定义两个空栈
// 2. 将数字push进第一个栈，然后再将pop出来的值push进第二个栈。最后在pop出来
// let arr2 = [],
// arr1 = [];
// function push(node)
// {
// // write code here
// arr1.push(node);
// }
// function pop()
// {
// // write code here
// if(!arr2.length){
// while(arr1.length){
// arr2.push(arr1.pop())
// }
// }
// return arr2.pop();
// }
// 方法二：
// 思路：
// 1. 定义一个空栈
// 2. 先将值push进去，然后再shift从头部删除值
let queue = [];
function push(node)
{
return queue.push(node);
}
function pop()
{
return queue.shift();
}
2. 包含Min函数的栈
描述：定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的 min 函数，输入操作时保证 pop、top 和 min 函数操作时，栈中一定有元素。
此栈包含的方法有：
push(value):将value压入栈中
pop():弹出栈顶元素
top():获取栈顶元素
min():获取栈中最小元素
示例:
输入: [“PSH-1”,“PSH2”,“MIN”,“TOP”,“POP”,“PSH1”,“TOP”,“MIN”]
输出: -1,2,1,-1
解析:
"PSH-1"表示将-1压入栈中，栈中元素为-1
"PSH2"表示将2压入栈中，栈中元素为2，-1
“MIN”表示获取此时栈中最小元素==>返回-1
"TOP"表示获取栈顶元素==>返回2
"POP"表示弹出栈顶元素，弹出2，栈中元素为-1
"PSH1"表示将1压入栈中，栈中元素为1，-1
"TOP"表示获取栈顶元素==>返回1
“MIN”表示获取此时栈中最小元素==>返回-1
// 思路：
// 1. 定义一个空栈
// 2. top函数获取的就是栈中最后一个元素
// 3. min函数获取就是栈中元素的最小值，可以使用Math.min()方法
let stack = []
function push(node)
{
return stack.push(node)
}
function pop()
{
if(stack.length){
return stack.pop()
}
}
function top()
{
return stack[stack.length - 1]
}
function min()
{
return Math.min(...stack)
}
3. 有效括号序列
描述：给出一个仅包含字符’(‘,’)‘,’{‘,’}‘,’[‘和’]',的字符串，判断给出的字符串是否是合法的括号序列，括号必须以正确的顺序关闭，"()“和”()[]{}“都是合法的括号序列，但”(]“和”([)]"不合法。
数据范围：字符串长度 0 <= n <= 10000
要求：空间复杂度O(n)，时间复杂度O(n)
示例1
输入：“[”
返回值：false
示例2
输入：“[]”
返回值：true
// 思路：
// 1. 先判断字符串的长度是不是偶数，如果是奇数则一定匹配不成功直接返回false
// 2. 如果长度是偶数，定义一个空栈，从左往右遍历字符串，遇到左字符串则放进栈中
// 3. 继续遍历如果遇到右字符串立刻从栈中弹出一个字符串，如果二者不能匹配则返回false
// 4. 遍历结束后如果栈的长度为零则说明匹配成功，是有效括号序列，返回true
function isValid( s ) {
const len = s.length % 2
let stack = []
if(len) return false
for(let i of s){
if(i=='(' || i=='[' || i=='{'){
stack.push(i)
}else{
if(stack.length){
if(i==')'){
if(stack.pop() != '(') return false
}else if(i==']'){
if(stack.pop() != '[') return false
}else{
if(stack.pop() !='{') return false
}
}else{
// 说明没有左括号，肯定匹配不成功
return false
}
}
}
return !stack.length
}
4. 滑动窗口的最大值
描述：给定一个长度为 n 的数组 num 和滑动窗口的大小 size ，找出所有滑动窗口里数值的最大值。
例如给定数组[1,2,3],窗口大小为2。则所有滑动的结果可能为[1,2],[2,3]所以对应的最大值分别为[2,3]
示例1
输入：[2,3,4,2,6,2,5,1],3
返回值：[4,4,6,6,6,5]
示例2
输入：[9,10,9,-7,-3,8,2,-6],5
返回值：[10,10,9,8]
示例3
输入：[1,2,3,4],5
返回值：[]
// 方法一思路：
// 1. 判断窗口长度和数组长度的大小，窗口长度为0，或者数组长度为0，或者窗口长度大于数组长度，返回空数组
// 2. 确定可能出现的滑动结果即有几组值，n = len - size + 1(n:滑动窗口值，len:数组长度，size:窗口大小)
// 3. 遍历数组，记录所有的滑动窗口，并计算出每一个窗口中的最大值
// 4. 将记录的最大值push进入一个新的栈中，最后返回这个栈
function maxInWindows( num , size ) {
if(!size || size > num.length) return []
const endValue = num.length - size
let maxNum = []
let stack = []
for(let i=0;i<endValue+1;i++){
for(let j=i;j<i+size;j++){
stack.push(num[j])
}
const max = Math.max(...stack)
maxNum.push(max)
stack = []
}
return maxNum
}
// 方法二思路：
// 1. 判断窗口长度和数组长度的大小，窗口长度为0，或者数组长度为0，或者窗口长度大于数组长度，返回空数组
// 2. 新建两个空栈 stack 和 maxNum 遍历数组将每一项放进 stack 中，判断 stack 的长度
// 如果 stack 的长度等于 size，此时求取 stack 中的最大值，放进 maxNum 中
// 如果 stack 的长度大于 size,此时从 stack 中删除第一个元素，此时 stack 的长度会等于 size,在求取 stack 中的最大值放进 maxNum 中
// 3. 遍历结束后返回 maxNum
function maxInWindows( num , size ){
if(!num.length || !size || size > num.length) return []
let stack = [],maxNum = []
for(let i of num){
stack.push(i)
if(stack.length > size){
stack.shift()
}
if(stack.length == size){
maxNum.push(Math.max(...stack))
}
}
return maxNum
}
5. 最小的k个数
描述：给定一个长度为 n 的可能有重复值的数组，找出其中不去重的最小的 k 个数。例如数组元素是4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4(任意顺序皆可)。
示例1
输入：[4,5,1,6,2,7,3,8],4
返回值：[1,2,3,4]
说明：返回最小的4个数即可，返回[1,3,2,4]也可以
示例2
输入：[1],0
返回值：[]
示例3
输入：[0,1,2,1,2],3
返回值：[0,1,1]
// 思路：
// 1. 将数组从小到大排序
// 2. 新建一个空栈，从排序后的数组中 shift 出前 k 个数
function GetLeastNumbers_Solution(input, k){
if(!input.length || !k) return []
let stack = []
input.sort((a,b) => a-b) // 从小到大排个序，会改变原数组
for(let i=0;i<k;i++){
stack.push(input.shift())
}
return stack
}
6. 寻找第K大的数
描述： 有一个整数数组，请你根据快速排序的思路，找出数组中第 k 大的数。给定一个整数数组 a ,同时给定它的大小n和要找的 k ，请返回第 k 大的数(包括重复的元素，不用去重)，保证答案存在
示例1
输入：[1,3,5,2,2],5,3
返回值：2
示例2
输入：[10,10,9,9,8,7,5,6,4,3,4,2],12,3
返回值：9
说明：去重后的第3大是8，但本题要求包含重复的元素，不用去重，所以输出9
// 思路：
// 1. 先判断数组长度是否为零，数组长度和n,k的大小关系。如果数组长度为零，或者数组长度不等于n,或者小于k。都返回false
// 2. 将数组从大到小排列，从中取出第k个数
function findKth( a , n , K ) {
if(!a.length || a.length != n || a.length < K ) return false
a.sort((a,b) => b-a) // 从大到小排列
return a[K-1]
}
7. 寻找中位数
描述：/如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
示例1
输入：[5,2,3,4,1,6,7,0,8]
返回值："5.00 3.50 3.00 3.50 3.00 3.50 4.00 3.50 4.00 "
说明：数据流里面不断吐出的是5,2,3…,则得到的平均数分别为5,(5+2)/2,3…
示例2
输入：[1,1,1]
返回值："1.00 1.00 1.00 "
// 思路：
// 1. 如果是一个空数组，直接返回'',
// 2. 新建一个数组，把原数组中的头部元素逐一取出放进这个数组中。在放进之后对数组进行从小到大的排序，排序完对数组长度判断
// 如果长度是奇数，则取中间值。如果长度是偶数则取中间两个值的平均值，就是中位数
// 3. 将上面得到中位数再放进一个新的栈中
// 4. 用join(' ')的方法拼成一个字符串
// 读取数据流
function Insert(num)
{
if(!num.length) return ''
let stack1 = [],stack2 = []
for(let i=0;i<num.length;i++){
stack1.push(num[i]) // 取出num中的头部元素放进stack1中
stack1.sort((a,b)=>a-b) // 对stack1进行从小到大排序
const median = GetMedian(stack1)
stack2.push(median)
}
return stack2.join(' ')
}
// 获取当前数据流中的中位数
function GetMedian(arr){
if(arr.length % 2){
// 此时数组长度为奇数，中位数是中间的值
const index = Math.floor(arr.length / 2)
const value = arr[index]
return value.toFixed(2)
}else{
// 此时数组长度是偶数，中位数是中间两个值的平均值
const index = arr.length / 2
const value = (arr[index] + arr[index - 1]) / 2
return value.toFixed(2)
}
}
8.表达式求值
描述：请写一个整数计算器，支持加减乘三种运算和括号。
要求：空间复杂度：O(n)，时间复杂度：O(n)
示例1
输入：“1+2”
返回值：3
示例2
输入：“(2*(3-4))*5”
返回值：-10
示例3
输入：“3+234-1”
返回值：26
function solve( s ) {
// write code here
return eval(s)
}
三. 哈希
1. 两数之和
描述：给出一个整型数组 numbers 和一个目标值 target，请在数组中找出两个加起来等于目标值的数的下标，返回的下标按升序排列。
要求：空间复杂度 O(n)，时间复杂度 O(nlogn)
示例1
输入：[3,2,4],6
返回值：[2,3]
说明：因为 2+4=6 ，而 2的下标为2 ， 4的下标为3 ，又因为 下标2 < 下标3 ，所以返回[2,3]
示例2
输入：[20,70,110,150],90
返回值：[1,2]
说明：20+70=90
function twoSum(numbers, target) {
if(!numbers.length) return false
const map = new Map()
for(let i=0; i<numbers.length; i++) {
if(map.has(target-numbers[i])) {
return [map.get(target-numbers[i]) + 1, i + 1]
}else {
map.set(numbers[i], i)
}
}
}
2. 数组中出现次数超过一半的数字
描述：给一个长度为 n 的数组，数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
要求：空间复杂度：O(1)，时间复杂度 O(n)
示例1
输入：[1,2,3,2,2,2,5,4,2]
返回值：2
示例2
输入：[3,3,3,3,2,2,2]
返回值：3
示例3
输入：[1]
返回值：1
// 方法一思路：
// 1. 建立一个空对象，将数组中的每一项作为对象中的key,出现次数作为值。（利用了对象中key的唯一性）
// 2. 如果这个值第一次出现就将他的值设为1，后面再出现一次，就将这个值加上1。和数组长度的一半向下取值比较
// 3. 如果小于，继续循环；如果大于终止循环，返回当前的key
// 使用一般 for 循环
// const arr = [1,2]
function MoreThanHalfNum_Solution( numbers ) {
const len = Math.floor(numbers.length / 2 )
let obj = {
}
if(numbers.length == 1){
return numbers[0]
}else{
for(let i of numbers){
if(obj[i]){
obj[i]++
if(obj[i] > len){
return i
}
}else{
obj[i] = 1
}
}
return '无解'
}
}
// console.log(MoreThanHalfNum_Solution(arr));
// 使用reduce
// const arr = [3,3,3,3,2,2,2]
function MoreThanHalfNum_Solution(numbers){
const len = Math.floor(numbers.length / 2 )
if(numbers.length == 1) return numbers[0]
const obj = numbers.reduce((preValue,curValue)=>{
preValue[curValue] = (preValue[curValue] + 1) || 1
return preValue
},{
})
for(let i in obj){
if(obj[i] > len) return i
}
return '无解'
}
// console.log(MoreThanHalfNum_Solution(arr));
// // 方法二：思路
// 将数组从小到大排列，取中那个数
// 如果这个数在数组中出现次数超过了一半，则排序后中间的那个数就是要求的结果
const arr = [3,3,3,3,2,2,2]
function MoreThanHalfNum_Solution(numbers){
const len = Math.floor(numbers.length / 2 )
return numbers.sort((a,b) => a -b)[len]
}
console.log(MoreThanHalfNum_Solution(arr));
3. 数组中只出现一次的两个数字
描述：一个整型数组里除了两个数字只出现一次，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。
要求：空间复杂度 O(1)，时间复杂度 O(n)，输出的结果按照非降序排列
示例1
输入：[1,4,1,6]
返回值：[4,6]
说明：返回的结果中较小的数排在前面
示例2
输入：[1,2,3,3,2,9]
返回值：[1,9]
// 方法一思路：
// 1. 新建一个对象 obj 和一个数组 arr
// 2. 将数组中的每一项作为对象中的key,出现次数作为值。（利用了对象中key的唯一性）
// 3. 统计每个数字出现的次数，然后对obj里面的每一项进行判断，如果对应的值为1，则将这个键放入arr数组中
// 4. 将最后得到的arr数组按照从小到大的顺序进行排列
function FindNumsAppearOnce(nums){
let obj = {
}, arr = []
for(let i of nums){
if(obj[i]){
obj[i]++
}else{
obj[i] = 1
}
}
for(let j in obj){
if(obj[j] == 1){
arr.push(+j)
}
}
return arr.sort((a,b) => a-b)
}
// 方法二思路：
// 1. 新建一个数组 arr 用于存储返回的结果
// 2. 如果这个数字在数组中只出现了一次，那么从头开始找和从尾开始找得到的应该是同一个数组下标
// 3. 所以判断indexOf() 和 lastIndexOf() 返回的下标是否相同，如果相同将这个值 push 进入 arr 中
// 4. 将得到的数组按照从小到大的顺序排列
function FindNumsAppearOnce(nums){
let arr = []
for(let i of nums){
if(nums.indexOf(i) == nums.lastIndexOf(i)){
arr.push(i)
}
}
return arr.sort((a,b) => a-b)
}
4. 缺失的第一个正整数
描述：给定一个无重复元素的整数数组nums，请你找出其中没有出现的最小的正整数
要求： 空间复杂度 O(1)，时间复杂度 O(n)
示例1
输入：[1,0,2]
返回值：3
示例2
输入：[-2,3,4,1,5]
返回值：2
示例3
输入：[4,5,6,8,9]
返回值：1
// 思路：
// 1. 将数组用set转换，使用while循环，终止条件是取到数组的长度。
// 2. 使用has()判断当前值是否在set数据结构中，不在则返回这个值，在则将当前值加1
function minNumberDisappeared( nums ) {
// 会超时
// if(!nums.length) return 1
// let i = 1
// while(i <= nums.length){
// if(!nums.includes(i)){
// return i
// }else{
// i++
// }
// }
// return i
let set = new Set(nums);
let i = 1;
if(!nums.length) return 1
while(i <= nums.length){
if(!set.has(i)){
return i
}else{
i++;
}
}
return i;
}
5. 三数之和
描述：给出一个有n个元素的数组S，S中是否有元素a,b,c满足a+b+c=0？找出数组S中所有满足条件的三元组。
要求：空间复杂度：O(n2)，时间复杂度 O(n2)
注意：三元组（a、b、c）中的元素必须按非降序排列。（即a≤b≤c）解集中不能包含重复的三元组。
示例1
输入：[0]
返回值：[]
示例2
输入：[-2,0,1,1,2]
返回值：[[-2,0,2],[-2,1,1]]
示例3
输入：[-10,0,10,20,-10,-40]
返回值：[[-10,-10,20],[-10,0,10]]
// 思路：
// 1. 如果数组长度小于3，直接返回空数组 []
// 1. 先将原数组按照从小到大的顺序排序
// 2. 定义一个新数组 array 用来存储满足条件的结果
// 3. 在排序后的数组中遍历，设定两个值，一个是 head = i+1,一个是tail = 数组长度 -1
// 4. 执行一个while循环，循环条件是head < tail
// 5. 对当前值，head 和 tail 指向的值做一个求和操作。对求和结果判断，如果结果为 0，则将这三个值放进一个数组中并push进 array 中同时则将 haed +1 向后移一位，tail - 1向前移动一位。
// 如果大于零则将 tail - 1,如果小于零则将 head + 1
// 6. 对循环结束后得到的 array 数组，进行二维数组的去重操作。
// 7. 二维数组去重
// （1）将里面的每一项用 JSON.stringify 变为字符串
// （2）将上述结果用 new Set() 去重，在将结果里面的每一项用 JSON.parse()反转回去
function threeSum( num ) {
let len = num.length
if(len < 3) return []
let arr = []
num.sort((a,b) => a -b)
for(let i=0;i<len - 2;i++){
let head = i + 1, tail = len - 1
while(head < tail){
let sum = num[i] + num[head] + num[tail]
if(sum > 0){
tail--
}else if(sum < 0){
head++
}else{
arr.push([num[i], num[head], num[tail]])
head++
tail--
}
}
}
// 对 array 数组，进行二维数组的去重操作
let stringArr = arr.map(item => JSON.stringify(item))
let setArr = [...new Set(stringArr)]
let resultArr = setArr.map(ele => JSON.parse(ele))
return resultArr
}
console.log(threeSum([-2,0,1,1,2]));
四. 链表
1. 反转链表
描述：给定一个单链表的头结点pHead(该头节点是有值的，比如它的val是1)，长度为n，反转该链表后，返回新链表。
示例1
输入：{1,2,3}
返回值：{3,2,1}
示例2
输入：{}
返回值：{}
说明：空链表则输出空
// 思路：
// 1. 定义两个指针，一个 pre 指向 null,一个 cur 指向当前表头
// 2. 将cur.next存起来，因为是单链表，不保存的话，改变方向之后就找不到旧节点的下个节点了
// 3. 直接改变链表方向，将cur.next 指向 pre。
// 4. 将 pre 和 cur 逐渐向后面移动，直到 cur 指向 null，此时返回 pre
function ReverseList( head ) {
// write code here
let pre = null
let cur = head
while(cur){
let temp = cur.next
cur.next = pre
pre = cur
cur = temp
}
return pre
}
2. 指定区域内的反转
五. 二叉树
1. 二叉树的前、中、后遍历
// 一. 前序遍历：根左右
// 描述：给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
// 输入：{1,#,2,3}
// 返回值：[1,2,3]
/*
* function TreeNode(x) {
* this.val = x;
* this.left = null;
* this.right = null;
* }
*/
// 思路：
// 1. 先判断是否为空二叉树
// 2. 递归遍历左右子树
function preorderTraversal( root ) {
let res = []
function preorder(node){
if(!node) return
res.push(node.val)
preorder(node.left)
preorder(node.right)
}
preorder(root)
return res
}
// 二. 中序遍历：左根右
// 描述：给你二叉树的根节点 root ，返回它节点值的 中序 遍历。
// 输入：{1,2,#,#,3}
// 返回值：[2,3,1]
function inorderTraversal( root ) {
let res = []
function inorder(node){
if(!node) return
inorder(node.left)
res.push(node.val)
inorder(node.right)
}
inorder(root)
return res
}
// 三. 后序遍历：左右根
// 描述：给定一个二叉树，返回他的后序遍历的序列。
// 输入：{1,#,2,3}
// 返回值：[3,2,1]
function postorderTraversal( root ) {
let res = []
function postorder(node){
if(!node) return
postorder(node.left)
postorder(node.right)
res.push(node.val)
}
postorder(root)
return res
}
2. 二叉树的层序遍历
描述：给定一个二叉树，返回该二叉树层序遍历的结果，（从左到右，一层一层地遍历）
要求: 0 <= 二叉树的结点数 <= 1500
示例1：
输入：{3,9,20,#,#,15,7}
输出：[[3], [9, 20], [15, 7]]
示例2
输入：{1,2}
返回值：[[1],[2]]
示例3
输入：{1,2,3,4,#,#,5}
返回值：[[1],[2,3],[4,5]]
// 思路：
// 1. 如果是空二叉树返回一个空数组
// 2. 新建两个数组 res = [](用来存储最终的结果),queue = [root]（用来存储每一层的结果）
// 3. 当 queue 这个数组的长度不为零时候，通过while循环将每一层的数据放入 queue 中。
// 4. 将 queue 这个数组放入 res 中。对左右子树依然执行步骤三
function levelOrder( root ) {
if(!root) return []
let res = [], queue = [root]
while (queue.length) {
res.push(queue.map(node => node.val));
queue = queue.reduce((q, node) => {
node.left && q.push(node.left);
node.right && q.push(node.right);
return q;
}, []);
}
return res;
}
3. 按之字形顺序打印二叉树
描述：给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替）
示例1
输入：{1,2,3,#,#,4,5}
返回值：[[1],[3,2],[4,5]]
说明：如题面解释，第一层是根节点，从左到右打印结果，第二层从右到左，第三层从左到右。
示例2
输入：{8,6,10,5,7,9,11}
返回值：[[8],[10,6],[5,7,9,11]]
示例3
输入：{1,2,3,4,5}
返回值：[[1],[3,2],[4,5]]
// 思路：按照层序遍历的方式，将偶数项翻转排列，层序遍历的思路见上
function Print( pRoot ) {
if(!pRoot) return []
let res = [], queue = [pRoot], floor = 1;
while(queue.length){
// 判断是奇数层还是偶数层，如果是奇数层直接放入数组中，如果是偶数层先反转一下再放进数组中
if(floor % 2 == 1){
// 奇数层
res.push(queue.map(node => node.val))
}else{
// 偶数层
res.push(queue.map(node => node.val).reverse())
}
queue = queue.reduce((q, node) => {
node.left && q.push(node.left);
node.right && q.push(node.right);
return q;
}, [])
floor++
}
return res
}