相關算法排序安排

1排序算法分類

冒泡排序 選擇排序 插入排序 希爾排序 歸併排序 快速排序 推排序 計數排序 桶排序 基數排序

2 計算代碼以下

  冒泡排序 function bubbleSort(arr) {

let len = arr.length;
 for(let i = 0;j<len-1-i;j++){
    for(let j = 0;j< len-1-i;j++) {
	   if(arr[j]>arr[j+1]){
	       [arr[j+1]，arr[j]] = [arr[j],arr[j+1]];
	   }
	}
 }
  return arr;
}

//快排demo:
    function quickSort(arr,left,right) {
      let len = arr.length;
      let partitionIndex;
      left = typeof left != 'number'? 0 :left;
      right = typeof right ！='number'? len -1 :right;
      if(left<right) {
        partitionIndex = partition(arr,left,right);
	    quickSort(arr,left,partitionIndex-1);
	    quickSort(arr,partitionIndex+1,right);
      }
     return arr;
  }
function partition(arr,left,right) {
  let pivot = left;
  let index = pivot + 1;
  for(let i = index;i<=right;i++) {
  if(arr[i]<arr[pivot]){
      [arr[i],arr[index]] = [arr[index],arr[i]];
	  index++;
    }
  }
 [arr[pivot],arr[index-1]] = [arr[index-1],arr[pivot]];
  return index-1
}
// 選擇demo 
  function selectionSort (arr){
  let len = arr.length;
  let minIndex;
  for(let i=0;i<len-1;i++) {
  minIndex = i;
  for (let j=i+1;j<len;j++) {
    if (arr[j] < arr[minIndex]) {     //尋找最小的數
		    minIndex = j;                 //將最小數的索引保存
	    }
    }
	[arr[i],arr[minIndex]] = [arr[minIdenx],arr[i]];
  }
  return  arr
}

// 插入排序：每次排一個數組項，假設數組的第一項已經排序，接着，把第二項與第一項進行對比，第二項是該插入到第一項以前仍是以後，第三項是該    插入到第一項以前仍是第一項以後仍是第三項
function insertionSort(arr) {
  let len = arr.length;
  let preIndex,current;
  for(let 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;
}
// 歸併排序：Mozilla Firefox 使用歸併排序做爲Array.prototype.sort的實現，而chrome使用快速排序的一個變體實現的,前面三種算法性能很差，但歸併排序性能不錯 算法複雜度O(nlog^n)
 function mergeSort (arr) {
   let len = arr.length;
   if(len<2) {
     return arr 
   }
    let middle = Math.floor(len/2),
	left = arr.slice(0,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;
 //堆排序：堆排序把數組當中二叉樹來排序而得名。
   var len;
function buildMaxHeap(arr) {
      len = arr.length;
	  for(let i = Math.floor(len/2;i>=0;i--){
	      heapify(arr,i)
	  }
   }
 function heapify(arr,i) {
     let left = 2* i+1;
	 let right = 2*i+2;
	 let largest = i;
	 if(left<len && arr[left]> arr[largest]) {
	     largest = left;
	 }
	 if(right < len && arr[right]>arr[largest]){
	  largest = right;
	 }
	 if (largest !== i) {
    [arr[i], arr[largest]] = [arr[largest], arr[i]];
    heapify(arr, largest);
    }
  }
function heapSort(arr) {
   buildMaxHeap(arr);
  for (let i = arr.length - 1; i > 0; i--) {
		[arr[0],arr[i]]=[arr[i],arr[0]];
		len--;
		heapify(arr, 0);
  }
  return arr;
}