冒泡排序算法

算法思想：

挨着的两个，两两比较，前一个比后一个大，交换位置

[78 67 55 89 38]

[67 78 55 89 38]

[67 55 78 89 38]

[67 55 78 38 89]

第一轮冒泡排序             元素          比较次数                
1                       5               5-1
2                       4               5-2
3                       3               5-3
4                       2               5-4
i                       n               n-1-i

n个数进行冒泡排序，外层循环进行n-1轮冒泡，内层循环进行n-1-冒泡次数


var arr = [78,67,55,89,38]
for(var i = 0;i < arr.length-1;i++){
    for(var j= 0; j < arr.length-1 -i; j++){
        if(arr[i] > arr[i+1]){
            var temp = arr[0]
            arr[i] = arr[i+1]
            arr[i+1] = temp
        }
    }
}

数组去重

方法一：利用indexOf

思想：1·定义一个新数组，用于存储不重复的元素

var newArr = []

2·遍历原数组，判断原数组是否在新数组中，如果数组中不存在，添加到新数组


var arr = [2,4,2,5,8,2,5]
var newArr = []//定义一个新数组存储不重复的元素
//遍历原数组
for(var i = 0; i<arr.length;i++){
    if(newArr.indexOf(arr[i]) == -1){
        newArr.push(arr[i])//添加到新数组newArr中
    }
}
console.log(newArr);

方法二：利用splice

分析：[2,4,2,5,8,2,5]

思想：让第一个数与后面的所有书进行比较，如果相同，截取想用的数

让第二个数与后面的所有书进行比较，如果相同，截取想用的数


function arrTwo(){
    var arr = [2,4,2,5,8,2,5]
    for(var i = 0; i < arr.length; i++){
        var item = arr[i]
        for(var j = i + 1; j < arr.length;j++){
            //让第一个数与后面的数进行比较
            if(item == arr[j]){//如果相同就截取
                arr.splice(j,1)
                j--
            }
        }
    }
    console.log(arr);
}
arrTwo()

选择排序

代码实现

未排序的元素中找最小元素，根第一个元素交换位置

var temp = arr[minIndex]

var[minIndex] = arr[0]

arr[0] = temp

最小元素

[78,67,55,89,38]

var min = arr[0]

for()


var arr = [78,67,55,89,38]
//重点： 外层循环选择排序次数，n个数进行n-1次选择排序
//      找未排序数列中最小数下标，与未排序数列的第一个元素交换位置
for(var i = 0; i < arr.length - 1; i++){
    //找未排序数列中最小数的下标
    var minIndex = i  //最小数的下标
    for(var j = i + 1; j < arr.length; j++){
        if(arr[j] < arr[minIndex]){
            minIndex = j
        }
    }
    var temp = arr[i]
    arr[i] = arr[minIndex]
    arr[minIndex] =temp
}
console.log(arr);

js 冒泡排序，选择排序