JavaScript小练习2

1--对一个整数进行若干次变换，直到这个数只剩下一位数字，变换规则：将这个数变成所有位数上的数字的乘积，输出变换的次数

function GetResult(n){
    var count = 0;
    while(n>= 10){  //n大于等于10的遍历，即不满足变换规则停止的条件下应该做的事
        var m = n;  //保存n变量
        var s = 1;  //乘数设置
        var str  = m + "=";  //变换规则输出的定义
        while(m) {   //n存在的遍历
            s *= m % 10;  //求取最后一位上的数字，并进行乘积运算
            if(m <10){   //输出样式调整
                str += m% 10；
            }else {
                str += m % 10 + "*";
            }
            m = parseInt(m/10);  //将输入的数减少一位，即末尾数去掉
        }
        console.log(str)；
        n = s;
        count++；

    }
    console.log(count);
    return n;
}
console.log(GetResult(3369))
/*
3369=9*6*3*3
486=6*8*4
192=2*9*1
18=8*1
4
8
*/

2--冒泡排序

思想：比较相邻的两个元素，若前一个元素比后一个大，则交换位置；第一轮的时候最后一个元素应该是最大的一个；按照步骤1方法进行相邻两个元素的比较，这个时候最后一个元素已经是最大的了，不需要再进行比较。

function bubblesort(arr){
    for(var i=0;i<arr.length-1;i++){
        for(var j=0;j<arr.length-i-1;j++){
           if(arr[j] > arr[j+1]){
               var temp=arr[j];
               arr[j]=arr[j+1];
               arr[j+1]=temp;
           }
        }
    }
}
var arr=[1,3,4,6,2,9,5];
console.log(arr);
bubblesort(arr);
console.log(arr);

3-- 快排

思想：选择一个基准数，这里以数组第一个元素为基准，对数组从第二个元素开始进行遍历，对于大于基准的元素push进right数组，对于小于基准的元素push进left数组。对left、right数组进行递归。将left、pivot、right相拼接。

function quickSort(arr){
    if(arr.length<=1) {
      return arr;
    }
    var left=[];
    var right=[];
    var pivot=arr[0];
    for(var i=1;i<arr.length;i++){
        if(arr[i]<pivot) {
          left.push(arr[i]);
        }else {
          right.push(arr[i]);
        }
    }
    return quickSort(left).concat(pivot,quickSort(right));
}
var arr=[5,6,2,1,3,8,7,1.2,5.5,4.5];
console.log(quickSort(arr));

4--插入排序
思想：

（1） 从第一个元素开始，该元素可以认为已经被排序
（2） 取出下一个元素，在已经排序的元素序列中从后向前扫描
（3） 如果该元素（已排序）大于新元素，将该元素移到下一位置
（4） 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
（5）将新元素插入到下一位置中
（6） 重复步骤2

function insertSort(arr){
    if(arr.length <= 1){
        return arr
    }
    for(var i=1; i<arr.length; i++){
        var tmp = arr[i]      //把arr[i]保存起来，防止被覆盖
        var j = i-1           //定位排好序的最大元素
        while(tmp < arr[j] && j>=0){   //如果要插入的元素小于排好序的最大元素，将该最大元素向后移，j向前移，继续比较
            arr[j+1] = arr[j]
            j--
        }
        arr[j+1] = tmp                
    }
    return arr
}

var arr = [5,3,2,4,1,10]
console.log(insertSort(arr))

5--二分查找

思想：二分法查找，也称折半查找，是一种在有序数组中查找特定元素的搜索算法。查找过程可以分为以下步骤：
（1）首先，从有序数组的中间的元素开始搜索，如果该元素正好是目标元素（即要查找的元素），则搜索过程结束，否则进行下一步。
（2）如果目标元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半区域查找，然后重复第一步的操作。
（3）如果某一步数组为空，则表示找不到目标元素。

递归：
function binarySearch(arr,findVal,leftIndex,rightIndex){
    if(leftIndex>rightIndex){
        return ;
    }
    var midIndex=Math.floor((leftIndex+rightIndex)/2);
    var midVal=arr[midIndex];
    if(midVal>findVal){
        binarySearch(arr,findVal,leftIndex,midIndex-1);
    }else if(midVal<findVal){
        binarySearch(arr,findVal,midIndex+1,rightIndex);
    }else{
        console.log(“找到，下标为：”+midIndex);
        return
    }
}


非递归：
function binarySearch(data, item){
    var h = data.length -1, l = 0;
    while(l <= h ){
        var m = Math.floor((h+l)/2);
        if(data[m]===item){  //找到
            return m;
        }else if(item > data[m]){  //如果要查找的数据大于中间值，则在右半边查找
            l = m + 1;
        }else{      //要查找的数据小于中间值，则在左半边查找
            h = m -1;
        }
    }
    return -1;
}