前端jquery实现搜索功能 javascript 搜索

转载

代码工匠大师 2023-11-12 14:49:53

文章标签 前端jquery实现搜索功能 javascript 数据结构搜索算法 文章分类 jQuery 前端开发

在开始之前，我们首先创建一个数组来表示待排序和搜索算法的数据结构。

function ArrayList(){
    var array = [];

    this.insert = function(item){
        array.push(item);
    };

    this.toString = function(){
        return array.join();
    };
}

ArrayList下的方法，关于排序和搜索的函数

冒泡排序： this.bubbleSort
选择排序： this.selectionSort
插入排序： this.insertionSort
并归排序： this.mergeSort
快速排序： this.quickSort
顺序搜索： this.sequentialSearch
二分搜索： this.binarySearch

详细算法如下：

function ArrayList(){
    var array = [];

    this.insert = function(item){
        array.push(item);
    };

    this.toString = function(){
        return array.join();
    };
    /*
     * 冒泡排序: 比较任何两个相邻的元素， 如果第一个比第二个大则交换他们。
       时间复杂度: 最好：O(n), 一般情况： O(n2) 最差情况： O(n2)  |（n的平方）
       打开函数中的console可以看到排序次数和每次移动的元素
     */
    this.bubbleSort = function(){
        var length = array.length;

        for(var i=0; i<length; i++){
            for(var j=0; j<length-1-i; j++){
                if(array[j] > array[j+1]){
                    swap(j, j+1);   //交换函数后面有定义
                    //console.log(this.toString());
                }
            }
        }
    }

    /*
    * 选择排序：找到数据结构中的最小值并且放在第一位，接着找到第二小的值放在第二位，依次类推
      时间复杂度：O(n2) |最好一般最差都为n的平方。
      打开函数中的console可以看到排序次数和每次移动的元素
    */
    this.selectSort = function(){
        var length = array.length,
            indexMin;

            for (var i =0;  i < length;  i++) {
                indexMin = i;
                for(var j=i; j < length; j++){
                    if(array[indexMin] > array[j]){
                        indexMin = j;
                    }
                }
                if(i !== indexMin){
                    swap(i, indexMin);
                    console.log(this.toString());
                }
            }
    };

    var swap = function(index1, index2){
        var aux = array[index1];
        array[index1] = array[index2];
        array[index2] = aux;
    };

    /*
     * 插入排序： 每次排一个数组，以此方式构建组最后的排序数组。首先把要比较的一项放在临时变量temp中拿第二项和第一项比较如果第一项大于第二项则交换，然后拿第三项和第二项比较，如果第二项大于第三项，把第二项放在第三项中，再拿第二项和第一项比较，如果第一项大于第二项把第一项放在第二项上，把temp中的值放到第一项上， 如果第二项不小于第一项，就把temp放到第二项上面，依次类推。。。
     时间复杂度： 最好： O(n) 一般： O(n2) 最差 O(n2)
     */
     this.insertSort = function(){
        var length = array.length,
            j, temp;

        for(var i = 1; i < length; i++){
            j = i;
            temp = array[i];

            while(j>0 && array[j-1] > temp){
                array[j] = array[j-1];
                j--;
                console.log(this.toString());
            } 
            array[j] = temp; 

        }
     };

     /*
      * 并归排序：并归排序是一种分治算法， 其思想是将原来的数组切成较小的数组，直到每个小数组只有一个元素，接着将小数组归并为较大的数组， 直到最后一个排序完毕的大数组。
        时间复杂度为： 最好一般最差：O(nlogn);
      */
     this.mergeSort = function(){
        array = mergeSortRec(array);
     }

     var mergeSortRec = function(array){
        var length = array.length;
        if (length === 1) {
            return array;
        }
        var mid = Math.floor(length / 2),
            left = array.slice(0, mid),
            right = array.slice(mid, length);

            return merge(mergeSortRec(left), mergeSortRec(right));
     };

     var merge = function(left, right){
        var result = [],
        il = 0,
        ir = 0;
        while(il < left.length && ir < right.length){
            if(left[il] < right[ir]){
                result.push(left[il++]);
            }else{
                result.push(right[ir++]);
            }
        }
        while(il < left.length){
            result.push(left[il++]);
        }
        while(ir < right.length){
            result.push(right[ir++]);
        }
        return result;
     };
     /*
      *快速排序: ①首先从数组中选择中间一项作为主元素。②然后创建两个指针，左边一个指向数组的第一项，右边的一个指向数组的最后一项。移动左边的指针直到我们找到一个比主元素大的元素，接着，移动右边的指针直到找到一个比主元素小的元素，然后交换它们，重复这个过程直到左边的指针超过右边的指针。③接着较小的元素组成一个子数组，较大的元素组成一个子数组，重复步骤①②直到数组完全排序。
      时间复杂度：最好一般： O(nlogn) 最差 O(n2)
      */

     this.quickSort = function(){
        quick(array, 0, array.length-1);
     };

     var quick = function(array, left, right){
        var index;
        if(array.length > 1){
            index = partition(array, left, right);

            if(left < index-1 ){
                quick(array, left, index - 1 );
            }

            if(index < right ){
                quick(array, index, right); 
            }
        }
     }

     var partition = function(array, left, right){
        var pivot = array[Math.floor((right + left) / 2)],
            i = left,
            j = right;

            while(i <= j){
                while(array[i] <  pivot){
                    i++;
                }
                while(array[j] > pivot){
                    j--;
                }
                if(i <= j){
                    swapQuickStort(array, i, j);
                    i++;
                    j--;
                }
            }

        return i;
     };

     var swapQuickStort = function(array, index1, index2){

        var aux = array[index1];
        array[index1] = array[index2];
        array[index2] = aux;
     };

     /*
      * 查找 直接查找 最差情况:O(n)
      */

     this.sequentialSearch = function(item){
        for (var i = array.length - 1; i >= 0; i--) {
            if(item === array[i]){
                return i;
            }
        }

        return -1;
     };
     /*
      *二分法查找 查找前要把要查找的元素排序 最差情况： O(log(n))
      */

     this.binarySearch = function(item){
        this.quickSort();

        var low = 0,
            high = array.length -1,
            mid, element;

        while(low <= high){
            mid = Math.floor((low + high)/2);
            element = array[mid];
            if(element < item){
                low = mid +1;
            }else if(element > item){
                high = mid -1;
            }else{
                return mid;
            }
        }
        return -1;
     }
}

function createNonSortedArray(size){ //为数组添加元素的函数
    var array = new ArrayList();
    for(var i= size; i>0; i--){
        // array.insert(Math.floor(Math.random(1, size)*10));
        array.insert(i);
    }

    return array;
}

var array = createNonSortedArray(7);
console.log("排序前：" + array.toString());
array.bubbleSort();
console.log("冒泡排序：" + array.toString());
array.selectSort();
console.log("选择排序：" + array.toString());
array.insertSort();
console.log("插入排序：" + array.toString());
array.mergeSort();
console.log("并归排序："+ array.toString());
array.quickSort();
console.log("快速排序："+ array.toString());

console.log("直接查找：" + array.sequentialSearch(3));
console.log("二分查找：" + array.binarySearch(3));

运行结果：

前端jquery实现搜索功能 javascript 搜索_搜索