关于冒泡排序、选择排序和快速排序算法的详解

冒泡排序

冒泡排序的核心思想

• 冒泡排序与选择拍排序不同，不需要定义索引值
• 而是直接遍历数组元素，在第一层循环意思就是总体的相邻数值两两比较需要比较的次数
• 第二层循环就是在走完一遍外循环之后，将前面比较好了拍到了后面的较大的值给排除掉，然后在剩下的元素中进行两两相邻的值比较
• 前面的值比后面的值大就替换位置，否则就不替换,直到排完全部

        //冒泡排序的核心思想
        //冒泡排序与选择拍排序不同，不需要定义索引值
        //而是直接遍历数组元素，在第一层循环意思就是总体的相邻数值两两比较需要比较的次数
        //第二层循环就是在走完一遍外循环之后，将前面比较好了排到了后面的较大的值给排除掉，然后在剩下的元素中进行两两相邻的值比较
        //前面的值比后面的值大就替换位置，否则就不替换,直到排完全部
        var arr = [6,9,7,3,4,8,10];
        for(i=0;i<arr.length-1;i++){//这里length-1的原因是因为arr中的元素只需要进行6次对比
            //第一层for循环就是总体需要循环遍历比较的次数
            // console.log(arr)//
            for(j=0;j<arr.length-1-i;j++){
                //第二层for循环是根据一层循环最大值排好的位数减去已经排好的值再进行两两比较
                var temp
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp
                }
                // console.log(arr);//打印21个结果
            }
            // console.log(arr);//打印6个结果
        }
        console.log(arr);//打印一个结果，所以打印结果要在循环体外打印，不然里面循环执行多少次就会打印多少次

选择排序

选择排序法的核心思想

• 先定义一个当下索引（下标）值的 元素值为最小值 的索引（下标）值，简而言之就是先定义一个下标元素值为数组中的最小元素值
• 再针对当前数组长度进行遍历，找到第一项，在第二层循环里找到第一项的后一项，从第一项的后一项开始遍历，对比二层循环当前项与外层定义的最小下标的值大小
• 如果比最小值还小，则交换两项的索引值
• 索引值交换成功后判断当前得到的最小值的索引值是否与外层循环赋给最小下标的索引值相同，如若相同则没必要进行位置替换，如若不同，则进行元素值位置的替换

        //选择排序法的核心思想
        //先定义一个当下索引（下标）值的 元素值为最小值 的索引（下标）值，简而言之就是先定义一个下标元素值为数组中的最小元素值
        //再针对当前数组长度进行遍历，找到第一项，在第二层循环里找到第一项的后一项，从第一项的后一项开始遍历，对比二层循环当前项与外层定义的最小下标的值大小
        //如果比最小值还小，则交换两项的索引值
        //索引值交换成功后判断当前得到的最小值的索引值是否与外层循环赋给最小下标的索引值相同，如若相同则没必要进行位置替换，如若不同，则进行元素值位置的替换
        var arr = [5,89,3,64,2,57,1,0,9]
        console.log(arr.length);//arr所拥有的元素个数为9个，所以长度为9
        for(var i=0;i<arr.length-1;i++){//第一层for循环arr长度-1是因为到第8位与最后一项比较时，只剩一项了，前面已经排好了，此时只要把第8项与最后一项比较换顺序就好了，换完即排完
            var minIndex = i;//先定义一个最小下标为i,跟随第一层for循环i的值变化而变化，将前面第一项已经排好的顺序给排除在外，不再用第一项跟其他项进行对比
            for(var m=i+1;m<arr.length;m++){//m=i+1是因为前面对比过的排到了前面的数字已经是排好的，再比较排序的话的话只需要基于当前还未进行比较换位置的i项的位置往后+一项进行比较即可
                if(arr[m]<arr[minIndex]){
                    minIndex = m//记录当前的最小值的下标
                }
            }
            // console.log(minIndex);
            if(minIndex != i){//对比之后发现最小值就是原来的位置的话就不交换位置，相反如果对比之后minIndex的值发生改变与外层初始赋值给minIndex的i的值不同，你就进行位置更换
                var temp
                temp = arr[minIndex];
                arr[minIndex] = arr[i];
                arr[i] = temp;
            }
        }
        console.log(arr);

快速排序

快速排序运用到的时递归的思想

• 首先我们对要传入的参数进行判断，如果说这个参数它是一个数组，那么我们就判断它的数组的长度，看里面的元素个数是否小于2，如果小于2直接return该数组
• 假若传入的参数不是一个数组，我们就直接给它return一个新的空数组
• 在传入的参数是一个数组且数组长度大于等于2的情况下，我们需要针对该数组取一个中间值，方法是先用数组长度/2且向下取整，得到中间那个下标，在针对这个下标取中间值，得到中间值后，用数组删除元素的splice方法进行删除且将它抽离出本身的数组，即改变了原数组的内容，也将中间值给独立出来，方便拿中间值和改变后的数组内容进行比较；
• 接下来创建两个新的数组，一个是用来承载中间值左边的元素内容，一个用承载中间值右边的元素内容
• 最后就是将左边和右边新组成的数组进行以上步骤的重复，也就是说我们可以针对以上重复的步骤进行一个方法的封装，在函数内部有需要重复步骤的内容重复调用即可，直到到达条件终止，这也称作递归思想

var arr = [23,2,13,7,1,34,65,4,8,5];
function quickSort(arr){
    //判断传入的arr参数是否是一个数组，如果是一个数组，且长度小于2，就返回该数组
    if(arr.length<2) return arr;
    //如果传入的参数不是一个数组，就给他返回一个新的数组
    if(!Array.isArray(arr)) return [];
    //针对该传入的arr数组，找到它的中间下标
    var middleIndex = Math.floor(arr.length/2);
    //针对该中间下标进行中间值的确定，并去出该中间值，从原数组中删除
    var middleValue = arr.splice(middleIndex,1);//该处得到的middleValue是一个数组
    //定义两个数组，一个为left，一个为right
    var left = [],right = [];
    //对改变后的数组进行遍历，将取出的中间值与改变后的数组内的元素一一比较，如果说大于中
    //间值就放在该中间值的右边那个数组，也就是说往数组right中添加元素，这里用到数组的添加
    //方法push
    for(var i = 0;i < arr.length;i++){
        if(arr[i] > middleValue){
            right.push(arr[i]);
        }
        if(arr[i] < middleValue){
            left.push(arr[i]);
        }
    }
    //合并数组
    return quickSort(left).concat(middleValue,quickSort(right));
}

console.log(quickSort(arr));