数据结构与算法六(js 实现排序算法)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>排序</title>
</head>
<body>
<script>
    // 封装ArrayList
    function ArrayList() {
        this.array = []
        ArrayList.prototype.swap = function (m, n) {
            var temp = this.array[m]
            this.array[m] = this.array[n]
            this.array[n] = temp
        }
        ArrayList.prototype.insert = function (item) {
            this.array.push(item)
        }

        ArrayList.prototype.toString = function () {
            return this.array.join()
        }
        //冒泡排序
        ArrayList.prototype.bubbleSort = function () {
            // 1.获取数组的长度
            var length = this.array.length

            // 2.反向循环, 因此次数越来越少
            for (var i = length - 1; i >= 0; i--) {
                // 3.根据i的次数, 比较循环到i位置
                for (var j = 0; j < i; j++) {
                    // 4.如果j位置比j+1位置的数据大, 那么就交换
                    if (this.array[j] > this.array[j+1]) {
                        // 交换
                        this.swap(j, j+1)
                    }
                }
            }
        }
        //选择排序
        ArrayList.prototype.selectionSort = function () {
            // 1.获取数组的长度
            var length = this.array.length

            // 2.外层循环: 从0位置开始取出数据, 直到length-2位置
            for (var i = 0; i < length - 1; i++) {
                // 3.内层循环: 从i+1位置开始, 和后面的内容比较
                var min = i
                for (var j = min + 1; j < length; j++) {
                    // 4.如果i位置的数据大于j位置的数据, 记录最小的位置
                    if (this.array[min] > this.array[j]) {
                        min = j
                    }
                }
                this.swap(min, i)
            }
        }
        //插入排序
        ArrayList.prototype.insertionSort = function () {
            var length = this.array.length
            //外层循环,从第一个位置开始获取
            for(var i= 1;i< length;i++){
                //获取i位置,和前面的对比,一旦小于I位置数据就插入
                var temp = this.array[i]
                var j = i;
                while (this.array[j-1] > temp && j>0){
                    this.array[j] = this.array[j-1]
                    j--
                }
                this.array[j] = temp
            }


        }
        ArrayList.prototype.shellSort = function () {
            // 1.获取数组的长度
            var length = this.array.length

            // 2.根据长度计算增量
            var gap = Math.floor(length / 2)

            // 3.增量不断变量小, 大于0就继续排序
            while (gap > 0) {
                // 4.实现插入排序
                for (var i = gap; i < length; i++) {
                    // 4.1.保存临时变量
                    var j = i
                    var temp = this.array[i]

                    // 4.2.插入排序的内存循环
                    while (j > gap - 1 && this.array[j - gap] > temp) {
                        this.array[j] = this.array[j - gap]
                        j -= gap
                    }

                    // 4.3.将选出的j位置设置为temp
                    this.array[j] = temp
                }

                // 5.重新计算新的间隔
                gap = Math.floor(gap / 2)
              }
        }
        ArrayList.prototype.minddle = function (left,right) {
            //取出中间位置
            var
                    center = Math.floor((left + right)/2)
            //判断大小并进行交换
            if(this.array[left] > this.array[center]){
                this.swap(left,center)
            }
            if(this.array[center] > this.array[right]){
                this.swap(center,right)
            }
            if (this.array[left] > this.array[right]){
                this.swap(left,right)
            }
            //将center 换到Right -1的位置
            this.swap(center,right-1)
            return this.array[right -1];
        }
        ArrayList.prototype.quickSort = function () {
            this.quick(0,this.array.length -1)
        }
        ArrayList.prototype.quick = function (left,right) {
            //结束条件
            if(left >= right)return
            //获取枢纽
            var pivot = this.minddle(left,right)
            //定义变量
            var i = left;
            var j = right - 1;
            //进行交换操作
            while (true){
                while (this.array[++i] <pivot){}
                while (this.array[--j] > pivot){}
                if (i <j){
                    this.swap(i,j);
                }else{
                    break;
                }
            }
            //将枢纽放置在正确位置
            this.swap(i,right -1)

            this.quick(left,i -1)
            this.quick(i+1,right)
        }
    }
    // 初始化数据项
    var list = new ArrayList()
    list.insert(3)
    list.insert(6)
    list.insert(4)
    list.insert(2)
    list.insert(11)
    list.insert(10)
    list.insert(5)
    alert(list) // 3,6,4,2,11,10,5
    // 测试冒泡排序
    //    list.bubbleSort()
    //    alert(list) // 2,3,4,5,6,10,11

    // 测试选择排序
    //    list.selectionSort()
    //    alert(list) // 2,3,4,5,6,10,11

    // 测试插入排序
    //    list.insertionSort()
    //    alert(list) // 2,3,4,5,6,10,11

    // 测试希尔排序
//        list.shellSort()
    list.quickSort();
    alert(list)


</script>


</body>
</html>
数据结构与算法六(js 实现排序算法)

猜你喜欢
