<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>2019/6/04~2019/6/13猫眼面试准备+面试记录</title>
</head>
<body>
<script>
var array = [1, 1, 100, 3, 2, 7, 5];
var obj = { name: 'a', age: 18 };
var x = 10;
var result;
/*深度克隆*/
function deep(obj) {
var target;
if (typeof obj !== 'object') {
return obj;
}
else
target = Object.prototype.toString.call(obj) == 'object Array' ? [] : {};
for (var prop in obj) {
target[prop] = deep(obj[prop]);
}
return target;
}
function deepcopy(target, option) {
if (Object.prototype.toString.call(option) == '[object Array]') {
target = [];
for (var i = 0; i < option.length; i++) {
target[i] = deepcopy(target[i], option[i]);
}
}
else if (Object.prototype.toString.call(option) == '[object Object]') {
target = {};
for (var prop in option) {
target[prop] = deepcopy(target[prop], option[prop]);
}
}
else
target = option;
return target;
}
function deepClone(target, option) {
if (option != null) {
for (var prop in option) {
var src = target[prop];
var copy = option[prop];
if (copy != null && typeof copy == 'object') {
if (Object.prototype.toString.call(copy) == '[object Array]') {
src = [];
}
else
src = {};
target[prop] = deepClone(src, copy);
}
else
target[prop] = option[prop];
}
}
return target;
}
/*数组自带的sort排序 如果返回正数参数位置改变，如果返回负数，参数位置不变*/
var res = deepcopy(result, array).sort(function (a, b) {
return a - b;
})
console.log(res);
/* 冒泡排序*/
function bobulesort(arr) {
if (arr == null || arr.length < 2)
return arr;
var temp;
for (var i = 0; i < arr.length; i++) {
for (var j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
var res1 = deepcopy(res1, array);
console.log(bobulesort(res1));
/*选择排序*/
function sectorsort(arr) {
if (arr == null || arr.length < 2)
return arr;
var temp, mid;
for (var i = 0; i < arr.length; i++) {
temp = i;
for (var j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[temp]) {
temp = j;
}
}
if (i != temp) {
mid = arr[i];
arr[i] = arr[temp];
arr[temp] = mid;
}
}
return arr;
}
var res2;
console.log(sectorsort(deepcopy(res2, array)));
/*插入排序*/
function insertsort(arr) {
for (var i = 1; i < arr.length; i++) {
var index = i;
while (index > 0 && arr[index - 1] > arr[index]) {
var temp = arr[index];
arr[index] = arr[index - 1];
arr[index - 1] = temp;
index--;
}
}
return arr;
}
var res3;
console.log(insertsort(deepcopy(res3, array)));
/*希尔排序*/
function shellsort(arr) {
var len = arr.length;
for (var gaps = Math.floor(len / 2); gaps > 0; gaps = Math.floor(gaps / 2)) {
for (var i = gaps; i < len; i++) {
for (var j = i - gaps; j >= 0 && arr[j] > arr[j + gaps]; j -= gaps) {
var temp = arr[j];
arr[j] = arr[j + gaps];
arr[j + gaps] = temp;
}
}
}
return arr;
}
var res4;
console.log(shellsort(deepcopy(res4, array)));
/*归并排序*/
function merge(left, right) {
var result = [];
while (left.length > 0 && right.length > 0) {
if (left[0] < right[0]) {
/*shift()方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。*/
result.push(left.shift());
} else {
result.push(right.shift());
}
}
return result.concat(left).concat(right);
}
function mergeSort(items) {
if (items.length == 1) {
return items;
}
var middle = Math.floor(items.length / 2),
left = items.slice(0, middle),
right = items.slice(middle);
return merge(mergeSort(left), mergeSort(right));
}
/* 快速排序*/
function quickSort(arr) {
if (arr.length == 0) return [];
var item = arr[0];
var leftarr = [];
var rightarr = [];
for (var i = 1; i < arr.length; i++) {
if (arr[i] <= item) {
leftarr.push(arr[i]);
} else {
rightarr.push(arr[i]);
}
}
return quickSort(leftarr).concat(item, quickSort(rightarr));
}
function quick_sort(arr, left, right) {
if (left > right) return;
var temp = a[left];
var l = left, r = right;
while (left < right) {
while (left < right && a[right] >= temp) right--;
while (left < right && a[left] < temp) left++;
if (left != right) {
var x = arr[left];
arr[left] = arr[right];
arr[right] = temp;
}
}
a[l] = a[left];
a[left] = temp;
quick_sort(arr, 0, left - 1);
quick_sort(arr, left + 1, right);
}
var res3;
console.log(quickSort(deepcopy(res3, array)));
/* 二分查找 */
function er_fen(num, arr) {
var l = 0, r = arr.length - 1, key = -1;
while (l <= r) {
var mid = Math.floor((l + r) / 2);
if (arr[mid] < num) {
l = mid + 1;
} else if (arr[mid] == num) {
key = mid;
} else {
r = mid - 1;
}
}
return key;
}
/*数组去重*/
function unque(arr) {
var res = [];
arr.forEach(function (ele, index) {
if (res.indexOf(ele) == -1) res.push(ele);
})
return res;
}
console.log(quickSort(unque(array)));
/*约瑟夫环*/
var arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14];
function test(arr, k, m) {
var len = arr.length;
var num = (k - 1) % len;
var index = num;
while (arr.length > 0) {
len = arr.length;
index += m - 1;
index %= len;
//console.log(arr[index]);
arr.splice(index, 1);
}
}
test(arr1, 12, 9);
/*合并排序不使用数组的方法*/
function merge_1(arr, left, mid, right) {
var result = [];
var index = 0, l = left, r = mid + 1, lenl = mid, lenr = right;
while (l <= lenl && r <= lenr) {
if (arr[l] < arr[r]) {
result[index++] = arr[l++];
} else {
result[index++] = arr[r++];
}
}
if (l <= lenl) {
while (l <= lenl) { result[index++] = arr[l++]; }
} else if (r <= lenr) {
while (r <= lenr) { result[index++] = arr[r++]; }
}
console.log(result);
for (var i = left; i <= right; i++) {
arr[i] = result[i - left];
}
}
function merge_Sort(arr, start, end) {
if (end <= start) return;
var mid = start + Math.floor((end - start) / 2);
console.log(start, mid, end);
merge_Sort(arr, start, mid);
merge_Sort(arr, mid + 1, end);
merge_1(arr, start, mid, end);
}
/*斐波那契数列*/
function itFib(n) {
var last = 1;
var nextLast = 1;
var result = 1;
for (var i = 2; i < n; i++) {
result = nextLast + last;
nextLast = last;
last = result;
}
return result;
}
/*数组模拟队列*/
function queue() {
this.dataStore = [];
this.inqueue = inqueue;//向队尾添加一个元素
this.dequeue = dequeue;//删除队首的元素
this.front = front;//读取队首的元素
this.back = back;//读取队尾的元素
this.toString = toString;//显示队列内的所有元素
this.empty = empty;//判断队列是否为空
}
/*数组模拟栈*/
function Stack() {
this.dataStore = [];
this.top = 0;//记录栈顶位置
this.push = push;//向栈顶添加新元素
this.pop = pop;//删除栈顶元素
this.peek = peek;//返回栈顶元素
}
/*Node类*/
function Node(element) {
this.element = element;//保存节点上的数据
this.next = null;//保存指向下一节点的链接
}
function LList() {
this.head = new Node('head');
this.find = find;//查找节点
this.insert = insert;//插入新节点
this.remove = remove;//用findPrevious方法找到前一个节点，删除当前节点
this.display = display;//
}
/*继承*/
/*call方法*/
Function.prototype.newcall = function () {
var ctx = arguments[0] || window;
ctx.fn = this;
var args = [];
for (var i = 1; i < arguments.length; i++) {
args.push('arguments[' + i + ']');
}
var result = eval('ctx.fn(' + args.join(',') + ')');
delete ctx.fn;
return result;
}
/*apply*/
Function.prototype.newapply = function (ctx, arr) {
var ctx = ctx || window;
ctx.fn = this;
if (!arr) {
var result = ctx.fn();
delete ctx.fn;
return result;
} else {
var args = [];
for (var i = 0; i < arr.length; i++) {
args.push('arguments[' + i + ']');
}
var result = eval('ctx.fn(' + args.join(',') + ')');
delete ctx.fn;
return result;
}
}
/*bind方法*/
Function.prototype.bind = function (ctx) {
var self = this;
var arr = Array.prototype.slice.call(arguments, 1);
return function () {
var args = Array.prototype.slice.call(arguments);
var finarr = arr.concat(args);
return self.apply(ctx, finarr);
}
}
/*节流*/
function throttle(handler, wait) {
var lastTime = 0;
return function (e) {
//arguments [event]
var nowTime = new Date().getTime();
if (nowTime - lastTime > wait) {
handler.apply(this, arguments);
lastTime = nowTime;
}
}
}
/*防抖*/
function debounce(fn, wait) {
var timeout = null;
return function () {
if (timeout !== null) clearTimeout(timeout);
timeout = setTimeout(fn, wait);
}
}
</script>
</body>
</html>
56万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
