js基础算法

//1.递归: 递归函数是在一个函数通过名字调用自身情况下构成的

function jiecheng(n) {//n=5
    if (n == 1) {//基点
        return 1;
    } else {
        return n * jiecheng(n - 1);
    }

}

alert(jiecheng(100));//9.33262154439441e+157 10的157次方。

//2.利用递归求斐波那契数列的前20项
// 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，

function fb(n) {//n:位置
    if (n == 1 || n == 2) {//基点
        return 1;
    } else {
        return fb(n - 1) + fb(n - 2)
    }
}

alert(fb(8));
for (var i = 1; i <= 20; i++) {
    document.write(fb(i) + ',');
}



//1.冒泡排序
//冒泡排序算法的原理如下：
//比较相邻的元素。如果第一个比第二个大，就交换他们两个。
//对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
//针对所有的元素重复以上的步骤，除了最后一个。
//持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
var arr = [9, 30, 4, 89, 75, 456, 2, 7, -100, 9];
var times = 0;//次数
for (var i = 0; i < arr.length - 1; i++) {//控制次数 -1:10个数字只需要两两比较9次。
    for (var j = 0; j < arr.length - i - 1; j++) {//-i:i循环一次，j循环到底，每一次i的循环都已经排好一个数字。
        if (arr[j] > arr[j + 1]) {
            var temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
        times++;
    }
}
console.log(arr);
console.log(times);

//2.选择排序

//选择排序（Selection sort）是一种简单直观的排序算法。
//它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，
//直到全部待排序的数据元素排完。
var arr = [9, 300, 4, 890, 7500, 456, 20, 70, -100, -9];
for (var i = 0; i < arr.length; i++) {
    var minindex = i;//假设最小值的下标
    var minvalue = arr[minindex];//假设最小值

    for (var j = i + 1; j < arr.length; j++) {
        if (minvalue > arr[j]) {
            minvalue = arr[j];
            minindex = j;
        }
    }
    //如果上面的for循环完成，代表minindex就是最小值的下标。
    if (minindex != i) {//如果minindex!=i说明找到了真正的最小值。否则就代表假设的刚好就是最小值。
        var temp = arr[minindex]
        arr[minindex] = arr[i];
        arr[i] = temp;
    }
}
console.log(arr);


//3.快速排序(去重)

//在数组中截取中间值，中间值可以任意获取。--splice
//剩余的数组项都和中间值进行比较，如果比中间值小，放置在一个数组中，比中间值大，放到另外一个数组中。
//分别对上面的两个数组重复上面的操作--递归
//最终利用concat进行拼接。输出结果

var arr = [9, 300, 4, 890, 7500, 456, 20, 70, -100, -9];
function quicksort(array) {
    if (array.length <= 1) {
        return array;
    } else {
        var midindex = parseInt(array.length / 2);//获取中间索引
        var midvalue = array.splice(midindex, 1)[0];//获取中间值
        var left = [];
        var right = [];
        for (var i = 0; i < array.length; i++) {
            if (array[i] < midvalue) {
                left.push(array[i]);
            } else {
                right.push(array[i]);
            }
        }
        return quicksort(left).concat(midvalue, quicksort(right));
    }
}
console.log(quicksort(arr));


//indexOf去重
var arr = [9, 301, 4, 8900, 4, 7500, 4156, 20, 70, 4156, -100, -9, 9, 9, 4, 8900, 20];
var newarr = [];
for (var i = 0; i < arr.length; i++) {
    if (newarr.indexOf(arr[i]) == -1) {
        newarr.push(arr[i]);
    }
}
console.log(arr);
console.log(newarr);


var arr = [9, 301, 4, 8900, 4, 7500, 4156, 20, 70, 4156, -100, -9, 9, 9, 4, 8900, 20];

var newarr = arr.filter(function (value, index, array) {

    return arr.indexOf(value) == index;//数组项的索引是否等于当前索引。

});

console.log(newarr);


var arr = [1, 7, 5, 6, 4, 1, 2, 6];
function norepeat(arr) {
    for (var i = 0; i < arr.length; i++) {
        for (var j = i + 1; j < arr.length; j++) {
            if (arr[j] == arr[i]) {
                arr.splice(i, 1);
                arr.length - 1;
                j--;
            }
        }
    } return arr;
} console.log(norepeat(arr));

//递归深拷贝
function deepclone(obj) {
    var cloneobj = Array.isArray(obj) ? [] : {};
    if (obj && typeof obj === "object") {
      for (i in obj) {
        if (obj.hasOwnProperty(i)) {
          if (obj[i] && typeof obj[i] === "object") {
            cloneobj[i] = deepclone(obj[i]);
          } else {
            cloneobj[i] = obj[i];
          }
        }
      }
    }
    return cloneobj;
  }
  let a = [1, 2, 3, { a: 9, b: 8, c: 7, d: 6 }];
  b = deepclone(a);
  console.log(a, b);