// 1、判断当前的数组是否有这个数据
function unique(arr) {
if (!Array.isArray(arr)) {
console.log("当前的不是数组");
return;
}
var res = [];
for (let i = 0; i < arr.length; i++) {
if (res.indexOf(arr[i] === -1)) {
res.push(arr[i]);
}
}
}
//2，数据去重的方案是，过滤出元素第一次出现的位置和现在位置是否相等，不等说明该元素是重复的元素
function unique() {
if (!Array.isArray(arr)) {
console.log("当前的不是数组");
return;
}
Array.prototype.filter.call(arr, (item, index) => {
return arr.indexOf(item) === index;
})
}
//3, 将数组进行排序，相邻的数据不能相等
function unique() {
if (!Array.isArray(arr)) {
console.log("当前的不是数组");
return;
}
var arr = arr.sort();
let res = [];
for (var i = 0; i < arr.length; i++) {
if (a[i] !== arr[i - 1]) {
res.push(a[i]);
}
}
return res;
}
//4.利用对象的属性进行的处理
function unique() {
if (!Array.isArray(arr)) {
console.log("当前的不是数据");
}
let obj = {};
let res = [];
for (let i = 0; i < arr.length; i++) {
if (!obj[arr[i]]) {
res.push(arr[i]);
obj[arr[i]] = 1;
}
}
return res;
}
//5,使用es6属性去重,把其他对象转成数组，用解构字符和set
function unique() {
if (!Array.isArray(arr)) {
console.log("当前不是数组");
return;
}
return [...new set(arr)]
}
// 6,Array.form 对于对象Set Map Array 进行解构
function unique() {
if (!Array.isArray(arr)) {
console.log("当前不是数组");
}
return Array.from(new set(arr));
}
pasting
// spy-debugger
// 1, 函数自动加一
var getId = (function () {
var i = 0;
return function () {
return i++;
};
})();
console.log(getId());
console.log(getId());
// // 333=====
function A() {
var tmp = 0
return function B() {
return tmp++;
}
}
var add = A()
console.log('ddd' + add())
console.log('ddd1' + add())
// 偏函数
function a(a) {
return function (b) {
return a + b
}
}
var addOne = a(1)
console.log(addOne(2));
console.log(addOne(3));
// 2，偏函数、柯里化函数的了解
// https://www.cnblogs.com/zztt/p/4142891.html 实现柯里化的工作
function G(val) {
var tmp = 0
function B(val) {
tmp = tmp + val
console.log('d' + tmp)
return B;
}
return B;
}
var addE = G()
console.log('222' + addE(1)(2)(3)(4))
// 结果
// 1
// 3
// 6
// 10
function add() {
var args = Array.prototype.slice.call(arguments);
var fn = function () {
var arg_fn = Array.prototype.slice.call(arguments);
return add.apply(null, args.concat(arg_fn));
}
fn.valueOf = function () {
return args.reduce(function (a, b) {
return a + b;
})
}
return fn;
}
// console.log(sum); // Function
console.log('add===' + add(1)) // 1
console.log('dd====' + add(1, 2)(3)) //6
console.log('ff===' + add(1)(2)(3)(4)(5)) // 15
// 调用形式灵活，一次调用可输入一个或者多个参数，并且支持链式调用
// bind reduce
var obj = {
value: 1,
items: [
{
value: 2,
items: [{
value: 2,
items: [{
value: 4,
items: []
}]
}]
}
]
}
function a(obj) {
var sub = 0
for (key in obj) {
if (key === 'value') {
sub += obj[key]
console.log(sub)
} else {
a(obj[key][0])
}
}
console.log(sub += sub)
// return sub += sub
console.log('sub===' + sub)
}
console.log(a(obj));
//4、 冒泡，快排，时间复杂度：
// 5、线性顺序存储，链式存储结构有什么的区别
https://www.cnblogs.com/webFrontDev/p/3865719.html
1、堆
3，二叉树 总结
4，斐波那契算法
/**
* 斐波拉契数列算法书写,过多的重复计算
*/
function fobonacci(n) {
if (n === 0) return 0;
if (n === 1) return 1;
return fobonacci(n - 1) + fobonacci(n - 2);
}
// 从上往下看，时间复杂度为O(n)
function fobonacci(n) {
var arr = [0, 1];
for (var i = 2; i <= n; i++) {
arr[i] = arr[i - 1] + arr[i - 2];
};
return arr[n];
}
基础排序
1，冒泡排序：
function bubleSort(arr){
var len=arr.length;
for(var i=0;i<len-1;i++){
for(var j=0; j<len-1-i;j++){
if(arr[j]>arr[j+1]){
var temp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
}
}
}
}
2，选择排序：
function selectionSort(arr){
var len=arr.length;
var minIndex,temp;
for(var i=0;i<len-i;i++){
minIndex=i;
for(var j=i+1;j<len;j++){
if(arr[j]<arr[minIndex]){
minIndex=j;
}
}
}
temp=arr[i];
arr[i]=arr[minIndex]
arr[minIndex]=temp
}
4，快速排序：
function quickSort(arr){
if(arr.length<=1){
retrun arr; // 递归出口
}
var left=[],
right=[],
current=arr.splice(0,1)
for(let i=0;i<arr.length;i++){
if(arr[i]<current){
left.push(arr[i])
}else{
right.push(arr[i])
}
}
return quickSort(left).concat(current,quickSort(right))
}