判断数组内是否有某一个数据————实现数组映射(放大 10 倍)—— 实现按序插入数组（修改bug）——实现数组去重

封装函数, 判断数组内是否有某一个数据

var arr  = [7,3,24,5,20,1,0,12,10,0,5]
function hasData(arr, data) {
    var res = arr.indexOf(data);
    return res !=-1 ? true : false;    
}

封装函数, 实现数组映射(放大 10 倍)

function mapArr(arr) {
    for(var i=0;i<arr.length;i++){
        arr[i] = arr[i]*10;
        console.log(arr[i]);
    }
}

算法实现：

封装函数, 实现按序插入数组

//判断升序还是降序
function fun(arr){
    var i =0
    while(true){       
        if(arr[i] != arr[i+1]){
            return arr[i]<arr[i+1] ? true:false
        }
        i++;
    }       
}


function insert(arr, data) {
    if(fun(arr)){
        if(data>=arr[arr.length-1]){
            arr.push(data)
            return 0
        }
        if(data<=arr[0]){
            arr.unshift(data)
            return 0
        }
        for(var i=0; i< arr.length; i++){
            if(data >= arr[i] && data <= arr[i+1]){
                console.log(arr[i],arr[i+1]);
                arr.splice(i+1,0,data)
                break;
            }
        }
    }else{
        if(data<=arr[arr.length-1]){
            arr.push(data)
            return 0
        }
        if(data>=arr[0]){
            arr.unshift(data)
            return 0
        }
        for(var i=0; i< arr.length; i++){
            if(data <= arr[i] && data >= arr[i+1]){
                // console.log(arr[i],arr[i+1]);
                arr.splice(i+1,0,data)
                break;
            }
        }
    }
}
//var arr = [1,4,8,9,12,12]
var arr = [12,12,8,6,2,1]
insert(arr,5)
console.log(arr);
console.log(fun(arr));

=> 提示:
-> 插入的数据可能和数组内部数据一样
-> 保持原有排序方式

还有最简单的方式：判断两头的大小，来确定到底是升序还是降序，然后打算从那一头开始遍历。遇到符合条件的数组方法，splice()

实现数组去重

=> 说明: 只考虑纯数字的数组
=> 提示: 当你删除数组某一项的时候, 后面索引会塌陷
这块果然有大坑，谨慎兄妹们！！！！！！（我晚饭时间都耽搁了）

算法实现：

var arr = [3,2,10,3,1,2,10,8,9,1,10,6,10];
console.log(arr);
//var arr = [8,1,8,8,90,90,8];
// var arr = [3,1,10,10,3,1,2];
var arr = [3,1,3,3,1,4]
console.log(arr);
var size = arr.length;
var count = 0;
for(var i=0; i<arr.length;i++){
    for(var j=i+1;j<arr.length;j++){
        if(arr[i] == arr[j]){
            console.log(`对比的当前下标是：${i}`);
            console.log(`重复项：${arr[j]},索引下标为${j}`);
            arr.splice(j,1)
            console.log("=>当前去重后：",arr);
            j--;
        }
        console.log(`<=======j是：${j}=========>`);
    }
}
console.log(arr);

---

1. 排序, 遍历

arr.sort()
    console.log('排序之后 : ', arr)
    // 遍历数组, 只要前一个和后一个一样, 删除一个
    for (var i = 0; i < arr.length; i++) {
      // 当前这个 arr[i]
      // 下一个 arr[i + 1]
      if (arr[i] === arr[i + 1]) {
        arr.splice(i, 1)
        i--
      }
    }

2. 第二个循环查找后面有没有长得一样的

for (var i = 0; i < arr.length; i++) {
      // i 当前这个数据的索引
      var repeat = arr.indexOf(arr[i], i + 1)
      // repeat 如果为 -1 说明后面没有了
      if (repeat === -1) continue
      // repeat 如果不为 -1, 那么 repeat 索引位置就是那个重复的数据
      arr.splice(repeat, 1)
      i--
    }
console.log('去重之后 : ', arr)

3. Set

ES2015 推出的一种数据结构, 特点: 不接受重复数据
语法结构创建: new Set([ 数据, 数据, 数据 ])
var s = new Set([ 10, 20, 30, 10, 20, 30 ])
console.log(s)
3-1. 利用 Set 数据结构把数组内的重复数据摒弃
var s = new Set(arr)
// console.log(s)
// 3-2. 把 s 还原成一个数组
// 语法: Array.from()
var r1 = Array.from(s)
console.log(r1)
// 语法: ... 运算符
var r2 = [ ...s ]
console.log(r2)
var r1 = [ ...new Set(arr) ]
var r2 = Array.from(new Set(arr))
console.log(r1, r2)

4. 计数排序的逻辑

var tmp = []
for (var i = 0; i < arr.length; i++) {
	  var item = arr[i]
	  tmp[item] = '随便'
}
arr = []
for (var i = 0; i < tmp.length; i++) {
	  if (!tmp[i]) continue
	  arr.push(i)
}
console.log(arr)

var tmp = {}
for (var i = 0; i < arr.length; i++) {
	  var item = arr[i]
	  tmp[item] = '随便'
}
arr = []
for (var k in tmp) {
	  arr.push(k - 0)
}
console.log(arr)

5. 创建新数组, 依次插入

var result = []
for (var i = 0; i < arr.length; i++) {
	 var item = arr[i]
	 // 判断, 如果 result 内没有 item 这个数据, 才向内插入
	 if (result.indexOf(item) === -1) result.push(item)
}
 console.log('去重之后 : ', result)