JavaScript 数学排序

冒泡排序 n^2 n
相邻两个数字比较大小，小的在左边大的在右边。一趟下来一定能把数组中最大的值放在最右边。

function bubble(arr){
    var temp=null;
    for (var i=0;i<arr.length;i++){
        for (var j=0;j<arr.length;j++){
            if (arr[j]>arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
    return arr;
}
console.log(bubble([2,3,5,1,0]));

选择排序 n^2
在一个长度为n的无序数组中。第一次，遍历n个数据。找出其中的最小值与第一个元素交换。第二次，遍历剩下的n-1个数据。找出其中的最小值与第二个元素交换。…

function select(arr){
    var min=0;
    var temp=null;
    for(var i=0;i<arr.length;i++){
        min=i;
        for(var j=i+1;j<arr.length;j++){
            if(arr[j]<arr[min]){
                min=j;
            }
        }
        temp=arr[i];
        arr[i]=arr[min];
        arr[min]=temp;
    }
    return arr;
}
console.log(select([2,0,4,9,6]))

快速排序 nlogn n^2
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。

 function quickSort(arr){
      if(arr.length<2){return arr}

      var left=[],right=[],mid=arr.splice(Math.floor(arr.length/2),1);

      for(var i=0;i<arr.length;i++){
            if(arr[i]<mid){
                left.push(arr[i]);
            }else {
                right.push(arr[i])
            }
      }
      return quickSort(left).concat(mid,quickSort(right))
  }
 console.log(quickSort([6,1,2,4,3,5]))

插入排序 n^2
从第一个元素开始，该元素可以认为已经被排序； 取出下一个元素，在已经排序的元素序列中从后向前扫描；如果该元素（已排序）大于新元素，将该元素移到下一位置；重复步骤3，直到找到已排序的元素小于或者等于新元素的位置； 将新元素插入到该位置后；重复步骤2~5。

 function insertSort(arr){
            var len = arr.length;
             for (var i = 1; i < len; i++) {
              var key = arr[i];
             var j = i - 1;
              while (j >= 0 && arr[j] > key) {
                  arr[j + 1] = arr[j];
                  j--;
              }
             arr[j + 1] = key;
         }
        return arr;
        }
console.log(insertSort([6,1,2,4,3,5]));

归并排序 nlogn

function merge(left, right) {
    var result = [];
   	while(left.length > 0 && right.length > 0) {
       if(left[0] < right[0]) {
           result.push(left.shift());
       }
       else {
           result.push(right.shift());
       }
   }
   /* 当左右数组长度不等.将比较完后剩下的数组项链接起来即可 */
   return result.concat(left).concat(right);
}
	function mergeSort(arr){
		if(arr.length==1) {return arr};
		var mid=Math.floor(arr.length/2);
		var left_arr=arr.slice(0,mid),right_arr=arr.slice(mid);
		return merge(mergeSort(left_arr),mergeSort(right_arr));
	}
 
	var arr=[12,20,30,21,15,33,26,19,40,25];
	console.log(mergeSort(arr));

基数排序
nlog®m r为所采取的基数m为堆数

function radixSort(arr, maxDigit) {
　　var mod = 10;
　　var dev = 1;
　　var counter = [];
　　console.time('基数排序耗时');
　　for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
　　　　for(var j = 0; j < arr.length; j++) {
　　　　　　var bucket = parseInt((arr[j] % mod) / dev);
　　　　　　if(counter[bucket]== null) {
　　　　　　　　counter[bucket] = [];
　　　　　　}
　　　　counter[bucket].push(arr[j]);
　　　　}
　　　　var pos = 0;
　　　　for(var j = 0; j < counter.length; j++) {
　　　　　　var value = null;
　　　　　　if(counter[j]!=null) {
　　　　　　　　while ((value = counter[j].shift()) != null) {
　　　　　　　　　　arr[pos++] = value;
　　　　　　　　}
　　　　　　}
　　　　}
　　}
　　console.timeEnd('基数排序耗时');
　　return arr;
}
var arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48];
console.log(radixSort(arr,2));

二分查找

 function binary_search(arr,low, high, key) {
            if (low > high){
                return -1;
            }
            var mid = parseInt((high + low) / 2);
            if(arr[mid] == key){
                return mid;
            }else if (arr[mid] > key){
                high = mid - 1;
                return binary_search(arr, low, high, key);
            }else if (arr[mid] < key){
                low = mid + 1;
                return binary_search(arr, low, high, key);
            }
        };
        var arr = [1,2,3,4,5,6,7,8,9,10,11,23,44,86];
        var result = binary_search(arr, 0, 13, 10);
        console.log(result);

二叉树

//二叉树的输入 以及前中后序输出
var node4 = {left: null, right: null, val: 4 }; 
var node5 = {left: null, right: null, val: 5 }; 
var node6 = {left: null, right: null, val: 6 }; 
var node7 = {left: null, right: null, val: 7 };
var node3 = {left: node6, right: node7, val: 3 };
var node2 = {left: node4, right: node5, val: 2 };
var node1 = {left: node2, right: node3, val: 1 };
//前序
function preorderTraversal(root) {  
    if (!root) {
        return;
    }
    console.log(root.val);
    var left = root.left;
    var right = root.right;
    left && preorderTraversal(left);
    right && preorderTraversal(right);
}
preorderTraversal(node1); 
//中序
function inorderTraversal(root) {
    if (!root) {
        return;
    }
    var left = root.left;
    var right = root.right;
    left && inorderTraversal(left);
    console.log(root.val);
    right && inorderTraversal(right);
}

console.log(inorderTraversal(node1)); 
//后序
function postorderTraversal(root) {
    if (!root) {
        return;
    }
    var left = root.left;
    var right = root.right;
    left && postorderTraversal(left);
    right && postorderTraversal(right);
    console.log(root.val);
}
postorderTraversal(node1);