冒泡排序

  1. function sort(s){
  2.   for (let i = 0;i<s.length-1;i++){
  3.     for (let j = 0;j<s.length-i-1;j++){
  4.       if (s[j]>s[j+1]){
  5.         [s[j],s[j+1]] = [s[j+1],s[j]]
  6.       }
  7.     }
  8.   }
  9.   return s
  10. }

第一个循环为了重置指针用，没有指针含义代表了冒泡次数，进行下一轮冒泡

选择排序

  1. function sort(s){
  2.   let min = s[0]
  3.   let index = 0
  4.   if (s.length === 1){
  5.     return s
  6.   }else {
  7.     for (let i = 0;i<s.length;i++){
  8.       if (min>=s[i]){
  9.         min = s[i]
  10.         index = i
  11.       }
  12.     }
  13.     s.splice(index,1)
  14.   }
  15.   return [min].concat(sort(s))
  16. }

快速

  1. function sort(s){
  2.   const pivotIndex = Math.floor(s.length/2)
  3.   let pivot = s.splice(pivotIndex, 1)[0];
  4.   const left  = []
  5.   const right = []
  6.   for (let i = 0; i < s.length; i++) {
  7.     if (s[i] < pivot) {
  8.       left.push(s[i]);
  9.     } else {
  10.       right.push(s[i]);
  11.     }
  12.   }
  13.   if (s.length<=1){
  14.     return s
  15.   }else {
  16.     return sort(left).concat([pivot],sort(right))
  17.   }
  18. }

归并

  1. function mergesort(numbers) {
  2.   if (numbers.length === 1) {
  3.     return numbers;
  4.   }
  5.   let left = arr.slice(0, Math.floor(numbers.length / 2));
  6.   let right = arr.slice(Math.floor(numbers.length / 2));
  7.   return merge(mergesort(left), mergesort)(right);
  8. }
  9. function merge(a, b) {
  10.   if (a.length === 0) return b;
  11.   if (b.length === 0) return a;
  12.   if (a[0] > b[0]) {
  13.     [b[0]].concat(merge(a, b.slice(1)));
  14.   } else {
  15.     [a[0]].concat(merge(a.slice(1), b));
  16.   }
  17. }