javascript「數組」的經常使用方法---以及冒泡排序

時間 2020-07-18

標籤 javascript 數組經常使用方法以及冒泡排序欄目 JavaScript 简体版

原文原文鏈接

首先，數組是數據的集合。數組

能夠經過構造函數(var arr = new Array('0','1','hello'))和字面量(var arr = ['0','1'])的方式來建立，函數

須要注意的是，構造函數建立時，若是值只有一個，並且仍是數字，那麼他表明數組的長度(var arr = new Array(5),建立一個長度爲5的數組)。this

數組的索引是從0開始，length屬性能夠獲取數組的長度，同時也能夠改變數組的值。spa

length屬性如何改變數組的值？3d

當數組length爲0，或者數組爲[]時，數組清空。code

關於數組的存儲orm

--這個問題是咱們在使用數組時須要特別注意的問題！--blog

咱們有的時候會碰見這麼一個問題，當兩個數組的值同樣時，數組不相等，當把一個數組的值賦給另外一個數組，另外一個數組改變時，兩個數組都會發生改變。排序

數組屬於複雜類型(引用類型)數據，當咱們var一個arr時，變量存儲在棧內存，arr的值存儲在堆內存，而後給在棧內存中的arr一個地址，這個地址就是arr的值的地址(堆)。索引

每當咱們建立一個新數組，在堆內存中就給新數組新建一個位置。雖然數組裏的值相同，可是他們的地址不一樣，因此不相等。

而當咱們把arr賦值給arr3時，其實就是把arr數組的地址賦給了arr3，arr和arr3指向了同一個數組，因此當咱們改變arr3時，對應的原arr也會發生改變。

數組的經常使用方法

1. Array.isArray() --- 檢測是不是數組

2. push() --- 接受任意數量的參數，並逐個添加到數組末尾

3. pop() --- 從數組末尾移除最後一項

4. unshift() --- 在數組前面添加任意個項

5. shift() --- 移除數組中的第一個項

6. reverse() --- 翻轉數組項的順序

7. sort() --- 按照字母表升序排列數組項

但咱們排序數字時，就會出現問題

若是給數字排序，咱們須要藉助一個函數

1 function compare(a,b){
2      return a-b   
3 }

以上爲由小到大，若是由大到小排列，只需將函數內部return改成b - a便可。

8. concat() --- 克隆當前數組項，建立一個新數組，參數能夠是數組項或者數組

9. slice() --- 基於當前數組中的一個或多個項建立一個新數組。能夠接受一或兩個參數（索引位置）

10. splic() --- 對數組進行刪除、插入、替換，是最強大的數組方法，返回值是數組，改變原數組

刪除

參數1：從起始位置開始；參數2：刪除的長度

插入

參數2爲0時，從參數1對應原數組索引位置，後面添加項

替換

先刪除，後添加，添加是從參數1對應索引位置後面添加。

11. join() --- 將數組轉換成對應的字符串，參數就是鏈接符

原數組不變

12. indexOf() --- 返回要查找的相在數組中的位置，沒有找的狀況下返回-1

兩個參數，參1：查找的項；參2：查找的起點位置索引(可選)

13.lastIndexOf() --- 從數組的末尾開始向前查找，返回的索引位置仍是從前日後數

14. every() --- 對數組的每一項運行給定的函數，若是數組每一項都爲true，返回true，不然返回false

有兩個參數：參1是一個函數(回調函數)；參2(可選) this指向
參1是一個函數（回調函數），這個回調函數又有三個參數（數組項的值，數組項的索引位置，數組自己）

15. some() --- 對數組的每一項運行給定的函數，若是該函數對數組的任意一項都返回true，結果就返回true

16. filter() --- 對數組中的每一項運行給定的函數，返回該函數結果爲true的項組成的數組

17. map() --- 對數組中的每一項運行給定的函數，返回每次函數調用的結果組成的數組，返回的就是數組，不考慮true仍是false--映射

18. forEach() --- 從頭至尾遍歷數組，爲數組中的每一個元素調用給定的函數，沒有返回值

19. reduce() 和 reduceRight() --- 迭代數組的全部項，而後構建一個最終返回的值。每一次迭代獲得的結果回做爲下一次下一次迭代的初始值

方法都有兩個參數，參1：每一項執行的函數（有四個參數（前一個值，當前值，數組項索引，數組自己））; 參2：迭代的初始值(可選)

若是第二個參數省略，那麼就是用數組的第一項當作初始值，這就意味着第一次調用函數時使用了第一項和第二項值做爲函數的第一個和第二個參數

reduceRight()和reduce()原理同樣，但reduceRight()是從數組的最後一項逐個處理到第一項(從右到左)

冒泡排序

冒泡排序簡單說就是將數組的值進行兩兩比較，通常用來把亂序數組處理爲有序數組。

好比，將一個數組，裏面的值從小到大排列

可是，這並非最優的方式，咱們能夠看到，console.log(1)執行了100次。

每一輪比較，都能將最大值排在最後，因此每一輪的下一輪無需在與已經排在後面的最大值進行比

 
              第一輪            9次比較 
 
              5 8 3 2 15 67 98 12 3 25 
 
              5 3 8 2 15 67 98 12 3 25 
 
              5 3 2 8 15 67 98 12 3 25 
 
              5 3 2 8 15 67 98 12 3 25 
 
              5 3 2 8 15 67 98 12 3 25 
 
              5 3 2 8 15 67 98 12 3 25 
 
              5 3 2 8 15 67 12 98 3 25 
 
              5 3 2 8 15 67 12 3 98 25 
 
              5 3 2 8 15 67 12 3 25 98 -----選出最大值98 
 
              第二輪             8次比較 
 
              3 5 2 8 15 67 12 3 25 
 
              3 2 5 8 15 67 12 3 25 
 
              3 2 5 8 15 67 12 3 25 
 
              3 2 5 8 15 67 12 3 25 
 
              3 2 5 8 15 67 12 3 25 
 
              3 2 5 8 15 12 67 3 25 
 
              3 2 5 8 15 12 3 67 25 
 
              3 2 5 8 15 12 3 25 67 -----最大值67,67無需再跟98比較，由於上一輪已經比較了，最大值已經選出 
 
              第三輪             7次比較 
 
              2 3 5 8 15 12 3 25 
 
              2 3 5 8 15 12 3 25 
 
              2 3 5 8 15 23 3 25 
 
              2 3 5 8 15 23 3 25 
 
              2 3 5 8 15 23 3 25 
 
              2 3 5 8 15 3 23 25 
 
              2 3 5 8 15 3 23 25 ---同理本輪最大值25也無需在跟67,98比較，下面同理 
 
              第四輪             6次比較 
 
              2 3 5 8 15 3 23 
 
              2 3 5 8 15 3 23  
 
              2 3 5 8 15 3 23 
 
              2 3 5 8 15 3 23 
 
              2 3 5 8 3 15 23 
 
              第五輪             5次比較 
 
              2 3 5 8 3 15 
 
              2 3 5 8 3 15 
 
              2 3 5 8 3 15 
 
              2 3 5 3 8 15 
 
              2 3 5 3 8 15 
 
              第六輪             4次比較 
 
              2 3 5 3 8 
 
              2 3 5 3 8 
 
              2 3 3 5 8 
 
              2 3 3 5 8 
 
              第七輪             3次比較 
 
              2 3 3 5 --2跟3比較 
 
              2 3 3 5  
  --3跟3比較 
 
              2 3 3 5  
  --3跟5比較 
 
              第八輪              2次比較 
 
              2 3 3 --2 3 
 
              2 3 3 --3 3 
 
              第九輪              1次比較 
 
              2 3

總結：數組有10個數值，十個數值只須要進行9輪比較

輪數 = 數組length - 1

每一輪的比較次數 = 數組長度 - 當前輪數

for循環i從零開始，因此當前輪數 = i + 1

相同的結果，但此次console.log(1)只進行了45次。

 1         var a = [5, 8, 3, 2, 15, 67, 98, 12, 3, 25];
 2         for (let i = 0; i < a.length - 1; i++) {
 3             for (let j = 0; j < a.length - i - 1; j++) {
 4                 if (a[j] > a[j + 1]) {//若是從大到小，只需a[j]<a[j+1]  5                     let temp = a[j];
 6                     a[j] = a[j + 1];
 7                     a[j + 1] = temp;
 8                 }
 9                 console.log(1);//45次
10             }
11         }
12         console.log(a);//Array(10) [ 2, 3, 3, 5, 8, 12, 15, 25, 67, 98 ]