算法_内部排序_冒泡排序(javascrpt语言实现)

• 排序可分为内部排序和外部排序。
• 内部排序：所有需要排序的数据存放在内存中。在内存中调整数据的存储顺序，遮掩的排序称为内部顺序。
• 外部排序： 待排记录数据量较大，排序是只有部分数据别调入内存，排序过程中存在多次内、外存之间的交换，这样的排序称为外部排序。
• 内部排序可分为：交换排序、插入排序、选择排序、归并排序和基数排序五大类。

交换排序

• 交换排序的核心思想是：根据徐磊中两台哦记录键值得比较结果，判断是否需要交换记录在序列中的位置。其特点是将键值较大（或较小）的记录向序列的前端移动，将键值较小(或较大)的记录向后端移动。

简单交换排序

举例代码(简单交换排序)

//定义全局变量
var temp;
//将一个数组降序排序
var arr1=[2,0,9,8,1,4,6,3,7,5];

//length=arr.length;
function simpleChangeSort(arr){
    //数组下标从0开始 最大的下标是length-1; 
    //总共有length个数，要比较(length-1)轮
    //第一轮:数组下标为0的数组元素与数组下标为1,2....length-1进行逐个比较，选出最大的数组元素赋值给arr[0]。
    //第二轮:数组下标为1的数组元素与数组下标为2,3....length-1进行逐个比较，选出最大的数组元素赋值给arr[1]。
    //第二轮:数组下标为2的数组元素与数组下标为3,4....length-1进行逐个比较，选出最大的数组元素赋值给arr[2]。
    //....
    //第length-1轮，无需比较。
    //此期间arr[0]的值可能因为比较大小发生改变。
    //获取数组的长度
    length=arr.length;
    for(var i=0;i<length;i++){//外层循环是表示要比较多少轮，总共要比较(length-1)轮
        //里层j表示要比较的数组下标，j大于等于1，小于length-1
        for(var j=i+1;j<length;j++){
            if(arr[i]< arr[j]){ //arr[i]小,则交换，把数组元素大的交换到前面来
              temp=arr[i];
              arr[i]=arr[j];
              arr[j]=temp;
            }
                       
        }        
    }
    return arr;
}
simpleChangeSort(arr1);

冒泡排序

• 经过冒泡排序(bubble sort)得到的徐磊，较大(或较小)的数据会“浮到”序列的顶端(或底部)。
• 冒泡排序的基本原则：n个 数字排序,比较两两相邻的记录的关键字，使不满足序列要求的记录交换位置，直到n-1轮循环村换操作结束。
• 冒泡排序获得降序排列的基本操作如下:
  1. 从头部开始，比较相邻的两个元素arr[i]和arr[i+1],如果第二个元素比第一个元素大，进行数据交换
  2. 指针向后移动，即i=i+1,再比较元素arr[i]和arr[i+1],判断是否需要交换数据。
  3. 针对序列中每一对两两相邻的 数据重复以上不走，直到指针指向最后一个位置。
  4. 在每一轮循环中重复步骤(1-3),直到n-1轮循环执行结束。

var arr1=[2,0,9,8,1,4,6,3,7,5];
//冒泡排序算法实现
//传递一个数组
function BulbbleSort(arr){
    //获取数组长度
    length=arr.length;
    for(var i=0;i<length-1;i++){//要进行(length-1)轮循环比较,i=length-1停止循环，临界条件最后一个不用比较。
        //内层循环，两两数组元素比较，都是从下标为0开始，且考虑数组最大的下标为n-1,
        //所以 j=0; j<n-1,但是每进行一轮比较完成，内层循环的比较的数组元素都会少一个,因为每进行一轮比较都有一个元素浮到最上(下)方,已经排好序了
        //所以进行i轮排序，j(比较次数)肯定小于n-1-i;
        for(var j=0;j<length-i-1;j++){
            if(arr[j]<arr[j+1]){
                var temp;
                //交换
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }

    }
    return arr;
}
BulbbleSort(arr1);//[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

• 考虑到时间复杂度和空间复杂度，可以对冒泡排序进行优化，避免一些不必要的比较(比如一部分元素已经有序的情况，无需比较)

var arr1=[2,0,9,8,1,4,6,3,7,5];
function BulbbleSort_B(arr){
    //获取数组长度
    length=arr.length;
    //设置标志变量，判断是否有必要进行循环比较
    var flag=1;
    for(var i=0;i<length-1;i++){//要进行(length-1)轮循环比较,i=length-1,结束循环，因为此时要比较的元素只剩一个,自然有序
        //内层循环，两两数组元素比较，都是从下标为0开始，且考虑数组最大的下标为n-1,
        //所以 j=0; j<n-1,但是每进行一轮比较完成，内层循环的比较的数组元素都会少一个,因为每进行一轮比较都有一个元素浮到最上(下)方,已经排好序了
        //所以进行i轮排序，j(比较次数)肯定小于n-1-i;
        //进入内层循环前将标志变量置为0,
        flag=0;
        for(var j=0;j<length-i-1&&flag;j++){
            if(arr[j]<arr[j+1]){
                flag=1;
                var temp;
                //交换
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }

    }
    return arr;
}
BulbbleSort_B(arr1);//[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]