冒泡排序

for(var i=0;i<arr.length-1;i++){
        for(var j=0;j<arr.length-1-i;j++){
            if(arr[j]>arr[j+1]){   //就是两个两个比较 大的往后排
                var temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
console.log(arr)

选择排序

 for(var i=0;i<arr.length-1;i++){
        //执行一轮代码
        //1.假设最小
       var min=i;  //下标 
        //2.开始遍历
       for(var j=i+1;j<arr.length;j++){
        //如果下标所对应的元素 小于 arr的第 j 项  把j的值赋给min(给的是下标)  就把最小值的下标拿到了
          if(arr[min]>arr[j]) min=j; 
       }
        //3.进行交换
       var temp=arr[i];
       arr[i]=arr[min];
       arr[min]=temp;
  }
console.log(arr)

快速排序

 function quickSort(arr){
            if(arr.length<=0) return arr;

            var n=~~(arr.length/2);  //取中间值的索引
            var current=arr[n];      //中间值
            var left=[],right=[];   //准备一左 一右 空数组

            for(var i=0;i<arr.length;i++){
                if(i===n) continue; //循环到中间值时  不做处理

                if(arr[i]<=current) left.push(arr[i]);//如果数值比中间值小 放左空数组
                else right.push(arr[i]);             //否则 放在右空数组
            }
           return  quickSort(left).concat(current,quickSort(right));//拼接在一起
        }

       var arr1=quickSort(arr);
       console.log(arr1) 

数组去重1

方案1:
    => 准备一个新数组
    => 遍历原始数组, 把原始数组内每一个依次插入到新数组内
    => 在插入的时候, 要进行判断, 如果新数组内没有, 才插入
    
 var arr2 = []
// 遍历原始数组
for (var i = 0; i < arr.length; i++) {
  // 判断 arr2 内没有 arr[i] 这个数据, 才插入
  // 问题: 如何判断 arr2 内没有某一个数据
  // indexOf 结果为 -1 的时候, 表示没有
  if (arr2.indexOf(arr[i]) === -1) arr2.push(arr[i])
}
console.log('结果 : ', arr2)

数组去重2

方案2:
    => 拿出第一个数字
    => 判断后面还有没有这个数字, 如果有直接删除
    
for (var i = 0; i < arr.length; i++) {
  // 判断 [i + 1] 位置以后还有没有 arr[i] 这个数据 【数组.indexOf(要查找的数据, 开始索引)】
  var index = arr.indexOf(arr[i], i + 1)

  if (index !== -1) {
    // 表示有这个数据
    // 删除一个      【数组.splice(开始索引, 多少个)】
    arr.splice(index, 1)
    i--
  }
}

console.log('去重之后 : ', arr)

数组去重3

方案3:
    => 首先排序, 一样的元素是相邻的
    => 只需要循环判断, 相邻元素如果一样, 删除一个
    
arr.sort()     //数组.sort()-> 按照一位一位来进行排序
console.log('排序之后 : ', arr)
// 循环遍历
for (var i = 0; i < arr.length; i++) {
  // 比较当前这个和下一个
  if (arr[i] === arr[i + 1]) {
    arr.splice(i, 1)
    i--
  }
}
console.log('去重之后 : ', arr)     

数组去重4

方案5:
    => 利用 Set 数据结构
    => Set 数据结构
      -> 是一个类似于数组的数据结构
      -> 但是不接受重复数据
      -> 语法: var s = new Set([ 数据1, 数据2, 数据3, ... ])
      
var arr = [ 1, 2, 6, 8, 4, 3, 1, 3, 4, 5, 6, 3, 2, 1, 3, 4, 5 ]
var s = new Set(arr)
console.log(s)     

数组去重5

  var arr1=[];
    for(var i=0;i<arr.length;i++){
        var bool=true;
        for(var j=0;j<arr1.length;j++){
            if(arr[i]===arr1[j]){
                bool=false;
                break;
            }
        }
        if(bool){
            arr1.push(arr[i]);
        }
    }

数组去重6

   var arr1=[];
      xt:for(var i=0;i<arr.length;i++){
            for(var j=0;j<arr1.length;j++){
                if(arr[i]===arr1[j]) continue xt;
            }
            arr1.push(arr[i]);
        }

        console.log(arr1)

找相同的放在新数组中

 var arr = [1, 2, 3, 1, 2, 3, 2, 1, 4, 5, 1, 2, 3, 5, 6, 3, 4];
 var arr1 = [5, 2, 6, 8, 0, 5, 4, 6, 7, 9, 0];

 // 找相同的放在新数组中
 var arr2=[];
 for(var i=0;i<arr.length;i++){
     if(arr1.includes(arr[i]) && !arr2.includes(arr[i])) arr2.push(arr[i]);
 }
 console.log(arr2)

 //或
 var arr2=arr.reduce(function(v,t){
     if(!v.includes(t) && arr1.includes(t)) v.push(t);
     return v;
 },[]);
 console.log(arr2)

找不相同的放在新数组中

var arr = [1, 2, 3, 1, 2, 3, 2, 1, 4, 5, 1, 2, 3, 5, 6, 3, 4];
var arr1 = [5, 2, 6, 8, 0, 5, 4, 6, 7, 9, 0];

var arr2=arr1.reduce(function(v,t){
        if(!v.includes(t) && !arr.includes(t)) v.push(t);
        return v;
    },arr.reduce(function(v,t){
        if(!v.includes(t) && !arr1.includes(t)) v.push(t);
        return v;
    },[]));
    console.log(arr2)