算法之数组

一种最基础的数据结构，每种编程语言都有，它编号从 0 开始，代表一组连续的储存结构，用来储存同一种类型的数据。

数组：

let array = [1, 2, 3]

栈：

 let stack = [1, 2, 3]
        //进栈
        stack.push(4)
        //出栈
        stack.pop()

队列：

let queue = [1, 2, 3]
        //进队
        queue.push(4)
        //出队
        queue.shift()

1,已知如下数组：var arr = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10];

编写一个程序将数组扁平化去并除其中重复部分数据，最终得到一个升序且不重复的数组

 var arr = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10]
        function arrreduce(arr){
            //flat是es6中数组降维的方法  Infinity是降n维的意思
            var res = arr.flat(Infinity)
            //new set()是es6中去重的方法 
            var res1 = Array.from(new Set(res))
            //sort  是排序的
            var res2 = res1.sort((a,b)=> a-b)
            console.log(res,res1,res2)
        }
        arrreduce(arr)

array.from的几种用处

2,实现一个函数，判断输入是不是回文字符串
例如：abba       true

思路：先判断是不是字符串，不是就直接返回false，将字符串变成数组反转拼接成字符串是否等于传入的字符串

 function fun(arr){
            if(typeof arr !== 'string') return false
            let res = arr.split('').reverse().join('') === arr
            return res
        }
        fun('abba')

思路：将字符串的第一位和最后一位比较，在第二位和倒数第二位比较…以此类推

 function fun(arr){
            let j=arr.length-1
            for(let i = 0;i<j;i++){
                if(arr.charAt(i) !== arr.charAt(j)) return false
                i++;
                j--
            }
            return true

        }
        fun('abba')

3，给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度

思路一：定义一个数组，将字符串双层循环，查找没有重复字符的子串，在排序找到最大的数字

function fun(str){
            let res = []
              for(let i=0;i<str.length;i++){
                  for(let j = i+1;j<str.length;j++){
                    if(str.charAt(i) == str.charAt(j)){
                        res.push(j-i)
                        break
                    }
                  }
              }
              res.sort((a,b)=>b-a)
              return res[0]
        }
        console.log(fun("pwwkew"))

function fun(s){
            let arr = [], max = 0
            for(let i = 0; i < s.length; i++) {
                let index = arr.indexOf(s[i])
                if(index !== -1) {
                    arr.splice(0, index+1);
                }
                arr.push(s.charAt(i))
                console.log(arr)
                max = Math.max(arr.length, max) 
            }
            return max
        }

        console.log(fun("pwwkew"))

4，查找字符串中字符最多的字符或次数

var str = 'asdfssaaasasasasaa';
         function func(str){
             var res = {}
            for(var i = 0;i<str.length;i++){
                if(!res[str.charAt(i)]){
                    res[str.charAt(i)] = 1
                }else{
                    res[str.charAt(i)] += 1
                }
               
            }
            console.log(res)
         }
         func(str)

5，给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

思路：定义一个对象，左边的括号对应右边的，先判断在不在对象里面，在就保存字符（右边的括号）栈的概念，先进后出，判断字符是不是对应栈的最上面哪一个，不是就直接false，是继续下一个字符

var isValid = function(s) {
            let stack = []
            let map = {
                '(':')',
                '{':'}',
                '[':']'
            }
            for(let i = 0;i<s.length;i++){
                if(map[s[i]]){
                    stack.push(s[i])
                }else if(s[i] !== map[stack.pop()]){
                    return false
                }
            }
            return stack.length == 0
        };
        // isValid("()[]{}")
        console.log(isValid("{[}]"))

在这里插入代码片

删除字符串中的所有相邻重复项
输入："abbaca"
输出："ca"
解释：
例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

思路：定一个栈，for循环字符串，拿当前循环的字符串和栈的最顶端（数组的最末）的字符串比较，不想等就需要把数组最末的push，在把当前的字符push进数组

 var removeDuplicates = function(S) {
            let stack = []
            for(var c of S){
                var prev = stack.pop()
                if(prev !== c){
                    stack.push(prev)
                    stack.push(c)
                }
            }
            return stack.join('')

            // let stack = []
            // let str = S.split('')
            // for(let i = 0;i<str.length;i++){
            //     let prev = stack.pop()
            //     if(str[i] !== prev){
            //         stack.push(prev)
            //         stack.push(str[i])
            //     }
            // }

            // return stack.join('')



        };
        
        console.log(removeDuplicates("abbaca"))

6,删除排序数组中重复项

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

相信大家看到这道题的时候肯定想到的就是es6中的new Set()方法，我一开始也想到这个，编译一直通不过，我当时就纳闷了，我说去重不就是这样了，一番百度之后发现原来new set()方法不改变原数组，这个需要改变原数组，所以只能用splice之类的了

var removeDuplicates = function(nums) {
            for(var i = 0;i<nums.length;i++){
                if(nums[i] == nums[i+1]){
                    nums.splice(i,1)
                    i--
                }
            }
            return nums.length
        };
        var nums = [1,1,2]
        console.log(removeDuplicates(nums))

7,给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
        不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
        元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

这个应该没啥难度，只要记得在原有的数组上面修改就行

var removeElement = function(nums, val) {
            for(let i=0;i<nums.length;i++){
                if(nums[i] == val){
                    nums.splice(i,1)
                    i--
                }
            }
            return nums.length
        };
        console.log(removeElement([0,1,2,2,3,0,4,2],2))

 8，给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回  -1。

思路：因为看到这个我就想到substr()方法，所以是按照substr的思想做的，首先查找字符串里有没有needle的第一个字符一样的，有一样的就在数组里截取needle一样的长度的字符串再和needle比较

 var strStr = function(haystack, needle) {
            if(haystack == needle || needle == ''){
                return 0
            }
            for(let i = 0;i<haystack.length;i++){
                if(haystack[i] == needle.charAt(0)){
                    if(haystack.substr(i,needle.length) == needle){
                        return i
                    }
                }
            }
            return -1
        };
        console.log(strStr("hello","ll"))