一、数组去重
1、简单的去重方法
// 最简单数组去重法
/*
* 新建一新数组，遍历传入数组，值不在新数组就push进该新数组中
* IE8以下不支持数组的indexOf方法
*/
function uniq(array){
var temp = []; //一个新的临时数组
for(var i = 0; i < array.length; i++){
if(temp.indexOf(array[i]) == -1){
temp.push(array[i]);
}
}
return temp;
}
var newArray = [1,2,2,4,9,6,7,5,2,3,5,6,5];
console.log(uniq(newArray));// [1, 2, 4, 9, 6, 7, 5, 3]
/*
var newArray = ['mu','zi','dig','big','z','mu','zi','muzidigbig']
console.log(uniq(newArray));//["mu", "zi", "dig", "big", "z", "muzidigbig"]
*/
2、对象键值法去重
/*
* 速度最快， 占空间最多（空间换时间）
*
* 该方法执行的速度比其他任何方法都快， 就是占用的内存大一些。
* 现思路：新建一js对象以及新数组，遍历传入数组时，判断值是否为js对象的键，
* 不是的话给对象新增该键并放入新数组。
* 注意点：判断是否为js对象键时，会自动对传入的键执行“toString()”，
* 不同的键可能会被误认为一样，例如n[val]-- n[1]、n["1"]；
* 解决上述问题还是得调用“indexOf”。*/
function uniq(array){
var temp = {}, r = [], len = array.length, val, type;
for (var i = 0; i < len; i++) {
val = array[i];
type = typeof val;
if (!temp[val]) {
temp[val] = [type];
r.push(val);
} else if (temp[val].indexOf(type) < 0) {
temp[val].push(type);
r.push(val);
}
}
return r;
}
var newArray = [1,2,"2",4,9,"a","a",2,3,5,6,5];
console.log(uniq(newArray)); //[1, 2, "2", 4, 9, "a", 3, 5, 6]
3、数组下标法
/*
* 还是得调用“indexOf”性能跟方法1差不多，
* 实现思路：如果当前数组的第i项在当前数组中第一次出现的位置不是i，
* 那么表示第i项是重复的，忽略掉。否则存入结果数组。
*/
function uniq(array){
var temp = [];
for(var i = 0; i < array.length; i++) {
//如果当前数组的第i项在当前数组中第一次出现的位置是i，才存入数组；否则代表是重复的
if(array.indexOf(array[i]) == i){
temp.push(array[i])
}
}
return temp;
}
var newArray = [1,2,"2",4,9,"a","a",2,3,5,6,5];
console.log(uniq(newArray));//[1, 2, "2", 4, 9, "a", 3, 5, 6]
4、排序后相邻去除法
/*
* 给传入数组排序，排序后相同值相邻，
* 然后遍历时,新数组只加入不与前一值重复的值。
* 会打乱原来数组的顺序
*/
function uniq(array){
array.sort();
console.log(array.sort());
var temp=[array[0]];
for(var i = 1; i < array.length; i++){
if( array[i] !== temp[temp.length-1]){
temp.push(array[i]);
}
}
return temp;
}
var newArray = [1,2,"2",4,9,"a","a",2,3,5,6,5];
console.log(uniq(newArray));//[1, "2", 2, 3, 4, 5, 6, 9, "a"]
5、优化遍历数组法
// 思路：获取没重复的最右一值放入新数组
/*
* 推荐的方法
* 方法的实现代码相当酷炫，
* 实现思路：获取没重复的最右一值放入新数组。
* （检测到有重复值时终止当前循环同时进入顶层循环的下一轮判断）
*/
function uniq(array){
var temp = [];
var index = [];
var l = array.length;
for(var i = 0; i < l; i++) {
for(var j = i + 1; j < l; j++){
if (array[i] === array[j]){
i++;
j = i;
}
}
temp.push(array[i]);
index.push(i);
}
console.log(index);//[0, 2, 5, 6, 7, 8, 9]
return temp;
}
var newArray = [1,2,2,3,5,3,6,5,'3','muzi'];
console.log(uniq(newArray));// [1, 2, 3, 6, 5, "3", "muzi"]
6、数组includes()去重
//利用数组原型对象上的includes方法
function unique(arr){
var bArr= [];
for(var i=0; i<arr.length; i++){
if( !bArr.includes(arr[i]) ){ // 如果bArr新数组包含当前循环item
bArr.push(arr[i]);
}
}
return bArr;
}
var newArray = [1,2,2,3,5,3,6,5,'3','muzi'];
console.log(unique(newArray))//[1, 2, 3, 5, 6, "3", "muzi"]
7、数组原型对象上的filter和includes方法
//利用数组原型对象上的filter和includes方法
function unique(arr){
var bArr= [];
bArr=arr.filter(function(item){
return bArr.includes(item) ? null : bArr.push(item);
});
return bArr;
}
var newArray = [1,2,2,3,5,3,6,5,'3','muzi'];
console.log(unique(newArray))//[1, 2, 3, 5, 6, "3", "muzi"]
8、数组原型对象上的forEach和includes方法
//利用数组原型对象上的forEach和includes方法
function unique(arr){
var bArr= [];
arr.forEach(function(item){
bArr.includes(item) ? null : bArr.push(item);
});
return bArr;
}
var newArray = [1,2,2,3,5,3,6,5,'3','muzi'];
console.log(unique(newArray))//[1, 2, 3, 5, 6, "3", "muzi"]
9、数组原型对象上的 splice 方法
function unique(arr) {
var i,j,len = arr.length;
for (i = 0; i < len; i++) {
for (j = i + 1; j < len; j++) {
if (arr[i] == arr[j]) {
arr.splice(j, 1);
len--;
j--;
}
}
}
return arr;
}
console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4])); //[1, 2, 3, 5, 6, 7, 4]
10、数组原型对象上的 lastIndexOf 方法
function unique(arr) {
var res = [];
for (var i = 0; i < arr.length; i++) {
res.lastIndexOf(arr[i]) !== -1 ? '' : res.push(arr[i]);
}
return res;
}
console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));//[1, 2, 3, 5, 6, 7, 4]
11、原型对象去重
Array.prototype.unique = function(){
var arr=[]; //定义一个临时数组
for(var i = 0; i < this.length; i++){ //循环遍历当前数组
//判断当前数组下标为i的元素是否已经保存到临时数组
//如果已保存，则跳过，否则将此元素保存到临时数组中
if(arr.indexOf(this[i]) == -1){
arr.push(this[i]);
}
}
return arr;
};
var newArray = [1,4,1,1,3,3,4,6,7,8,3,7,0,2,11,2,'muzi','digbig','muzi'];
console.log(newArray.unique());//[1, 4, 3, 6, 7, 8, 0, 2, 11, "muzi", "digbig"]
12、es6去重
let arr = [1,2,2,3,4,4,4];
let s = new Set(arr);
//结果：Set {1,2,3,4}
let newArray = Array.from(s);
console.log(newArray); //[1, 2, 3, 5, 6, 7, 4]
二、数组排序
1、冒泡排序
var bubbleSort = function(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]; //元素交换
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
console.log(bubbleSort([1,4,3,6,7,8,5,2,11])) //[1, 2, 3, 4, 5, 6, 7, 8, 11]
function bubbleSort(arr) {
for(let i = 0,l=arr.length;i<l-1;i++) {
for(let j = i+1;j<l;j++) {
if(arr[i]>arr[j]) {
let tem = arr[i];
arr[i] = arr[j];
arr[j] = tem;
}
}
}
return arr;
}
module.exports = bubbleSort;
2、插入排序
var insertSort = function(arr) {
var len = arr.length;
var preIndex, current;
for(var i = 1; i < len; i++){
preIndex = i - 1;
current = arr[i];
while(preIndex >= 0 && arr[preIndex] > current){
arr[preIndex + 1] = arr[preIndex];
preIndex--;
}
arr[preIndex + 1] = current;
}
return arr;
}
console.log(insertSort([1,4,3,6,7,8,5,2,11])) //[1, 2, 3, 4, 5, 6, 7, 8, 11]
3、快速排序
var quickSort = function(arr) {
if(arr.length < 1) {//如果数组就是一项，那么可以直接返回
return arr;
}
var centerIndex = Math.floor(arr.length / 2);//获取数组中间的索引
var centerValue = arr.splice(centerIndex, 1)[0];;//获取数组中间项
var left = [], right = [];
for(var i = 0; i < arr.length; i++){
if(arr[i] < centerValue){
left.push(arr[i]);
}else{
right.push(arr[i]);
}
}
return quickSort(left).concat([centerValue], quickSort(right));//递归调用
}
console.log(quickSort([1,4,3,6,7,8,5,2,11])) //[1, 2, 3, 4, 5, 6, 7, 8, 11]
4、使用 sort() 对数组排序
JavaScript sort() 方法能够根据一定条件对数组元素进行排序。如果调用 sort() 方法时没有传递参数，则按字母顺序对数组中的元素进行排序。
var a = ["a","e","d","b","c"]; //定义数组
a.sort(); //按字母顺序对元素进行排序
console.log(a); //返回数组[a,b,c,d,e]
使用 sort() 方法时，应该注意下面几个问题
（1）所谓的字母顺序，实际上是根据字母在字符编码表中的顺序进行排列的，每个字符在字符表中都有一个唯一的编号。
（2）如果元素不是字符串，则 sort() 方法试图把数组元素都转换成字符串，以便进行比较。
（3）sort() 方法将根据元素值进行逐位比较，而不是根据字符串的个数进行排序。
var a = ["aba","baa","aab"]; //定义数组
a.sort(); //按字母顺序对元素进行排序
console.log(a); //返回数组[aab,aba,baa]
在排序时，首先比较每个元素的第 1 个字符，在第 1 个字符相同的情况下，再比较第 2 个字符，以此类推。
（4）在任何情况下，数组中 undefined 的元素都被排序在末尾。
（5）sort() 方法是在原数组基础上进行排序操作的，不会创建新的数组。
sort() 方法不仅按字母顺序进行排序，还可以根据其他顺序执行操作。这时就必须为方法提供一个函数参数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。排序函数应该具有两个参数 a 和 b，其返回值如下。
-
如果根据自定义评判标准，a 小于 b，在排序后的数组中 a 应该出现在 b 之前，就返回一个小于 0 的值。
-
如果 a 等于 b，就返回 0。
-
如果 a 大于 b，就返回一个大于 0 的值。
示例1
在下面示例中，将根据排序函数比较数组中每个元素的大小，并按从小到大的顺序执行排序。
function f(a,b) { //排序函数
return (a - b); //返回比较参数
}
var a = [3,1,2,4,5,7,6,8,0,9]; //定义数组
a.sort(f); //根据数字大小由小到大进行排序
console.log(a); //返回数组[0,1,2,3,4,5,6,4,7,8,9]
如果按从大到小的顺序执行，则让返回值取反即可。代码如下：
function f(a,b) { //排序函数
return -(a - b); //取反并返回比较参数
}
var a = [3,1,2,4,5,7,6,8,0,9]; //定义数组
a.sort(f); //根据数字大小由小到大进行排序
console.log(a); //返回数组[9,8,7,6,5,4,3,2,1,0]
示例2
根据奇偶性质排列数组。
sort() 用法比较灵活，主要是函数排序比较。例如，如果根据奇偶数顺序排序数组，只需要判断顺序函数中两个参数是否为奇偶数，并决定排列顺序。
function f(a, b) { //排序函数
var a = a % 2; //获取参数a的奇偶性
var b = b % 2; //获取参数b的奇偶性
if (a == 0) return 1; //如果参数a为偶数，则排在左边
if (b == 0) return -1; //如果参数b为偶数，则排在右边
}
var a = [3,1,2,4,5,7,6,8,0,9]; //定义数组
a.sort(f); //根据数字大小由大到小进行排序
console.log(a); //返回数组[3, 1, 5, 7, 9, 2, 4, 6, 8, 0]
sort() 方法在调用排序函数时，对每个元素值传递给排序函数，如果元素值为偶数，则保留其位置不动；如果元素值为奇数，则调换参数 a 和 b 的显示顺序，从而实现对数组中所有元素执行奇偶排序。如果希望偶数排在前面，奇数排在后面，则只需要取返回值。排序函数如下。
function f(a, b) {
var a = a % 2;
var b = b % 2;
if (a == 0) return -1;
if (b == 0) return 1;
}
var a = [3,1,2,4,5,7,6,8,0,9]; //定义数组
a.sort(f); //根据数字大小由大到小进行排序
console.log(a); //返回数组[0, 8, 6, 4, 2, 3, 1, 5, 7, 9]
示例3
不区分大小写排序字符串。
在正常情况下，对字符串进行排序是区分大小写的，这是因为每个大写字母和小写字母在字符编码表中的顺序是不同的，大写字母大于小写字母。
var a = ["aB", "Ab", "Ba", "bA"]; //定义数组
a.sort(); //默认方法排序
console.log(a); //返回数组["Ab", "Ba", "aB", "bA"]
大写字母总是排在左侧，如果让小写字母总是排在左侧，可以设计：
function f(a ,b) {
return (a < b);
}
var a = ["aB", "Ab", "Ba", "bA"]; //定义数组
a.sort(f); //默认方法排序
console.log(a); //返回数组["aB", "Ab", "Ba", "bA"]
对于字母比较大小时，JavaScript 是根据字符编码大小来决定的，当为 true 时，则返回 1；为 false 时，则返回 -1。
如果不希望区分大小写，大写字母和小写字母按相同顺序排列，可以设计：
function f(a, b) {
var a = a.toLowerCase;
var b = b.toLowerCase;
if (a < b) {
return -1;
}
else {
return 1;
}
}
var a = ["aB", "Ab", "Ba", "bA"]; //定义数组
a.sort(f); //默认方法排序
console.log(a); //返回数组["aB", "Ab", "Ba", "bA"]
如果要调整排列顺序，则设置返回值取反即可。
示例4
把浮点数和整数分开显示。
function f(a, b) { //排序函数
if (a > Math.floor(a)) return 1; //如果a是浮点数，则调换位置
if (b > Math.floor(b)) return -1; //如果b是浮点数，则调换位置
}
var a = [3.5555, 1.23456, 3, 2.11111, 5, 7, 3]; //定义数组
a.sort(f); //进行筛选
console.log(a); //返回数组[3, 5, 7, 3, 3.5555, 1.23456, 2.11111]
如果要调整排序顺序，则设置返回值取反即可。
