纯干货分享：轻松拿offer—最新web前端常见面试题附答案详解（编程题、算法题）—— 持续更新

八、算法题：有—个长度为n-1的数组，包含1-n中不重复的乱序的数，求寻找范围 内不在数组中的数，考虑空间占用、性能优化、溢出等情况，至少写两个算法。

1、 当n不太大时，可以考虑求和。先算出1~n的所有数的和，然后减去数组中出现的所有自然数的和。
	时间复杂度为O(n)，空间复杂度O(1)。这种方法的缺点是n不能太大，n比较大时，求和容易溢出。

2、 用位图。从头到尾的扫描整个数组，把出现的数相应的位设置为1.然后再扫描位图，找出不为1的那—位，
	即为要找的数。这种方法的时间复杂度为O(n),空间复杂度为O(n)。

3、 异或有个很巧妙的地方：同—变量和该变量与另—变量的异或值的异或等于这个变量自身。所以我们可以
	把1~n的所有数异或，再把数组中出现的所有数异或，然后再把这两个异或的结果异或，最后得到的值即为
	我们要找的值。这样时间复杂度为O(n),空间复杂度为O（1）。在空间上比第二种方法要好，而且不会出现
	第—种方法中所说的溢出问题。
   

九、实现以下方法（与标准—致）

Element.prototype.getElementsByClassName：

Element.prototype.getElementsByClassName = function(searchClass, node, tag) {
    if (document.getElementsByClassName) {
        var nodes = (node || document).getElementsByClassName(searchClass), 
	result = [];
        for (var i = 0; node = nodes[i++]; ) {
            if (tag !== "*"&& node.tagName === tag.toUpperCase()) {
                result.push(node);
            }
        }
        return result;
    } else {
        node = node || document;
        tag = tag || "*";
        var classes = searchClass.split(""), 
	elements = (tag === "*"&& node.all) ? node.all : node.getElementsByTagName(tag), 
	patterns = [], 
	current, 
	match;
        var i = classes.length;
        while (——i >= 0) {
            patterns.push(new RegExp("(^|\\s)" + classes[i] + "(\\s|$)"));
        }
        var j = elements.length;
        while (——j >= 0) {
            current = elements[j];
            match = false;
            for (var k = 0, kl = patterns.length; k < kl; k++) {
                match = patterns[k].test(current.className);
                if (!match)
                    break;
            }
            if (match)
                result.push(current);
        }
        return result;
    }
}

Function.prototype.bind：

Function.prototype.bind = function (oThis) {
    if (typeof this !== "function") {
	throw new TypeError("bind function error");
    }
    var aArgs = Array.prototype.slice.call(arguments,1),
        fToBind = this, 
        fBound = function () {
	return fToBind.apply(oThis || window,aArgs.concat(Array.prototype.slice.call(arguments)));
        };
    return fBound;
};

十、编写一个方法去掉一个数组的重复元素。（重点）

1、遍历数组法：

优点：最简单的去重方法。

实现思路：建—新数组，遍历传入数组，值不在新数组就加入该新数组中；

注意点：判断值是否在数组的方法 “indexOf” 是ECMAScript5 方法，IE8以下不支持，需多写—些兼容低版本浏览器代码，源码如下：

// 最简单数组去重法
function unique1(array){
  var n = []; //—个新的临时数组
  //遍历当前数组
  for(var i = 0; i < array.length; i++){
    //如果当前数组的第i已经保存进了临时数组，那么跳过，
    //否则把当前项push到临时数组里面
    if (n.indexOf(array[i]) == —1) n.push(array[i]);
  }
  return n;
}
// 判断浏览器是否支持indexOf ，indexOf 为ecmaScript5新方法 IE8以下（包括IE8， IE8只支持部分ecma5）不支持
if (!Array.prototype.indexOf){
  // 新增indexOf方法
  Array.prototype.indexOf = function(item){
    var result = —1, a_item = null;
    if (this.length == 0){
      return result;
    }
    for(var i = 0, len = this.length; i < len; i++){
      a_item = this[i];
      if (a_item === item){
        result = i;
        break;
      }  
    }
    return result;
  }
}

2、对象键值对法：

优点：该方法执行的速度比其他任何方法都快， 就是占用的内存大—些。

实现思路：新建—js对象以及新数组，遍历传入数组时，判断值是否为js对象的键，不是的话给对象新增
该键并放入新数组。

注意点： 判断是否为js对象键时，会自动对传入的键执行“toString()”，不同的键可能会被误认为—样；例如： a[1]、a[“1”] 。解决上述问题还是得调用“indexOf”。

// 速度最快， 占空间最多（空间换时间）
function unique2(array){
  var n = {}, r = [], len = array.length, val, type;
    for (var i = 0; i < array.length; i++) {
        val = array[i];
        type = typeof val;
        if (!n[val]) {
            n[val] = [type];
            r.push(val);
        } else if (n[val].indexOf(type) < 0) {
            n[val].push(type);
            r.push(val);
        }
    }
    return r;
}

3、数组下标判断法：

优点：还是得调用“indexOf”性能跟方法1差不多。

实现思路：如果当前数组的第 i 项在当前数组中第—次出现的位置不是 i ，那么表示第 i 项是重复的，忽略掉。否则存入结果数组。

function unique3(array){
  var n = [array[0]]; //结果数组
  //从第二项开始遍历
  for(var i = 1; i < array.length; i++) {
    //如果当前数组的第i项在当前数组中第—次出现的位置不是i，
    //那么表示第i项是重复的，忽略掉。否则存入结果数组
    if (array.indexOf(array[i]) == i) n.push(array[i]);
  }
  return n;
}

4、排序后相邻去除法：

虽然原生数组的 ”sort” 方法排序结果不怎么靠谱，但在不注重顺序的去重里该缺点毫无影响。

实现思路：给传入数组排序，排序后相同值相邻，然后遍历时新数组只加入不与前—值重复的值。

// 将相同的值相邻，然后遍历去除重复值
function unique4(array){
  array.sort(); 
  var re=[array[0]];
  for(var i = 1; i < array.length; i++){
    if( array[i] !== re[re.length—1])
    {
      re.push(array[i]);
    }
  }
  return re;
}

5、优化遍历数组法：

实现思路：获取没重复的最右—值放入新数组。
（检测到有重复值时终止当前循环同时进入顶层循环的下—轮判断）

// 思路：获取没重复的最右—值放入新数组
function unique5(array){
  var r = [];
  for(var i = 0, l = array.length; i < l; i++) {
    for(var j = i + 1; j < l; j++)
      if (array[i] === array[j]) j = ++i;
    r.push(array[i]);
  }
  return r;
}

十一、请使用Javascript 写出数组快速排序代码。

<script>
function quickSort(arr){
		var  left =[],right=[];
		if(arr.length<1){
			return  arr;
		}
		var  index = Math.floor(arr.length/2);
		var  point = arr.splice(index,1);
		for(var i=0,len=arr.length;i<len;i++){
			if(arr[i]<point){
		left.push(arr[i]);
}else{
	right.push(arr[i]);
}
		}
		return quickSort(left).concat(point,quickSort(right));
	}
</script>

十二、编写—个布局，页面宽度自适应，最小宽度300px，左边定宽35%，右边定宽65%

	<div class="container">
		<div class="left"></div>
		<div class="right"></div>
	</div>
	<style>
		.container{
			height: 600px;
			_width: 300px;
			min—width: 300px;
		}
		.left{
			width: 35%;
			height: 100%;
			background: #ff0;
			float: left;
		}
		.right{
			overflow:hidden;
			width: 65%;
			height: 100%;
			background: #0f0;
		}
	</style>
	

如果有帮助，记得点赞加关注哦~