数组及排序（冒泡、选择、快速排序）

01.数组基础

1.数组

使用单独的变量名来存储一系列的值

简单的说，数组的作用，就是一个容器，将多个数据保存起来

2.声明数组的方法

1. 字面量 ：

   var arr = [];
   eg：
   var arr = ["兔子1","兔子2","兔子3","兔子4"];
   console.log(arr);

2. 构造函数方法：

   var arr = new Array();
    如果参数为一个数值：代表的是数组中的长度
       如果为多个值，则是数组内容
   eg:
   var arr = new Array(1,2,3,4);
   console.log(arr);

3.数组的取值

1. 利用数组的下角标 eg：arr[0] arr[1];

2. 数组里面的下标都是连续的

eg:
//取值
var arr = ["兔子1","兔子2","兔子3","兔子4"];
console.log(arr[0]);
​
//获取数组长度
console.log(arr.length);
​
//重新赋值
var arr = [1,2,3,4,5,6];
arr[3] = 10;
console.log(arr);

02.数组的遍历

1.遍历数组

根据数组的下标，从开始往后扫描，直到结束

2.遍历方法

(1) for 循环

(2) for in 循环 for in 常用来遍历对象

eg:
var arr = [1,2,3,4,5,6];
//for循环
for(i = 0 ; i < arr.length ; i++){
    console.log(arr[i]);
}
​
//for in循环
for(i in arr){
    console.log(arr[i]);
}

练习：
0、求data数组中所有数字的和
var arr = [1,2,3,4,5];
function arrSum(arr){   //arr形参
    var sum = 0;
    for(var i = 0 ; i < arr.length ; i++){
        sum += arr[i];
   }
    return sum;
}
console.log(arrSum(arr));    //arr实参
​
1、求平均成绩。
​
var arr = [1,2,3,4,5];
function fn(arr){
    var sum = 0;
    for (var i = 0 ; i < arr.length ; i++){
        sum += arr[i];
   }
    return sum / arr.length;
}
console.log(fn(arr));
​
2、把1 - 100 放在数组data中；
​
var arr = [];
for(var i = 0 ; i < 100 ; i++){
    arr[i] = i + 1;
}
console.log(arr);
​
3：随机点名程序Math.random()
​
var arr = ["disf","dfg","fdre","fh","gh"];
var randomIndex = parseInt(Math.random() * arr.length);   //下标
console.log(arr[randomIndex]);   
​
4. 编写函数map(arr) 把数组中的每一位数字都增加30%
​
    var arr = [1,2,3,4,5];
function map(arr){
    for(i = 0 ; i < arr.length ; i++){
        arr[i] *= 1.3;
   }
    return arr
}
console.log(map(arr));
​
5. 编写函数has(arr) 判断数组中是否存在60这个元素，返回布尔类型
​
方法一：
function has(arr,k){
    for(var i = 1 ; i < arr.length ; i++){
        if(arr[i] == k){
            return true;
       }
   }
    return false;
}
console.log(has([1,2,3,4,5],33));
​
方法二：
function has(arr, k) {
    var flag = false;
    for(var i = 0 ; i < arr.length ; i++){
        if(arr[i] == k){
            flag = true;
            break;
       }
   }
    if(flag){
        return "包含数字" + k;
   }else{
        return "不包含数字" + k;
   }
}
console.log(has([1,2,3,4,5],33));
​
6、把1 - 100 中能被3 与 5 整除的的数放在数组中
​
//方法一：
var arr = [],
    index = 0;   //由于数组下标是连续的，但是得到的结果是不连续的，所以，需要设置索引值，来代表下标
for(var i = 1 ; i <= 100 ; i++){
    if(i % 3 == 0 && i % 5 == 0){
        arr[index] = i;
        index++;
   }
}
console.log(arr);
​
//方法二：
var arr = [];
for(var i = 1 ;i <= 100 ; i++){
    if(i % 3 == 0 && i % 5 == 0){
        arr.push(i);
   }
}
console.log(arr);

03.数组的api

push()  在最后添加
pop()   取出最后一个
​
unshift()  在前面添加
shift()    取出第一个
​
reverse()   反转
​
sort()   方法，对数组排序
 参数为一个回调函数！！！
    如果没有参数：则是按照第一位ASCII码排列；
​
eg:
var arr = [5,2,1,7,6,10];
arr.sort(function(val1,varl2){
    return varl1 - val2;
});
console.log(arr);
​
arr.push(333);
console.log(arr);

04.数组的api2

concat()  数组的拼接，不会对原数组造成影响
join("")  将数组分割字符串，按照所填的字符。不会对原数组造成影响
toString()  将数组转成字符串
slice()   按照下标，数组的截取，不包括end ，不会对原数组造成影响
splice(start,deleteCount,arr)  从start开始，删除几个，arr新插入的数组元素。改变原数组
​
eg:
var arr1 = [1,2,3,4];
var arr2 = [2,3,4,3];
var newArr = arr1.concat(arr2);
console.log(newArr);       //newArr[8]
​
​
var arr1 = [1,2,3,4];
console.log(arr1.join("-"));    //1-2-3-4
​
var arr1 = [1,2,3,4]; 
console.log(arr1.toString());   //1,2,3,4
​
var arr1 = [1,2,3,4,5,6]; console.log(arr1.slice(0,3));   //[1,2,3];
​
var arr1 = ["nihao" , "www" , "kkk" , "ttt" , "dadsf"];
arr1.splice(1,3,'9994');
console.log(arr1);    //["nihao", "9994", "dadsf"]

05.数组的排序

1.冒泡排序

var arr = [9,8,7,6,5,2,1];
/*冒泡排序
       9,8,11,6,5,2,1
​
           第一轮：
               8   9   11 6   5   2   1
               8   9   11 6   5   2   1
               8   9   6   11 5   2   1
               8   9   6   5   11 2   1
               8   9   6   5   2   11 1
               8   9   6   5   2   1   11
​
           第二轮：
               8   9   6   5   2   1
               8   6   9   5   2   1
               8   6   5   9   2   1
               8   6   5   2   9   1
               8   6   5   2   1   9
​
           第三轮：
               8   6   5   2   1
               6   8   5   2   1
               6   5   8   2   1
               6   5   2   8   1
               6   5   2   1   8
​
           第四轮：
               6   5   2   1
               5   6   2   1
               5   2   6   1
               5   2   1   6
​
           第五轮：
               5   2   1
               2   5   1
               2   1   5
​
           第六轮：
               2   1
               1   2
​
​
       */
​
//冒泡排序
var arr = [2,3,4,6,2,0,4,3];
function bubbleSort(arr){
    //确定循环的轮数
    for(var i = 0 ; i < arr.length - 1 ; i++){
        //每一轮 数值的比较(两两比较的，每一轮最后一个都不用比较，所以-i;得到的最后一个和空的undefined比较了，所以-1，不用比较，提高算法的效率)
        for(var k = 0 ; k < arr.length - i - 1 ; k++){
            //谁大谁往后排
            if(arr[k] > arr[k+1]){
                var temp = arr[k];
                arr[k] = arr[k+1];
                arr[k+1] = temp;
           }
       }
   }
    return arr;
}
console.log(bubbleSort(arr));

2.选择排序

/*
选择排序(打擂台)
           var arr = [6,5,1,3,2]
​
               6   5   1   3   2
​
           第一轮：
               5   6   1   3   2
               1   6   5   3   2
               1   6   5   3   2
               1   6   5   3   2
​
           第二轮：
               6   5   3   2
               5   6   3   2
               3   5   6   2
               2   5   6   3
​
           第三轮：
               5   6   3
               5   6   3
               3   6   5
​
           第四轮：
               6   5
               5   6
​
​
       */
​
//选择排序
var arr = [2,3,4,6,2,0,4,3];
function chooseSort(arr){
    //确定循环的轮数(几轮)
    for(var i = 0 ; i < arr.length - 1 ; i++){
        //每一轮都和第一个位置的数值比较(让后面的都与第一位比较，所以是从i+1位开始,)
        for(var k = i + 1 ; k < arr.length ; k++){
            //谁小谁往前排(让每轮的第一位与后面的数进行比较.每一轮比较完得到较小的，就不再比较。确定了第一位arr[i])
            if(arr[i] > arr[k]){
                var temp = arr [i];
                arr[i] = arr[k];
                arr[k] = temp;
           }
       }
   }
    return arr;
}
console.log(chooseSort(arr));

3.快速排序

var arr = [10,30,50,20,40,70];
/*
           快速排序：
           [10 30]   (50) [20 40 70]         //取中间的一个值，让中间位置的值（50）与每一个值进行比较，自身不用和自身比较，直接continue跳出本次循环。
           [10 30]   ((20)) [40 (50) 70]       //小于等于中间值（50）的放在中间值的左侧，大的放在右侧，左侧重新确定中间位置的值为((20))
           [10] ((20))   [30 40 50 70]         //重复上述步骤，将((20))右侧重新确定中间位置，然后进行比较得到结果.....
           .....
       */
​
var arr = [3,2,8888,5,55,5,88,777777,11];
function quickSort(arr){
    //递归结束条件
    if(arr.length <= 1){
        return arr;
   }
    //取中间的值以及中间的下标
    var 
    midIndex = parseInt(arr.length / 2),    //取中间的下标
        midValue = arr[midIndex],        //取中间的值
        leftArr = [],    //创建左右的数组
        rightArr = [];
​
    //遍历arr数组。每一个值和中间的值相比较，大的放右侧数组。小的等的放左侧
    for(var i = 0 ; i < arr.length ; i++){
        //如果是中间下标的，跳出本次循环，（不用中间值和自身比较）
        if(i == midIndex){
            continue;
       }
        if(arr[i] <= midValue){
            leftArr.push(arr[i]);
       }else{
            rightArr.push(arr[i]);
       }
   }
    //利用递归处理左右的数组
    var res = quickSort(leftArr).concat(midValue).concat(quickSort(rightArr));
    return res;
}
console.log(quickSort(arr));

06.二维数组

//var arr = [1,2,3,4,4];  一维数组
​
var arr = [
   [1,2,3],
   [4,5,6],
   [7,8,9],
   [10,11,12]
]
//取值
for(var i = 0 ; i < arr.length ; i++){
    for(var k = 0 ; k < arr[i].length ; k++){
        console.log(arr[i][k]);
   }
}