前端学习笔记(2019/11/20)

请求出第20个丑数。（最小因子只有2、3、5的数，称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7，习惯上我们把1当做是第一个丑数）；

输入：getUglyNumber(20)

输出：36

function getUglyNumber(n) {
    let ret=[1],p2=0,p3=0,p5=0;
    while(n>0)
        {
            let temp = Math.min(ret[p2]*2,ret[p3]*3,ret[p5]*5)
            ret.push(temp)
            if(ret[p2]*2==temp)
                {p2++}
            if(ret[p3]*3==temp)
                {p3++}
            if(ret[p5]*5==temp)
                {p5++}
            n--;
        }
    return ret[ret.length-2]
};

console.log(getUglyNumber(20))

现有数组[5,2,0,1,3,1,4]， 请实现去重功能后完成升序排序，并考虑性能。

输入：const array = [5, 2, 0, 1, 3, 1, 4];

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

const array = [5, 2, 0, 1, 3, 1, 4];
let newArr = Array.from(new Set(array)); //set 去重 Array.from 将类数组转换成数组
let sortArr = newArr.sort((a,b) => a-b) // sort 排序是针对数组的
console.log(sortArr) 

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]  

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum

var twoSum = function(nums, target) {
  const map = new Map()
  for (let i = 0; i < nums.length; i ++) {
    const otherIndex = map.get(target - nums[i])
    if (otherIndex !== undefined) return [otherIndex, i]
    map.set(nums[i], i)
  }
};

常见的算法统计

冒泡排序  冒泡排序的算法思想如下（升序排序）：

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样最终最大数被交换到最后的位置
3. 除了最后一个元素以外，针对所有的元素重复以上的步骤
4. 重复步骤1~3，直到排序完成

   //冒泡排序
   function bubbleSort ( data ) {
       var temp = 0;
       for ( var i = data.length ; i > 0 ; i -- ){
           for( var j = 0 ; j < i - 1 ; j++){
              if( data[j] > data[j + 1] ){
                  temp = data[j];
                  data[j] = data [j+1];
                  data[j+1] = temp;
              }
           }
       }
       return data;
   }

选择排序（SelctionSort） 

//选择排序
function selectionSort( data ) {
    for( var i = 0; i< data.length ; i++){
        var min = data[i]; //最小值，默认初始化为数组的第一个值
        var temp;
        var index = i; //数组中最小值的索引
        for( var j = i + 1; j< data.length; j++){
            //如果当前值比最小值小，把值赋值给min 并记录最小值的索引
            if( data[j] < min ){
                min = data[j];
                index = j;
            }
        }

        temp = data[i];
        data[i] = min;
        data[index]= temp;
    }
    return data;
}