计算数组和平均值
-
求数组 [2,6,1,7, 4] 里面所有元素的和以及平均值。
案例分析
① 声明一个求和变量 sum。
② 遍历这个数组，把里面每个数组元素加到 sum 里面。
③ 用求和变量 sum 除以数组的长度就可以得到数组的平均值
// 1. 求数组 [2,6,1,7, 4] 里面所有元素的和以及平均值。
// (1)声明一个求和变量 sum。
// (2)遍历这个数组，把里面每个数组元素加到 sum 里面。
// (3)用求和变量 sum 除以数组的长度就可以得到数组的平均值。
var arr = [2, 6, 1, 7, 4];
var sum = 0;
var average = 0;
for (var i = 0; i < arr.length; i++) {
sum += arr[i]; // 我们加的是数组元素 arr[i] 不是计数器 i
}
average = sum / arr.length;
console.log(sum, average); // 想要输出多个变量，用逗号分隔即可
求数组中的最大值
// 求数组[2,6,1,77,52,25,7]中的最大值
// 声明一个保存最大元素的变量 max。
// 默认最大值可以取数组中的第一个元素。
// 遍历这个数组，把里面每个数组元素和 max 相比较。
// 如果这个数组元素大于max 就把这个数组元素存到 max 里面，否则继续下一轮比较。
// 最后输出这个 max
var arr = [2, 6, 1, 77, 52, 25, 7, 99];
var max = arr[0];
for (var i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
console.log('该数组里面的最大值是：' + max);
数组转换为字符串
// 将数组 ['red', 'green', 'blue', 'pink'] 转换为字符串，并且用 | 或其他符号分割
// 1.需要一个新变量用于存放转换完的字符串 str。
// 2.遍历原来的数组，分别把里面数据取出来，加到字符串里面。
// 3.同时在后面多加一个分隔符
var arr = ['red', 'green', 'blue', 'pink'];
var str = '';
var sep = '*';
for (var i = 0; i < arr.length; i++) {
str += arr[i] + sep;
}
console.log(str);
数组存放值
// 新建一个数组，里面存放10个整数（ 1~10）
// 核心原理：使用循环来追加数组。
// 1、声明一个空数组 arr。
// 2、循环中的计数器 i 可以作为数组元素存入。
// 3、由于数组的索引号是从0开始的， 因此计数器从 0 开始更合适，存入的数组元素要+1。
var arr = [];
for (var i = 0; i < 100; i++) {
// arr = i; 不要直接给数组名赋值 否则以前的元素都没了
arr[i] = i + 1;
}
console.log(arr);
数组筛选
// 将数组 [2, 0, 6, 1, 77, 0, 52, 0, 25, 7] 中大于等于 10 的元素选出来，放入新数组。
// 1、声明一个新的数组用于存放新数据newArr。
// 2、遍历原来的旧数组， 找出大于等于 10 的元素。
// 3、依次追加给新数组 newArr。
// 方法1
var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var newArr = [];
var j = 0;
for (var i = 0; i < arr.length; i++) {
if (arr[i] >= 10) {
// 新数组索引号应该从0开始 依次递增
newArr[j] = arr[i];
j++;
}
}
console.log(newArr);
// 方法2
var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var newArr = [];
// 刚开始 newArr.length 就是 0
for (var i = 0; i < arr.length; i++) {
if (arr[i] >= 10) {
// 新数组索引号应该从0开始 依次递增
newArr[newArr.length] = arr[i];
}
}
console.log(newArr);
数组去重
// 将数组[2, 0, 6, 1, 77, 0, 52, 0, 25, 7]中的 0 去掉后，形成一个不包含 0 的新数组。
// 1、需要一个新数组用于存放筛选之后的数据。
// 2、遍历原来的数组， 把不是 0 的数据添加到新数组里面(此时要注意采用数组名 + 索引的格式接收数据)。
// 3、新数组里面的个数， 用 length 不断累加。
var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var newArr = [];
for (var i = 0; i < arr.length; i++) {
if (arr[i] != 0) {
newArr[newArr.length] = arr[i];
}
}
console.log(newArr);
2.---------
// 数组去重 ['c', 'a', 'z', 'a', 'x', 'a', 'x', 'c', 'b'] 要求去除数组中重复的元素。
// 1.目标： 把旧数组里面不重复的元素选取出来放到新数组中， 重复的元素只保留一个， 放到新数组中去重。
// 2.核心算法： 我们遍历旧数组， 然后拿着旧数组元素去查询新数组， 如果该元素在新数组里面没有出现过， 我们就添加， 否则不添加。
// 3.我们怎么知道该元素没有存在？ 利用 新数组.indexOf(数组元素) 如果返回时 - 1 就说明 新数组里面没有该元素
// 封装一个 去重的函数 unique 独一无二的
function unique(arr) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
if (newArr.indexOf(arr[i]) === -1) {
newArr.push(arr[i]);
}
}
return newArr;
}
var demo = unique(['c', 'a', 'z', 'a', 'x', 'a', 'x', 'c', 'b'])
// var demo = unique(['blue', 'green', 'blue'])
console.log(demo);
翻转数组
// 将数组 ['red', 'green', 'blue', 'pink', 'purple'] 的内容反过来存放
// 1、声明一个新数组 newArr
// 2、把旧数组索引号第4个取过来（arr.length - 1)，给新数组索引号第0个元素 (newArr.length)
// 3、我们采取 递减的方式 i--
var arr = ['red', 'green', 'blue', 'pink', 'purple', 'hotpink'];
var newArr = [];
for (var i = arr.length - 1; i >= 0; i--) {
newArr[newArr.length] = arr[i]
}
console.log(newArr);
--------------------
// 1. 翻转数组
var arr = ['pink', 'red', 'blue'];
arr.reverse();
console.log(arr);
冒泡排序
- 冒泡排序：是一种算法，把一系列数据按照一定顺序进行排列显示（从大到小或从小到大）
// 冒泡排序
// var arr = [5, 4, 3, 2, 1];
var arr = [4, 1, 2, 3, 5, 6, 9, 7];
for (var i = 0; i <= arr.length - 1; i++) { // 外层循环管趟数
for (var j = 0; j <= arr.length - i - 1; j++) { // 里面的循环管 每一趟的交换次数
// 内部交换2个变量的值 前一个和后面一个数组元素相比较
if (arr[j] < arr[j + 1]) {
var temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
console.log(arr);
--------------------
// 冒泡
var arr = [4, 1, 2, 3, 5, 6, 9, 7];
var temp
var i = 0
while (i < arr.length) {
var j = 0
while (j < arr.length - 1) {
if (arr[j] < arr[j + 1]) {
var temp = arr[j]
arr[j] = arr[j + 1]
arr[j + 1] = temp
}
j++
}
i++
}
console.log(arr);
方法2
// 2. 数组排序（冒泡排序）
var arr1 = [13, 4, 77, 1, 7];
arr1.sort(function(a, b) {
// return a - b; 升序的顺序排列
return b - a; // 降序的顺序排列
});
console.log(arr1);
插入排序
// 插入排序:
// 前提: 升序
// 思想: 一般假设前面第一个元素是一个有序序列.循环后面元素和前面有序序列最后一个元素进行比较，
// 如果后面的元素比有序序列的最后一个元素大， 不用挪动位置.
// 如果后面的元素A比有序序列的最后一个元素小, 那么A就应该继续往有序序列的前面查找， 找到它应该存放的位置, 在这个位置插入元素A
var numbers = [3, 44, 38, 5, 47, 15, 36, 26, 27];
for (var i = 0; i < numbers.length; i++) {
//取出后面一位的元素 和 前面的有序序列进行对比
for (var j = i + 1; j > 0; j--) {
if (numbers[j] < numbers[j - 1]) { //后面的元素比有序序列的前一个元素小，交换位置
//交换位置
var tmp = numbers[j];
numbers[j] = numbers[j - 1];
numbers[j - 1] = tmp;
} else {
//如果当前元素没有比前面的小，这个元素在当前位置不动.它已经是有序队列里面最大.
break;
}
}
}
console.log("插入排序的结果==>", numbers);
///插入排序另外写法/升序//
var nums = [3, 44, 38, 5, 47, 15, 36, 26, 27, ];
//从1开始循环 假设第一个元素是一个有序列表
for (var i = 1; i < nums.length; i++) {
var preIndex = i - 1; //代表 有序列表的最后一个元素的下标
var current = nums[i]; //取出当前的值.
//判断 preIndex 下标大于0 当前值如果比有序列表的最后一个值要小
while (preIndex >= 0 && current < nums[preIndex]) {
nums[preIndex + 1] = nums[preIndex]; //把前面比当前值大的数据往后挪一位
preIndex--; //继续查找前面的元素 往后面挪.
}
//前面已经挪动完成，现在把当前值插入前面位置.
// XXXXXXXXXXXX 条件不成立的时候 多减了1 所有这里加+1
nums[preIndex + 1] = current;
}
console.log("插入排序结果22==》", nums);
// ---------------
var arr = ['3', '7', '2', '9', '4', '8', '1', '5', '6']
for (var i = 1; i < arr.length; i++) {
let curValue = arr[i]
var j = i - 1;
while (j >= 0 && curValue < arr[j]) {
arr[j + 1] = arr[j]
j--
}
arr[j + 1] = curValue
}
console.log(arr);
331
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
