JS-数组和函数冒泡排序递归函数

数组和函数

数组

计算数组中所有元素的和

 // 定义数组
        var  nums = [23, 789, 67, 500, 123, 78, 900, 671];
        // 1.计算数组中所有元素的和
        var sum = 0;
        for (i = 0; i < nums.length; i ++) {
            sum += nums[i];
        }
        console.log('数组中所有元素的和为:',sum)
        console.log('')

计算数组中元素的平均数

        var avg = sum /nums.length;
        console.log('数组中元素的平均数为:',avg)

获取数组中最大的元素

var max = nums[0];//默认值是第一个元素
        for (var i = 1;i < nums.length; i ++) {
            if (nums[i]>max) {
                max = nums[i];
            }
        }
        console.log('数组中最大的元素为:',max);

获取数组中最小的元素

var min = nums[0];
        for (var i = 1;i < nums.length ; i ++) {
            if (nums[i] < min) {
                min = nums[i];
            }
        }
        console.log('数组中最小的元素为:', min)

数组的冒泡排序

 var nums = [23, 789, 67, 500, 123, 78, 900, 671];
        console.log(nums);

        // 开始循环，决定冒泡次数
        for (var n = 1; n < nums.length; n ++) {
            // 进行冒泡， 把当前最大的放在最后
            for (var i = 0; i < nums.length - n; i ++) {
                // 如果前面的元素比下一个元素大，交换两个元素的值
                if (nums[i] > nums[i + 1]) {
                    // 交换两个元素的值
                    var temp = nums[i];
                    nums[i] = nums[i + 1];
                    nums[i + 1] = temp;
                }
            }
        }

        console.log(nums);

冒泡 从大到小

var nums = [23, 789, 67, 500, 123, 78, 900, 671];
         console.log(nums);


         // 循环 决定冒泡次数
         for (var i = 1; i < nums.length; i ++) {
             // 进行冒泡排序
             for (var j = 0; j < nums.length - i; j ++) {
                 // 如果前面的元素比后面的元素小
                 if (nums[j] < nums[j + 1]) {
                     // 交换两个元素的值
                     var temp = nums[j];
                     nums[j] = nums[j + 1];
                     nums[j + 1] = temp;
                 }
             }
         }

         console.log(nums);

数组排序-sort

var nums = [23, 789, 67, 500, 123, 78, 900, 671]
        nums.sort(function(next,curr) {
            //return next-curr;
            if (next < curr) {
                return -1;
            }
        }) ;
        console.log(nums);

        nums.sort(function(next,curr) {
            return curr-next;
        });
        console.log(nums)

数组的平均值排序

 // 先计算平均值，再进行数组排序
         var nums = [
       		[234, 23, 34, 123, 899],
       		[12, 34, 611],
       		[902, 78, 675, 34, 2, 6],
       		[89, 78, 90, 67, 617, 890]
       ]
        // 排序
        nums.sort(function(next,curr) {
            return avg(next) - avg(curr)
        });
        console.log(nums)

       function avg(arr) {
            //  计算每个数组的和 遍历每个数组
            var sum = 0;
            for (var i = 0;i < arr.length; i ++) {
                sum += arr[i];
            }
            // 计算平均值
            return sum / arr.length;
       }

函数

判断是否是素数

function isPrime(num) {
    // 从2开始到num-1，一次去整除num
    for (var i = 2;i < num-1; i ++) {
        // 如果有一个能被整除，不是素数了
        if (num % i === 0) {
            return false
        }
    }
    // 如果能够执行到这里
    return true;  
}
console.log(isPrime(197));  //ture
console.log(isPrime(100));  //false


// 输出100-200之间的素数
for (var i = 100;i <= 200; i ++) {
    if(isPrime(i)) {
        console.log(i);
    }
}

所有参数的和

// 定义函数，计算所有参数的和
function sum()  {
    var res = 0;

    for (var i = 0;i < arguments.length; i ++) {
        res += arguments[i]
    }
    return res
}
console.log(sum(1,2,3))

获取数组中最大的数

function max() {
    var res = arguments[0];
    for (var i = 0;i < arguments.length; i ++) {
        if (arguments[i]>res) {
            res = arguments[i];
        }
    }
    return res;
}

console.log(max(23, 789, 67, 500, 123, 78, 900, 671))

数组排序

function arraySort(arr, isDown) {
    // 循环进行冒泡
    for (var i = 1; i < arr.length; i ++) {
        // 进行冒泡排序
        for (var n = 0; n < arr.length - i; n ++) {
            // 如果 isDown 是true，降序排列
            if (isDown) {   
                // 降序排列
                if (arr[n] < arr[n + 1]) {
                    // 交换两个元素的值
                    var temp = arr[n];
                    arr[n] = arr[n + 1];
                    arr[n + 1] = temp;
                }
            } else {
                // 升序排列
                if (arr[n] > arr[n + 1]) {
                    // 交换两个元素的值
                    var temp = arr[n];
                    arr[n] = arr[n + 1];
                    arr[n + 1] = temp;
                }
            }
        }
    }
    // 返回排好序的数组
    return arr;
}
// 定义数组
var nums = [100, 23, 56, 890, 567, 198, 230];

console.log(nums);

参数中的最大值和最小值

function max() {
    // 定义变量，记录最大值，默认是第一个参数
    var res = arguments[0];
    // 循环遍历所以的参数
    for (var i = 1; i < arguments.length; i ++) {
        // 如果由参数比 res 大，修改 res 的值
        if (arguments[i] > res) {
            res = arguments[i];
        }
    }
    // 返回结果
    return res;
}
/**
         * 取所有参数中最小的值
         * @return number 参数中值最小的
        */
function min() {
    // 定义变量，记录最大值，默认是第一个参数
    var res = arguments[0];
    // 循环遍历所以的参数
    for (var i = 1; i < arguments.length; i ++) {
        // 如果参数比 res 小，修改 res 的值
        if (arguments[i] < res) {
            res = arguments[i];
        }
    }
    // 返回结果
    return res;
}
console.log(max(123, 23423, 2342, 1231231, 1232,434, 4, 67));
console.log(min(123, 23423, 2342, 1231231, 1232,434, 4, 67));

递归函数-计算阶乘

// 定义函数，实现某个数字的阶乘
function fn(n) {
    // 如果 n 是小于等于 2
    if (n <= 2) {
        return n;
    }
    return n * fn(n - 1);
}

console.log('8的阶乘：', fn(8));
console.log('10的阶乘：', fn(10));
console.log('3的阶乘：', fn(3));

/*
            fn(4) 调用  执行 return 4 * fn(3)
                fn(3) 调用  return 3 * fn(2)
                    fn(2) 调用  return 2
                    fn(2) 调用结束
                fn(3) 调用结束 return 6;
            fn(4) 调用结束 return 24
        */

递归函数-累加

//第一种方法：单向分支，先递归再满足条件
function fnc(n) {
    if (n <= 1) {
        return n;
    } 
    return n + fnc(n-1);
}
console.log(fnc(100));

// 第二种方法：满足条件，再递归 
function fn(n){
    if (n > 1) {
        return n + fn(n -1);
    }
    return n;
}
console.log(fn(10));