JavaScript(数组二冒泡、选择排序，去重)

sort方法可以进行排序，要学习的这两个排序方式，是实现sort内部排序的原理

如果有一天sort方法不能用了，我们也可以手动将数组进行排序

这两种排序方式是一些算法的基础，最简单的算法

冒泡排序：每相邻的两个元素进行大小比较，排除合适的顺序

var arr = [4,3,2,1];

需求：将arr进行升序排列

/*

冒泡原理：

3 和 2 进行比较，不符合我们规则，就交换这两个值的顺序 - 2 3 1

3 和 1 进行比较，不符合我们规则，就交换这两个值的顺序 - 2 1 3

2 和 1 进行比较，不符合我们规则，就交换这两个值的顺序 - 1 2 3

2 和 1 进行比较，符合我们规则，就什么也不做 - 1 2 3

*/

选择排序：

每次排序都要找到最小值或最大值放在最前面

下次排序还是在剩下的数据中找到最小值或最大值放在前面

var arr = [4,3,2,1]

需求：将数组按照升序排列

/*

原理：

第一轮，找最小值放在最前面

var min

4 3 2 1

1 3 2 4

第二轮，在剩下的数字中找最小值放在第二位

1 3 2 4

1 2 3 4

第三轮，在再剩下的数字中找最小值放在第三位

1 2 3 4

1 2 3 4

*/

去重

将数组中重复的元素去掉，让数组变成没有重复元素数组

var arr = [1,1,2,2,2,3,3,6,6,9,5,5,1,1,1,1]; // 1,2,3,6,9,5

1.遍历数组，将重复的元素删除

2.将所有不重复的元素放在一个新的数组中

3.利用对象的键不能重复，将所有元素作为对象的键，对象是有很多元素组成的，且是没有重复的。将对象中所有的键组成一个数组

遍历数组 - 怎么将重复元素找到

将重复元素删除

var arr = [1,1,1,1,1,1,2]
/*
当i=1
[1,1,1,1,1,1,2]
判断成立了 删除了下标1的元素
数组变成了：[1,1,1,1,1,2]

循环第一次结束；i++  i=2
判断成立 删除了下标2的元素
数组变成了： [1,1,1,1,2]

循环第一次结束；i++  i=3
断成立 删除了下标3的元素
数组变成了： [1,1,1,2]

循环第一次结束；i++  i=4
循环结束了
*/

for(var i=6; i<arr.length; i++) {
    // arr[i]代表遍历出来的所有元素
    if(arr[5] === arr[i]) {
        // 将arr[i]删除 - 数组.splice(开始下标, 1)
        arr.splice(i, 1)
        i-- // 因为下一个元素的下标会向前移动一位，所以需要判断下一个元素的话，就需要让他的下标-1
    }
}
console.log(arr);

//去重要进行多少次，有多少元素就进行多少次 - 遍历数组次
for(var j = 0; j < arr.length; j++) {
    //因为下面有j+1也作为数组的下标，所以j可以是最大下标，+1后，就没有元素了，所以让j的最大值变的小1一点
for(var j = 0; j < arr.length-1; j++) {

    for(var i=j+1; i<arr.length; i++) {
        if(arr[j] === arr[i]) {
            arr.splice(i, 1)
            i-- 
        }
    }

}
console.log(arr);

2.将不重复的元素都放在一个空数组中

var arr = [1,1,2,2,2,3,3,6,6,9,5,5,1,1,1,1];

// 需要将重复的元素判断出来，如果不重复了就放在一个空数组中

var brr = [] // 定义空数组用来存放所有不重复的元素

// 从arr中将不重复的元素找到

// 先将arr中的第一个元素放在空数组中

// 遍历arr，判断arr中的每个元素是否在brr中，如果在，不放进去，如果不在，就放进去

brr.push(arr[0])

// 遍历arr
for(var i=1; i<arr.length; i++) {
    // arr[i]是arr中的每个元素
    // 要判断每个元素是否在brr中 - 需要遍历brr
    for(var j=0; j<brr.length; j++) {
        if(arr[i] === brr[j]) {
            // 说明brr中已经有了arr[i]了 - 不放
            break;
        }
    }
    // 如果上面循环结束了，if也没有成立过一次，就放进去
    if(j === brr.length) { 
        brr.push(arr[i])
    }
}
console.log(brr);

3.利用对象中的键是不重复的

将arr中每个元素都当做对象的键

//定义一个空对象
var arr = [1,1,2,2,2,3,3,6,6,9,5,5,1,1,1,1];
var obj = {}
// 遍历数组，将每个元素都作为对象的键 - 值随意
for(var i=0; i<arr.length; i++) {
    // arr[i] 是每个值 - 当做obj的键放在obj中
    obj[ arr[i] ] = typeof arr[i]
}
console.log(obj);
// 将对象中所有键都放在一个数组中
var brr = [] // 定义空数组
// 遍历对象得到所有的键，将所有的键都放在brr中
for(var i in obj) {
    brr.push( obj[i] === 'number' ? Number(i) : i    )
}
console.log(brr);