简单的排序算法

用的找到最大值，最小值的筛选逻辑

性能上暂时没有比较的例子，因为用的数组，它的删除操作，性能肯定会很低的。

const arr = [];
for (let i = 0; i < 30; i++) {
    arr.push(Math.round(Math.random() * 100));
}
class Sort {
    constructor(data) {
        this.data = [...data];
        this.min = [];
        this.max = [];
    }
    loop() {
        const {data} = this
        let min = data[0], max = data[0];
        let minIndex = 0, maxIndex = 0;
        data.map(
            (num, ind) => {
                if (num > max) {
                    max = num;
                    maxIndex = ind;
                }
                if (num < min) {
                    min = num;
                    minIndex = ind;
                }
            }
        );
        this.min.push(min);
        this.max.unshift(max);
        const larger = minIndex > maxIndex ? minIndex : maxIndex;
        const small = minIndex < maxIndex ? minIndex : maxIndex;
        data.splice(larger,1);  //这里的性能有损耗，最好的方法是用双链表
        data.splice(small,1);
        while(data.length>1){
            this.loop()
        }
        if (data.length === 1){
            this.min.push(data[0])
        }
    }
}
const sort = new Sort(arr)
sort.loop()
console.log(arr,sort);

优化——然后我又突发奇想，觉得可以用赋值来代替删除这种损耗性能的操作。同时，我又增加了，如果匹配到相等的结果最大值或最小值，同时纳入控制。

基本思路就是，每次循环遍历，都找到最大值和最小值的所有位置。然后最小值们依次跟第0，1，2，，，位的数字交换位置。交换了位置，记录好当前最小值占了第几位了，下次循环和交换从它们的占位的下一位开始搞。同理，最大值就是反过来操作的。如此的性能应该会很好了。

这里有问题！错误方法！后面的排序算法里我纠正了！

const arr = [];
for (let i = 0; i < 30; i++) {
    arr.push(Math.round(Math.random() * 100));
}
class Sort {
    constructor(data) {
        this.data = [...data];
        this.min = [];
        this.max = [];
        this.left = 0;
        this.right = data.length - 1;
    }
    loop1() {
        const {data} = this;
        let min = data[this.left], max = data[this.left];
        let minIndex = [this.left], maxIndex = [this.left];
        for (let i = this.left; i <= this.right; i++) {
            if (data[i] > max) {
                max = data[i];
                maxIndex = [i];
            } else if (data[i] === max && i !== this.left) {
                maxIndex.push(i);
            }
            if (data[i] < min) {
                min = data[i];
                minIndex = [i];
            } else if (data[i] === min && i !== this.left) {
                minIndex.push(i);
            }
            // console.log(minIndex,min,max,maxIndex)
        }
        if (max === min) return;
        minIndex.map(  //这里有问题，一旦要替换的位置的数据是当前的最大值，也就是maxIndex里的数，，，
            ind => {
                if (ind !== this.left) {
                    const leftVal = data[this.left];
                    const indVal = data[ind];
                      const index = this.maxIndex.indexOf(this.left)
                    (index >=0 && this.maxIndex[index] = ind)   //修补错误，未验证！
                    data[this.left] = indVal;
                    data[ind] = leftVal;
                }
                this.left += 1;
            }
        );
        maxIndex.map(
            ind => {
                if (ind !== this.right) {
                    const rightVal = data[this.right];
                    const indVal = data[ind];
                    data[this.right] = indVal;
                    data[ind] = rightVal;
                }
                this.right -= 1;
            }
        );
        while(this.right-this.left>1){
            this.loop1()
        }
    }
}
const sort = new Sort(arr);
// sort.loop();
// console.log(arr, sort);
sort.loop1()
console.log(sort.data)