查找和排序算法的js实现

查找和排序算法的js实现

学习算法时，将算法手写实现，加深记忆。

二分查找（适用于有序述组）

二分查找的算法复杂度是$$\mathrm{O}(logn)$$

function dividal(start, end) {
		var mid = Math.floor((start + end)/2)
		if(num === arr[mid]) {
			return mid
		} 
		if(num > arr[mid]) {
			return dividal(mid, end)
		}else if(num < arr[mid]) {
			return dividal(start, mid)
		}
	}

选择排序

每次选择最大（小）的放入新数组，算法复杂度为$$\mathrm{O}(n^2)$$

function order(arr) {
		var orderArr = []
		return function findBigest() {
			if(arr.length === 1) {
				orderArr.push(arr[0])
				return orderArr
			}
			var big = arr[0]
			var index = 0
			for(var i = 0; i<arr.length; i++) {
				if(arr[i] > big) {
					big = arr[i]
					index = i
				}
			}
			orderArr.push(big)
			arr.splice(index, 1)
			return findBigest(arr)
		}
	}

快速排序

选择一个元素作为基准，比该元素大的都放左边，比该元素小的都放右边。基准条件为左（或右）边的数组长度小于2。用递归思想实现该算法。算法复杂度为
$$\mathrm{O}(nlogn)$$

function quickSort(arr) {
		if(arr.length < 2) return arr
		let index = Math.floor(arr.length /2)
		let leftArr = [], rightArr = []
		let criterion = arr.splice(index, 1)[0]
		arr.forEach(item => {
			if(item > criterion) {
				rightArr.push(item) 
			}else {
				leftArr.push(item)
			}
		})
		return quickSort(leftArr).concat(criterion, quickSort(rightArr))
	}

归并（合并）排序

先拆分，一直拆分到只有一个数。拆分完成后，开始递归合并。它的时间复杂度无论是平均，最好，最坏都是$$nlogn$$

    function divide(p, r) {
      return Math.floor((p + r) / 2);
    }
    
    function merge(A, p, q, r) {
      const A1 = A.slice(p, q);
      const A2 = A.slice(q, r);
      A1.push(Number.MAX_SAFE_INTEGER);
      A2.push(Number.MAX_SAFE_INTEGER);
    
      for (let i = p, j = 0, k = 0; i < r; i++) {
        if (A1[j] < A2[k]) {
          A[i] = A1[j];
          j++;
        } else {
          A[i] = A2[k];
          k++;
        }
      }
    }
    
    function merge_sort(A, p = 0, r) {
      r = r || A.length;
      if (r - p === 1) {
        return;
      }
      const q = divide(p, r);
      merge_sort(A, p, q);
      merge_sort(A, q, r);
      merge(A, p, q, r);
    
      return A;
    }