對排序算法的研究

算法是什么？、

算法（Algorithm）?代表著用系統的方法描述解決問題的策略機制，可以通過一定規范的?輸入，在有限時間內獲得所需要的?輸出。

一個算法的好壞是通過?時間復雜度?與?空間復雜度?來衡量的。

簡單來說，時間復雜度?就是執行算法的?時間成本?，空間復雜度?則是執行算法的?空間成本?。

時間復雜度?與?空間復雜度?都是用?“大O”?來表示，寫作?O(*)。有一點值得注意的是，我們談論復雜度，一般談論的都是時間復雜度。

常見時間復雜度的?“大O表示法”?描述有以下幾種：

時間復雜度非正式術語
O(1)常數階
O(n)線性階
O(n2)平方階
O(log n)對數階
O(n log n)線性對數階
O(n3)立方階
O(2n)指數階

一個算法在N規模下所消耗的時間消耗從大到小如下：

O(1) < O(log n) < O(n) < O(n log n) < O(n2) < O(n3) < O(2n)

常見的排序算法

1.O(n2)?的排序算法

  • 冒泡排序

  • 選擇排序

  • 插入排序

  • 希爾排序

2.O(n log n)?的排序算法

  • 歸并排序

  • 快速排序

  • 堆排序

3.線性的排序算法

  • 計數排序

  • 桶排序

  • 基數排序

冒泡排序

冒泡排序之所以叫冒泡排序，是因為它每一種元素都像小氣泡一樣根據自身大小一點一點往數組的一側移動。

算法步驟如下：

  1. 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個；

  2. 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素會是最大的數；

  3. 針對所有的元素重復以上的步驟，除了最后一個；

  4. 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

const?bubbleSort?=?arr?=>?{
????const?len?=?arr.length?-?1
????for?(let?i?=?0;?i?<?len;?++i)?{?/*?外循環為排序趟數，len個數進行len-1趟?*/
????????for?(let?j?=?0;?j?<?len?-?i;?++j)?{?/*?內循環為每趟比較的次數，第i趟比較len-i次?*/
????????????if?(arr[j]?>?arr[j?+?1])?{?/*?相鄰元素比較，若逆序則交換（升序為左大于右，逆序反之）?*/
????????????????[arr[j],?arr[j?+?1]]?=?[arr[j?+?1],?arr[j]]
????????????}
????????}
????}
????return?arr
}

選擇排序（Selection sort）?是一種簡單直觀的排序算法。

選擇排序的主要優點與數據移動有關。

如果某個元素位于正確的最終位置上，則它不會被移動。

選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，因此對?n?個元素的表進行排序總共進行至多?n - 1?次交換。在所有的完全依靠交換去移動元素的排序方法中，選擇排序屬于非常好的一種。

選擇排序的算法步驟如下：

  1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；

  2. 然后，再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾；

  3. 以此類推，直到所有元素均排序完畢。

代碼實現：

? ??const?selectionSort?=?arr?=>?{
????const?len?=?arr.length
????let?min
????for?(let?i?=?0;?i?<?len?-?1;?++i)?{
????????min?=?i?/*?初始化未排序序列中最小數據數組下標?*/
????????for?(let?j?=?i?+?1;?j?<?len;?++j)?{?/*?訪問未排序的元素?*/
????????????if?(arr[j]?<?arr[min])?{?/*?找到目前最小值?*/
????????????????min?=?j?/*?記錄最小值?*/
????????????}
????????}
????????[arr[i],?arr[min]]?=?[arr[min],?arr[i]]?/*?交換位置?*/
????}
????return?arr
}

插入排序

插入排序（Selection sort）?是一種簡單直觀的排序算法。

它的工作原理是通過構建有序序列，對于未排序數據，在已排序序列中從后向前掃描，找到相應位置并插入。

插入排序的算法步驟如下：

  1. 從第一個元素開始，該元素可以認為已經被排序；

  2. 取出下一個元素，在已經排序的元素序列中從后向前掃描；

  3. 如果該元素（已排序）大于新元素，將該元素移到下一位置；

  4. 重復步驟3，直到找到已排序的元素小于或者等于新元素的位置；

  5. 將新元素插入到該位置后；

  6. 重復步驟2~5。

const?insertionSort?=?arr?=>?{
????const?len?=?arr.length
????let?j,?temp
????for?(let?i?=?0;?i?<?len;?++i)?{
????????j?=?i?/*?存儲當前索引，便于后續與數組其他元素對比?*/
????????while?(j?>?0?&&?arr[j?-?1]?>?temp)?{
????????????arr[j]?=?arr[j?-?1]
????????????j--
????????}
????????[arr[j],?arr[i]]?=?[arr[i],?arr[i]]
????}
????return?arr
}

希爾排序

希爾排序，也稱?遞減增量排序算法，是?插入排序?的一種更高效的改進版本。希爾排序是非穩定排序算法。

希爾排序是基于插入排序的以下兩點性質而提出改進方法的：

  1. 插入排序在對幾乎已經排好序的數據操作時，效率高，即可以達到?線性排序?的效率；

  2. 但插入排序一般來說是低效的，因為插入排序每次只能將數據移動一位。

步長的選擇是希爾排序的重要部分。

只要最終步長為1任何步長序列都可以工作。

算法最開始以一定的步長進行排序。

然后會繼續以一定步長進行排序，最終算法以步長為1進行排序。

當步長為1時，算法變為普通插入排序，這就保證了數據一定會被排序。

插入排序的算法步驟如下：

  1. 定義一個用來分割的步長；

  2. 按步長的長度K，對數組進行K趟排序；

  3. 不斷重復上述步驟。

const?shellSort?=?arr?=>?{
????let?gaps?=?[5,?3,?1]?//?定義步長以及分割次數
????let?len?=?arr.length
????for?(let?g?=?0,?gLen?=?gaps.length;?g?<?gaps.length;?++g)?{
????????for?(let?i?=?gaps[g];?i?<?len;?++i)?{
????????????let?j
????????????for?(j?=?i;?j?>=?gaps[g]?&&?arr[j?-?gaps[g]]?>?arr[i];?j?-=?gaps[g])?{
????????????????arr[j]?=?arr[j?-?gaps[g]]
????????????}
????????????[arr[i],?arr[j]]?=?[arr[j],?arr[i]]
????????}
????}
????return?arr
}

快速排序

快速排序（Quicksort），又稱?劃分交換排序（partition-exchange sort）?。

快速排序（Quicksort）?在平均狀況下，排序?n?個項目要?O(n log n)?次比較。在最壞狀況下則需要?O(n2)?次比較，但這種狀況并不常見。事實上，快速排序?O(n log n)?通常明顯比其他算法更快，因為它的?內部循環（inner loop）?可以在大部分的架構上很有效率地達成。

快速排序使用?分治法（Divide and conquer）?策略來把一個序列分為較小和較大的2個子序列，然后遞歸地排序兩個子序列。

快速排序的算法步驟如下：

  1. 挑選基準值：從數列中挑出一個元素，稱為?“基準”（pivot）?；

  2. 分割：重新排序序列，所有比基準值小的元素擺放在基準前面，所有比基準值大的元素擺在基準后面（與基準值相等的數可以到任何一邊）。在這個分割結束之后，對基準值的排序就已經完成；

  3. 遞歸排序子序列：遞歸地將小于基準值元素的子序列和大于基準值元素的子序列排序。

遞歸到最底部的判斷條件是序列的大小是零或一，此時該數列顯然已經有序。

選取基準值有數種具體方法，此選取方法對排序的時間性能有決定性影響。

const?quickSort?=?arr?=>?{
????const?len?=?arr.length
????if?(len?<?2)?{
????????return?arr
????}
????const?pivot?=?arr[0]
????const?left?=?[]
????const?right?=?[]
????for?(let?i?=?1;?i?<?len;?++i)?{
????????if?(arr[i]?>=?pivot)?{
????????????right.push(arr[i])
????????}
????????if?(arr[i]?<?pivot)?{
????????????left.push(arr[i])
????????}
????}
????return?[...quickSort(left),?pivot,?...quickSort(right)]
}

三路快排

const?quickSort?=?arr?=>?{
????const?len?=?arr.length
????if?(len?<?2)?{
????????return?arr
????}
????let?left?=?[]
????let?center?=?[]
????let?right?=?[]
????let?pivot?=?arr[0]
????for?(let?i?=?0;?i?<?len;?++i)?{??????
????????if?(arr[i]?<?pivot)?{
????????????left.push(arr[i])
????????}?else?if?(arr[i]?===?pivot)?{
????????????center.push(arr[i])
????????}?else?{
????????????right.push(arr[i])
????????}
????}
????return?[...quickSort(left),?...center,?...quickSort(right)]
}

歸并排序

第一種是?自上而下的遞歸?，算法步驟如下：

  1. 申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合并后的序列；

  2. 設定兩個指針，最初位置分別為兩個已經排序序列的起始位置；

  3. 比較兩個指針所指向的元素，選擇相對小的元素放入到合并空間，并移動指針到下一位置；

  4. 重復步驟3直到某一指針到達序列尾；

  5. 將另一序列剩下的所有元素直接復制到合并序列尾。

具體實現：

?

?

?

?

?

?

?

?

?

?

const?merge?=?(left,?right)?=>?{
????let?resArr?=?[]
????while?(left.length?&&?right.length)?{
????????if?(left[0]?<?right[0])?{
????????????resArr.push(left.shift())
????????}?else?{
????????????resArr.push(right.shift())
????????}
????}
????return?resArr.concat(left,?right)
}

const?mergeSort?=?arr?=>?{
????if?(arr.length?<=?1)?{
????????return?arr
????}
????let?middle?=?Math.floor(arr.length?/?2)
????let?left?=?arr.slice(0,?middle)
????let?right?=?arr.slice(middle)
????return?merge(mergeSort(left),?mergeSort(right))
}

自下而上的迭代?，由于?分治法?的具體算法基本都能用?遞歸?跟?迭代?來實現，所有才有這種寫法，其主要步驟如下：

  1. 將序列每相鄰兩個數字進行?歸并操作?，形成?ceil(n / 2)?個序列，排序后每個序列包含兩/一個元素；

  2. 若此時序列數不是1個則將上述序列再次歸并，形成?ceil(n / 4)??個序列，每個序列包含四/三個元素；

  3. 重復步驟2，直到所有元素排序完畢，即序列數為1。

具體實現如下：

const?merge?=?(arr,?startLeft,?stopLeft,?startRight,?stopRight)?=>?{
????/*?建立左右子序列?*/
????let?rightArr?=?new?Array(stopRight?-?startRight?+?1)
????let?leftArr?=?new?Array(stopLeft?-?startLeft?+?1)
????/*?給左右序列排序?*/
????let?k?=?startRight
????for?(let?i?=?0,?len?=?rightArr.length;?i?<?len?-?1;?++i)?{
????????rightArr[i]?=?arr[k]
????????++k
????}
????k?=?startLeft
????for?(let?i?=?0,?len?=?leftArr.length;?i?<?len?-?1;?++i)?{
????????leftArr[i]?=?arr[k]
????????++k
????}
????//設置哨兵值，當左子列或右子列讀取到最后一位時，即Infinity，可以讓另一個剩下的列中的值直接插入到數組中
????rightArr[rightArr.length?-?1]?=?Infinity
????leftArr[leftArr.length?-?1]?=?Infinity
????let?m?=?0
????let?n?=?0
????//?比較左子列和右子列第一個值的大小，小的先填入數組，接著再進行比較
????for?(let?c?=?startLeft;?c?<?stopRight;?++c)?{
????????if?(leftArr[m]?<=?rightArr[n])?{
????????????arr[c]?=?leftArr[m]
????????????m++
????????}?else?{
????????????arr[c]?=?rightArr[n]
????????????n++
????????}
????}
}
const?mergeSort?=?arr?=>?{
????if?(arr.length?<=?1)?{
????????return?arr
????}
????//設置子序列的大小
????let?step?=?1
????let?left
????let?right
????while?(step?<?arr.length)?{
????????left?=?0
????????right?=?step
????????while?(right?+?step?<=?arr.length)?{
????????????merge(arr,?left,?left?+?step,?right,?right?+?step)
????????????left?=?right?+?step
????????????right?=?left?+?step
????????}
????????if?(right?<?arr.length)?{
????????????merge(arr,?left,?left?+?step,?right,?arr.length)
????????}
????????step?*=?2
????}
????return?arr
}

魚頭注：迭代比起遞歸還是安全很多，太深的遞歸容易導致堆棧溢出。

堆排序

堆排序的算法步驟如下：

  1. 把無序數列構建成二叉堆；

  2. 循環刪除堆頂元素，替換到二叉堆的末尾，調整堆產生新的堆頂。

/*?堆下沉調整?*/
const?adjustHeap?=?(arr,?parentIndex,?length)?=>?{
????let?temp?=?arr[parentIndex]?/*?temp保存父節點值，用于最后賦值?*/
????let?childIndex?=?2?*?parentIndex?+?1?/*?保存子節點位置?*/
????while?(childIndex?<?length)?{
????????/*?如果有右子節點，且右子節點大于左子節點的值，則定位到右子節點?*/
????????if?(childIndex?+?1?<?length?&&?arr[childIndex?+?1]?>?arr[childIndex])?{
????????????childIndex++
????????}
????????/*?如果父節點小于任何一個子節點的值，直接退出循環?*/
????????if?(temp?>=?arr[childIndex])?{
????????????break;
????????}
????????/*?無序交換，單向賦值即可?*/
????????arr[parentIndex]?=?arr[childIndex]
????????parentIndex?=?childIndex
????????childIndex?=?2?*?childIndex?+?1
????}
????arr[parentIndex]?=?temp
}
const?heapSort?=?arr?=>?{
????/*?把無序數列構建成最大堆?*/
????for?(let?i?=?Math.floor(arr.length?/?2);?i?>=?0;?--i)?{
????????adjustHeap(arr,?i,?arr.length?-?1)
????}
????for?(let?i?=?arr.length?-?1;?i?>?0;?--i)?{
????????/*?交換最后一個元素與第一個元素?*/
????????[arr[i],?arr[0]]?=?[arr[0],?arr[i]]
????????/*?調整最大堆?*/
????????adjustHeap(arr,?0,?i)
????}
????return?arr
}

計數排序

計數排序（Counting sort）?是一種穩定的線性時間排序算法。該算法于1954年由 Harold H. Seward 提出。計數排序使用一個額外的數組來存儲輸入的元素，計數排序要求輸入的數據必須是有確定范圍的整數。

當輸入的元素是?n?個?0?到?k?之間的整數時，它的運行時間是?O(n + k)?。計數排序不是比較排序，排序的速度快于任何比較排序算法。

計數排序的算法步驟如下：

  1. 找出待排序的數組中最大和最小的元素；

  2. 統計數組中每個值為?i?的元素出現的次數，存入數組?C?的第?i?項；

  3. 對所有的計數累加（從數組?C?中的第一個元素開始，每一項和前一項相加）；

  4. 反向填充目標數組：將每個元素?i?放在新數組的第?C[i]?項，每放一個元素就將 C[i] 減去1

具體實現如下：

const?countSort?=?arr?=>?{
????const?C?=?[]
????for?(let?i?=?0,?iLen?=?arr.length;?i?<?iLen;?++i)?{
????????const?j?=?arr[i]
????????if?(C[j]?>=?1)?{
????????????C[j]++
????????}?else?{
????????????C[j]?=?1
????????}
????}
????const?D?=?[]
????for?(let?j?=?0,?jLen?=?C.length;?j?<?jLen;?++j)?{
????????if?(C[j])?{
????????????while?(C[j]?>?0)?{
????????????????D.push(j)
????????????????C[j]--
????????????}
????????}
????}
????return?D
}

桶排序（Bucket Sort）?跟?計數排序（Counting sort）?一樣是一種穩定的線性時間排序算法，不過這次需要的輔助不是計數，而是桶。

工作的原理是將數列分到有限數量的桶里。每個桶再個別排序。當要被排序的數組內的數值是均勻分配的時候，桶排序使用線性時間?O(n)。

桶排序的算法步驟如下：

  1. 設置一個定量的數組當作空桶子；

  2. 尋訪序列，并且把項目一個一個放到對應的桶子去；

  3. 對每個不是空的桶子進行排序；

  4. 從不是空的桶子里把項目再放回原來的序列中。

const?bucketSort?=?arr?=>?{
????let?bucketsCount?=?10?/*?默認桶的數量?*/
????const?max?=?Math.max(...arr)?/*?序列最大數字?*/
????const?min?=?Math.min(...arr)?/*?數列最小數字?*/
????const?bucketsSize?=?Math.floor((max?-?min)?/?bucketsCount)?+?1?/*?桶的深度?*/
????const?__buckets?=?[]?/*?空桶?*/
????for?(let?i?=?0,?len?=?arr.length;?i?<?len;?++i)?{
????????const?index?=?~~(arr[i]?/?bucketsSize)?/*?騷操作，取數列中最大或最小的序列?*/
????????if?(!__buckets[index])?{
????????????__buckets[index]?=?[]?/*?創建子桶?*/
????????}
????????__buckets[index].push(arr[i])
????????let?bLen?=?__buckets[index].length
????????while?(bLen?>?0)?{?/*?子桶排序?*/
????????????if?(__buckets[index][bLen]?<?__buckets[index][bLen?-?1])?{
????????????????[__buckets[index][bLen],?__buckets[index][bLen?-?1]]?=?[__buckets[index][bLen?-?1],?__buckets[index][bLen]]
????????????}
????????????bLen--
????????}
????}
????let?buckets?=?[]?/*?真實序列?*/
????for?(let?i?=?0,?len?=?__buckets.length;?i?<?len;?++i)?{
????????if?(__buckets[i])?{
????????????buckets.push(...__buckets[i])
????????}
????}
????return?buckets
}

基數排序

基數排序（Radix sort）?是一種非比較型整數排序算法，其原理是將整數按位數切割成不同的數字，然后按每個位數分別比較。由于整數也可以表達字符串（比如名字或日期）和特定格式的浮點數，所以基數排序也不是只能使用于整數。

工作原理是將所有待比較數值（正整數）統一為同樣的數字長度，數字較短的數前面補零。然后，從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成以后，數列就變成一個有序序列。

const?LSDRadixSort?=?arr?=>?{
????const?max?=?Math.max(...arr)?/*?獲取最大值?*/
????let?digit?=?`${max}`.length?/*?獲取最大值位數?*/
????let?start?=?1?/*?桶編號?*/
????let?buckets?=?[]?/*?空桶?*/
????while?(digit?>?0)?{
????????start?*=?10
????????/*?入桶?*/
????????for?(let?i?=?0,?len?=?arr.length;?i?<?len;?++i)?{
????????????const?index?=?(arr[i]?%?start)
????????????if?(!buckets[index])?{
????????????????buckets[index]?=?[]
????????????}
????????????buckets[index].push(arr[i])?/*?往不同桶里添加數據?*/
????????}
????????arr?=?[]
????????/*?出桶?*/
????????for(let?i?=?0;?i?<?buckets.length;?i++)?{
????????????if?(buckets[i])?{
????????????????arr?=?arr.concat(buckets[i])
????????????}
????????}
????????buckets?=?[]
????????digit?--
????}
????return?arr
}

雞尾酒排序，是?冒泡排序?的一種變形。此算法與?冒泡排序?不同的地方在于從低到高然后從高到低，而?冒泡排序?則僅從低到高去比較序列里的每個元素。它可以得到比?冒泡排序?稍微好一點的性能，原因是?冒泡排序?只從一個方向進行比對（由低到高），每次循環只移動一個項目。

步驟跟冒泡算法差不多，區別在于從起點到終點遍歷完之后會進行一次終點到起點的遍歷。

const?cocktailSort?=?arr?=>?{
????let?i
????let?left?=?0
????let?right?=?arr.length?-?1
????while?(left?<?right)?{
????????for?(i?=?left;?i?<?right;?++i)
????????????if?(arr[i]?>?arr[i?+?1])?{
????????????????[arr[i],?arr[i?+?1]]?=?[arr[i?+?1],?arr[i]]
????????????}
????????right--
????????for?(i?=?right;?i?>?left;?--i)
????????????if?(arr[i?-?1]?>?arr[i])?{
????????????????[arr[i],?arr[i?-?1]]?=?[arr[i?-?1],?arr[i]]
????????????}
????????left++
????}
????return?arr
}

?

轉載于:https://www.cnblogs.com/zhouyideboke/p/11164024.html

本文來自互聯網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。
如若轉載，請注明出處：http://www.pswp.cn/news/247551.shtml
繁體地址，請注明出處：http://hk.pswp.cn/news/247551.shtml
英文地址，請注明出處：http://en.pswp.cn/news/247551.shtml

如若內容造成侵權/違法違規/事實不符，請聯系多彩編程網進行投訴反饋email:809451989@qq.com，一經查實，立即刪除！

相關文章

js實用算法

js實用算法

判斷文本是否為回文 定義&#xff1a;如果將一個文本翻轉過來&#xff0c;能和原文本完全相等&#xff0c;那么就可以稱之為“回文”。 方法一&#xff08;字符串、數組內置方法&#xff09;123456789101112131415/** 判斷文字是否為回文* param {string|number} val 需要判斷的…
閱讀更多...
stylus

stylus

stylus格式 指將css中{} &#xff1b;去掉即可
閱讀更多...
隨筆記錄（2019.7.10）

隨筆記錄（2019.7.10）

1、ISO/OSI 網絡七層參考模型 物理層 數據鏈路層 網絡層 傳輸層 會話層 表示層 應用層 2、 TCP/IP 網絡四層模型和五層模型 四層模型&#xff1a; 網絡接口層 網絡層 傳輸層 應用層 五層模型&#xff1a; 物理層 數據鏈路層 網絡層 傳輸層 應用層 3、 協議簇 &#xff08;1&a…
閱讀更多...
轉發：Ajax動態畫EChart圖表

轉發：Ajax動態畫EChart圖表

本人由于項目需要&#xff0c;在狀態變化的時候需要動態繪制對應數據的EChart圖表&#xff0c;并且不刷新整個網頁。 所以就用Ajax動態畫EChart圖表&#xff0c;下面是開發過程中遇到的一些坑的總結。 流程&#xff1a;頁面首次加載時展示一幅原始的圖形&#xff0c;若后臺數據…
閱讀更多...
如果硬盤不顯示可以這么處理

如果硬盤不顯示可以這么處理

http://www.zhuangjiba.com/soft/9574.html轉載于:https://www.cnblogs.com/braveheart007/p/11167311.html
閱讀更多...
Highcharts的餅圖大小的控制

Highcharts的餅圖大小的控制

在Highcharts中&#xff0c;餅圖的大小是Highcharts自動計算并進行繪制。餅圖的大小受數據標簽大小、數據標簽到切片的距離影響。當數據標簽內容較多&#xff0c;并且距離切片較遠時&#xff0c;餅圖就會被壓縮的很小。解決這個問題&#xff0c;有以下幾種方法&#xff1a;&…
閱讀更多...
轉：谷歌離線地圖基礎

轉：谷歌離線地圖基礎

一.需要文件 gapi3文件夾&#xff1a;存放接口等tilemap文件夾&#xff1a;存放圖片gapi.js文件maptool.js文件 二.html配置 <script type"text/javascript" src"gapi.js"></script> <script type"text/javascript" src"map…
閱讀更多...
HTTP Header 詳解

HTTP Header 詳解

搜集資料 HTTP&#xff08;HyperTextTransferProtocol&#xff09;即超文本傳輸協議&#xff0c;目前網頁傳輸的的通用協議。HTTP協議采用了請求/響應模型&#xff0c;瀏覽器或其他客戶端發出請求&#xff0c;服務器給與響應。就整個網絡資源傳輸而言&#xff0c;包括message-h…
閱讀更多...
Windows CE 6.0中斷處理過程（轉載）

Windows CE 6.0中斷處理過程（轉載）

這里我們主要討論的是CE的中斷建立和中斷相應的大概流程以及所涉及的代碼位置。這里所講述的&#xff0c;是針對ARM平臺的。在CE的中斷處理里面&#xff0c;有一部分工作是CE Kernel完成的&#xff0c;有一部分工作是要由OEM完成的。 Kernel代碼工作 ExVector.s&#xff1a;中斷…
閱讀更多...
document.createDocumentFragment 以及創建節點速度比較

document.createDocumentFragment 以及創建節點速度比較

document.createDocumentFragment document.createDocumentFragment()方法創建一個新空白的DocumentFragment對象。 DocumentFragments是DOM節點。它們不是主DOM樹的一部分。通常的用例是創建文檔片段&#xff0c;將元素附加到文檔片段&#xff0c;然后將文檔片段附加到DOM樹。…
閱讀更多...
Javascript重溫OOP之原型與原型鏈

Javascript重溫OOP之原型與原型鏈

prototype原型對象 每個函數都有一個默認的prototype屬性&#xff0c;其實際上還是一個對象&#xff0c;如果被用在繼承中&#xff0c;姑且叫做原型對象。 在構造函數中的prototype中定義的屬性和方法&#xff0c;會被創建的對象所繼承下來。舉個栗子&#xff1a; function F()…
閱讀更多...
webpack超詳細配置

webpack超詳細配置

在這里就不詳細介紹webpack來源以及作用了, 本篇博文面向新手主要說明如何配置webpack, 以及webpack的使用方法, 直到創建出一個合理的屬于自己webpack項目; 流程 webpack安裝 Step 1: 首先安裝Node.js, 可以去Node.js官網下載.Step2: 在Git或者cmd中輸入下面這段代碼, 通過全局…
閱讀更多...
小白十分鐘-推薦導航欄

小白十分鐘-推薦導航欄

大腿繞道&#xff0c;給小白學習用&#xff0c;上代碼 <div class"list"><div class"infor"><ul class"left"><li><a href"">限時特價</a></li><li><a href"">熱門推…
閱讀更多...
Underscore.js常用方法介紹

Underscore.js常用方法介紹

Underscore.js是一個很精干的庫&#xff0c;壓縮后只有4KB。它提供了幾十種函數式編程的方法&#xff0c;彌補了標準庫的不足&#xff0c;大大方便了JavaScript的編程。MVC框架Backbone.js就將這個庫作為自己的工具庫。除了可以在瀏覽器環境使用&#xff0c;Underscore.js還可以…
閱讀更多...
掌握ES6/ES2015核心內容

掌握ES6/ES2015核心內容

ECMAScript 6&#xff08;以下簡稱ES6&#xff09;是JavaScript語言的下一代標準。因為當前版本的ES6是在2015年發布的&#xff0c;所以又稱ECMAScript 2015。 也就是說&#xff0c;ES6就是ES2015。 雖然目前并不是所有瀏覽器都能兼容ES6全部特性&#xff0c;但越來越多的程序員…
閱讀更多...
express-generator——Express應用生成器賊快！

express-generator——Express應用生成器賊快！

通過應用生成器工具 express 可以快速創建一個應用的骨架。 通過如下命令安裝&#xff1a; $ npm install express-generator -g-h 選項可以列出所有可用的命令行選項&#xff1a; $ express -hUsage: express [options] [dir]Options:-h, --help output usage inform…
閱讀更多...
轉：canvas--放大鏡效果

轉：canvas--放大鏡效果

<!DOCTYPE html><html><head><meta charset"UTF-8"><title>鼠標事件</title></head><body><canvas id"canvas"></canvas><canvas id"offCanvas" style" display: none;&qu…
閱讀更多...
MON

MON

早上5點,咪咪牛就醒了,開始跳到我邊上,用白毛毛把我弄醒,在我身上走來走去,把她按住撫摸也不能讓她停止.....只能拎起來扔到邊上了 ;)看起來還的確是很調皮的貓咪呢昨天晚上就開始不太怕我了,走到我的椅子邊上喵喵叫,直到把她放在身上,才慢慢睡覺,滿可愛的早上出門叫車,一車正停…
閱讀更多...
CSS做個Switch開關

CSS做個Switch開關

Switch開關&#xff1a;根據需求可知&#xff0c;Switch開關只有兩種選擇&#xff0c;true或false。所以我們想到HTML的checkbox控件&#xff0c;用它來做。　　<input id"switch" type"checkbox" class"switch" />但是在瀏覽器中&#xf…
閱讀更多...
vue小記錄1

vue小記錄1

1.入口index.html文件 做reset.css初始化&#xff0c;視口viewport設置 2.規范化eslint配置&#xff08;常用&#xff09; &#xff08;1&#xff09;rules -->"semi"分號 "semi":[error,alway], &#xff08;2&#xff09;indent 空格 "inde…
閱讀更多...
最新文章

Copyright @ 2022~2023