0~n
之間的整數進行排序var testArr = [3, 5, 3, 5, 9, 7, 6]
console.log('原數組:', arr)
function skipSort (n, skipArr) {
let arr = []
let sortArr = []
arr.length = n
for (let i = 0; i <= n; i++) {
arr[i] = 0
}
for (let j = 0; j < skipArr.length; j++) {
arr[skipArr[j]]++
}
for (let t = 0; t <= n; t++) {
if (arr[t]) {
for (let k = 1; k <= arr[t]; k++) {
sortArr.push(t)
}
}
}
return sortArr
}
console.log('桶排序:', skipSort(10, testArr))
複製代碼
var arr = [3, 5, 3, 5, 9, 7, 6]
console.log('原數組:', arr)
function bubbleSort (arr) {
let len = arr.length
for (let i = 0; i < len - 1; i++) {
for (let j = 0; j < len - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
let temp = arr[j]
arr[j] = arr[j + 1]
arr[j + 1] = temp
}
}
}
return arr
}
console.log('冒泡排序:',bubbleSort(arr))
複製代碼
chrome
使用快速排序的一個變體做爲Array.prototype.sort的實現劃分操做
。切記
:必定要先從右往左找,再從左往右找,不然會出錯var arr = [3, 5, 3, 5, 9, 7, 6]
console.log('原數組:', arr)
function quickSort (arr, left, right) {
let len = arr.length
left = typeof left === 'undefined' ? 0 : left
right = typeof right === 'undefined' ? len - 1 : right
if (left > right) {
return
}
let temp = arr[left]
let i = left
let j = right
let t
while (i !== j) {
while (arr[j] >= temp && i < j) {
j--
}
while (arr[i] <= temp && i < j) {
i++
}
if (i < j) {
t = arr[i]
arr[i] = arr[j]
arr[j] = t
}
}
arr[left] = arr[i]
arr[i] = temp
quickSort(arr, left, i - 1)
quickSort(arr, i + 1, right)
return arr
}
console.log('快速排序:',quickSort(arr))
複製代碼
var arr = [3, 5, 3, 5, 9, 7, 6]
console.log('原數組:', arr)
function selectSort (arr) {
let len = arr.length
let minIndex
let temp
for (let i = 0; i < len; i++) {
minIndex = i
temp = arr[i]
for (let j = i + 1; j < len; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j
}
}
arr[i] = arr[minIndex]
arr[minIndex] = temp
}
return arr
}
console.log('選擇排序:',selectSort(arr))
複製代碼
var arr = [3, 5, 3, 5, 9, 7, 6]
console.log('原數組:', arr)
function insertSort (arr) {
let len = arr.length
let preIndex
for (let i = 1; i < len; i++) {
preIndex = i - 1
current = arr[i]
while (preIndex >= 0 && arr[preIndex] > current) {
arr[preIndex + 1] = arr[preIndex]
preIndex--
}
arr[preIndex + 1] = current
}
return arr
}
console.log('插入排序:', insertSort(arr))
複製代碼
Mozilla Firefox
使用歸併排序做爲Array.prototype.sort的實現歸併排序
是一種分治算法。本質上就是把一個原始數組切分紅較小的數組,直到每一個小數組只有一個位置,接着把小數組歸併成較大的數組,在歸併過程當中也會完成排序,直到最後只有一個排序完畢的大數組分治算法
的基本思想是將一個規模爲N的問題分解爲K個規模較小的子問題,這些子問題相互獨立且與原問題性質相同。求出子問題的解,就可獲得原問題的解。var arr = [3, 5, 3, 5, 9, 7, 6]
console.log('原數組:', arr)
function mergeSort (arr) {
let len = arr.length
if (len < 2) {
return arr
}
let middle = Math.floor(len / 2)
let left = arr.slice(0, middle)
let right = arr.slice(middle)
return merge(mergeSort(left), mergeSort(right))
}
function merge (left, right) {
let result = []
while (left.length && right.length) {
if (left[0] < right[0]) {
result.push(left.shift())
} else {
result.push(right.shift())
}
}
result.push(...left)
result.push(...right)
return result
}
console.log('歸併排序:', mergeSort(arr))
複製代碼
堆排序其實是利用堆的性質
來進行排序的,咱們一般說的堆就是二叉堆
,二叉堆又稱徹底二叉樹
或者近似徹底二叉樹
。堆排序是選擇排序的一種
。能夠利用數組的特色快速定位指定索引的元素。數組能夠根據索引直接獲取元素,時間複雜度爲O(1)算法
最大堆的特性以下:chrome
最小堆的特性以下:api
算法思想數組
將待排序序列構形成一個大頂堆,此時,整個序列的最大值就是堆頂的根節點。將其與末尾元素進行交換,此時末尾就爲最大值。而後將剩餘n-1個元素從新構形成一個堆,這樣會獲得n個元素的次小值。如此反覆執行,便能獲得一個有序序列了。性能
const arr = [21, 34, 56, 2, 4, 9, 87]
console.log('原數組:', arr)
let len = arr.length
// 構建最大堆
function buildMaxHeap (arr) {
let mid = Math.floor(len / 2)
for (let i = mid; i >= 0; i--) {
heapify(arr, i)
}
}
// 子數的調整
function heapify (arr, i) {
let maxIndex = i
let left = 2 * i + 1
let right = 2 * i + 2
if (left <len && arr[maxIndex] < arr[left]) {
maxIndex = left
}
if (right <len && arr[maxIndex] < arr[right]) {
maxIndex = right
}
if (maxIndex !== i) {
swap(arr, i, maxIndex)
heapify(arr, maxIndex)
}
}
// 交換兩值
function swap (arr, i, j) {
[arr[i], arr[j]] = [arr[j], arr[i]]
}
// 堆排序
function heapSort (arr) {
buildMaxHeap(arr)
for (let i = arr.length - 1; i>=0; i--) {
swap(arr, 0, i)
len--
heapify(arr, 0)
}
return arr
}
console.log('堆排序:', heapSort(arr))
複製代碼