js手写题——数组去重和数组排序

数组去重

set去重

let arr = ['a', 'b', 'c', 'c', 'd', 'd']
const newArr = [...new Set(arr)]

indexOf 去重

//数组去重
let arr = ['a', 'b', 'c', 'c', 'd', 'd']

//方式1
const newArr = arr.filter((item, index)=>{
  // console.log(arr.indexOf(item), index, item)
  return arr.indexOf(item) == index
})

//方法2
function quchong(arr){
  var s= []
  for (let i = 0; i < arr.length; i++) {
    if(s.indexOf(arr[i]) == -1){
      s.push(arr[i])
    }
  }
  return s
}
var arr = [1,1,2,3,4,2,'4',5]
var a = quchong(arr)
console.log(a) //[1, 2, 3, 4, "4", 5]

// includes方式
const result = []
for (const v of arr) {
  if(!result.includes(v)){
    result.push(v)
  }
}

数组对象去重

//方式1
const arr = [
  {'name': 'ti', 'id': 1},
  {'name': 'yu', 'id': 2},
  {'name': 'ti', 'id': 3},
  {'name': 'yu', 'id': 4},
]

const newArr = arr.filter((item, index)=>{
  let myArr =[]
  arr.forEach(el=>{
    myArr.push(el.name)
  })
  console.log(myArr)

  return myArr.indexOf(item.name) === index
})

//方式2
const list = [
  { id: 1, a: 1 },
  { id: 2, a: 2 },
  { id: 3, a: 3 },
  { id: 1, a: 4 },
];

const result = list.reduce((acc,cur)=>{
  const ids = acc.map(item => item.id)
  return ids.includes(cur.id)? acc: [...acc, cur]
},[])

数组排序

sort排序

//数字排序
const arr = [3,2,4,1,5]
arr.sort((a, b)=> a-b)
console.log(arr)//[1, 2, 3, 4, 5]

//字母排序
const arr = ['b','c','a','e', 'd']
arr.sort()
console.log(arr)//['a', 'b', 'c', 'd', 'e']

冒泡排序

/**

*2*，7，4，1=>
2，*7*，4，1=>
2，4，*7*，1=>
2，4，1，*7*   // 这样就找到了最大数
*2*，4，1，7
2，*4*，1，7
2，1，*4*，7   // 这样就找到了次大数
*2*，1，4，7
1，*2*，4，7   // 次次大数（已经有序）
*1*，2，4，7   // 排序成功


由此可见：N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，
外层控制循环多少趟，内层控制每一趟的循环次数

优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。
如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，
第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，
第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，
以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。

**/


// 原理：
// a.将数组中第一个数和下一个数比较大小，第一个数小则不动，否则和第二个数交换位置
// b.将新的到的第二个数和第三个数比较，重复第一步步骤，直到倒数第二个数与数组最末尾的数比较大小，
// 这样就可以得到一个最大的数在末尾，既是冒泡
// c.忽略排好队数字，对原数组中剩下的数继续操作，直到所有数都排完

function aSort(arr) {
  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;
       }
     }
   }   
   return arr;
}

var myArr = [10,1,35,61,89,36,55]
//调用函数
var b = aSort(myArr)
console.log(b)  // [1, 10, 35, 36, 55, 61, 89]