javascript 排序和搜索算法

排序算法

1冒泡排序　

学习排序算法时，通常都先学冒泡算法，因为它在所有排序算法中最简单。然而，从运行时间的角度来看，冒泡排序是最差的一个。

冒泡排序比较任何两个相邻的项，如果第一个比第二个大，则交换它们。元素项向上移动至正确的顺序，就好像气泡升至表面一样，冒泡排序因此得名。

function sort(arr){
    var len = arr.length;
    for(var i = 0; i < len;i++){
        for(var j = 0;j < len-1;j++){
            if(arr[j]>arr[j+1]){
                var temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp
            }
        }    
    }
    return arr      
}

2：选择排序：

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

function select(arr){
    for(var i = 0;i < arr.length-1;i++){
        for(var j= i+1;j<arr.length;j++){
            if(arr[i]>arr[j]){
                var t = arr[i];
                arr[i] = arr[j];
                arr[j] = t
            }
        }
    }
       return arr;  
}

3:快速排序

快速排序是找出一个元素作为基准,然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。递归快速排序，将其他n-1个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正确位置，排序完成。所以快速排序算法的核心算法是分区操作，即如何调整基准的位置以及调整返回基准的最终位置以便分治递归。

function quickSort(arr){
　　if(arr.length<=1){
　　　　return arr;
　　}
　　var midIndex = Math.floor(arr.length/2);
　　var midValue = arr.splice(midIndex,1);
　　var left = [];
　　var right = [];
　　for(var i = 0;i < arr.length; i++){
　　　　if(arr[i] < midValue){
　　　　　　left.push(arr[i])
　　　　}else{
　　　　　　right.push(arr[i])
　　　　}
　　}
　　return quickSort(left).concat(midValue,quickSort(right))


}

 4 插入排序

  插入排序:插入排序原理：它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

function insertSort(arr){
　　var len = arr.length;
　　for(var i = 1;i < len; i++){
　　　　if(arr[i] < arr[i-1]){
　　　　　　var ele = arr[i];
　　　　　　var j = i-1;
　　　　　　arr[i] = arr[j];
　　　　　　while(j>=0 && ele<arr[j]){
　　　　　　　　arr[j+1] = arr[j];
　　　　　　　　j--
　　　　　　}
　　　　　　arr[j+1] = ele;
　　　　}
　　}
　　return arr;
}

5：归并排序

归并排序是一种分治算法。其思想是将原始数组切分成较小的数组，直到每个小数组只有一个位置，接着将小数组归并成较大的数组，直到最后只有一个排序完毕的大数组。

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);
　　var 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]

mergeSort(arr)

搜索算法

1顺序搜索

顺序或线性搜索是最基本的搜索算法。它的机制是，将每一个数据结构中的元素和我们要找的元素做比较。顺序搜索是最低效的一种搜索算法。

以下是其实现：

this.sequentialSearch = function(item){
　　for (var i=0; i<array.length; i++){ //{1}
　　　　if (item === array[i]) //{2}
　　　　　　return i; //{3}
　　　　}
　　}
　　return -1; //{4}
};

2 ：二分搜索

这个算法要求被搜索的数据结构已排序。以下是该算法遵循的步骤。

(1) 选择数组的中间值。
(2) 如果选中值是待搜索值，那么算法执行完毕（值找到了）。
(3) 如果待搜索值比选中值要小，则返回步骤1并在选中值左边的子数组中寻找。
(4) 如果待搜索值比选中值要大，则返回步骤1并在选种值右边的子数组中寻找

function binarySearch (arr,item){
    //先排序
    arr.sort(function(val1,val2){
        return val1 - val2
    })
    var low = 0;
　　var high = arr.length -1;
　　var mid;
　　var element;
　　while(low <= high){
　　　　mid = Math.floor((low + high)/2);//中间索引
　　　　element = arr[mid];
　　　　if(item > element){
　　　　　　low = mid + 1;
　　　　}else if(item < element){
　　　　　　high = mid -1;
　　　　}else{
　　　　　　return mid
　　　　}

　　}
　　return -1;

}