EasySort

//##排序和搜索算法
    //1.冒泡排序
    //2.选择排序
    //3.插入排序
    //4.归并排序
    //5.快排
        //1.首先,在数组中选择一个值作为主元,也就是数组中间的那个值
        //2.创建两个指针引用,左边一个指向数组的第一个值,右边一个指向数组的最后一个值
        //移动左指针找到一个比主元大的值,移动右指针找到一个比主元小的值,然后交换
        //重复这个过程,直到左指针超过右指针,这一步叫做划分操作
        //3.接着对划分后的小数组重复之前的步骤,最后数组完全排序
        // 算法复杂度:O(nlog(n))
    // 封装ArrayList
    function ArrayList() {
        this.array = []

        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 () {
            // 1.获取数组的长度
            var length = this.array.length

            // 2.外层循环: 外层循环是从1位置开始, 依次遍历到最后
            for (var i = 1; i < length; i++) {
                // 3.记录选出的元素, 放在变量temp中
                var j = i
                var temp = this.array[i]

                // 4.内层循环: 内层循环不确定循环的次数, 最好使用while循环
                while (j > 0 && this.array[j-1] > temp) {
                    this.array[j] = this.array[j-1]
                    j--
                }

                // 5.将选出的j位置, 放入temp元素
                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.swap = function (m, n) {
            var temp = this.array[m]
            this.array[m] = this.array[n]
            this.array[n] = temp
        }

        // 选择枢纽
        ArrayList.prototype.median = function (left, right) {
            // 1.求出中间的位置
            var center = Math.floor((left + right) / 2)

            // 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)
            }

            // 3.巧妙的操作: 将center移动到right - 1的位置.
            this.swap(center, right - 1)

            // 4.返回pivot
            return this.array[right - 1]
        }

        // 快速排序实现
        ArrayList.prototype.quickSort = function () {
            this.quickSortRec(0, this.array.length - 1)
        }

        ArrayList.prototype.quickSortRec = function (left, right) {
            // 0.递归结束条件
            if (left >= right) return

            // 1.获取枢纽
            var pivot = this.median(left, right)

            // 2.开始进行交换
            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
                }
            }

            // 3.将枢纽放在正确的位置
            this.swap(i, right - 1)

            // 4.递归调用左边
            this.quickSortRec(left, i - 1)
            this.quickSortRec(i + 1, right)
        }
    }