數組及排序（冒泡、選擇、快速排序）

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]);
   }
}