本节作业之数组求和及其平均值、求数组最大值、最小值、数组转换为分割字符串、新增数组案例、筛选数组案例、删除指定数组元素、翻转数组、数组排序(冒泡排序)

求数组[2,6,1,7,4]里面所有的元素的和以及平均值

// 声明一个求和变量sum
// 遍历这个数组，把里面每个数组元素加到sum里面
// 用求和变量sum除以数组的长度就可以得到数组的平均值
var sum = 0;
var avg = 0;
var arr = [2,6,1,7,4];
for (var i = 0; i < arr.length; i++) {
	// 我们加的是数组元素 不是计数器
    sum += arr[i];
}
avg = sum / arr.length;
// 输入多个变量
console.log(sum,avg);
1
2
3
4
5
6
7
8
9
10
11
12
13

求数组[2,6,1,77,52,25,7]中的最大值

// 声明一个保存最大元素的变量max
// 默认最大值可以取数组中的第一个元素
// 遍历这个数组，把里面的每个数组元素和max相比较
// 如果这个数组元素大于max就把这个数组元素存到max里面，否则继续下一轮比较
// 最后输出这个max
        
var arr = [2,6,1,77,52,25,7];
var max = arr[0];
// 本身i应该从0开始，但是我们已经让max默认值为第一个元素，故应从第二个开始
for (var i = 1; i < arr.length; i++) {
	if (arr[i] > max) {
    	max = arr[i]
	}
}
console.log('该数组里面的最大值是：' + max);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

求数组[2,6,1,77,52,25,7]中的最小值

var arr = [2,6,1,77,52,25,7];
var min = arr[0];
// 本身i应该从0开始，但是我们已经让max默认值为第一个元素，故应从第二个开始
for (var i = 1; i < arr.length; i++) {
	if (arr[i] < min) {
    	min = arr[i]
    }
}
console.log('该数组里面的最小值是：' + min);
1
2
3
4
5
6
7
8
9

将数组[‘red’,‘green’,‘blue’,‘pink’]转换为字符串，并且用|或其它符号分割

// 输出：'red|green|blue|pink|'
// 需要一个新变量用于存放转换完的字符串str
// 遍历原来的数组，分别把里面的数据取出来，加到字符串里面
// 同时在后面多加一个分隔符

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);
1
2
3
4
5
6
7
8
9
10
11
12

新建一个数组，里面存放10个整数(1~10)

// 使用循环来追加数组
// 声明一个空数组arr
// 循环中的计数器i 可以作为数组元素存入
// 由于数组的索引号是从0开始的，因此计数器从0开始更合适，存入的数组元素要+1

var arr = [];
for (var i = 0; i < 10; i++) {
	// arr = i; 错误 不要直接给数组名赋值，否则以前的元素都没了
    arr[i] = i + 1; 
}
console.log(arr);
1
2
3
4
5
6
7
8
9
10
11

将数组[2,0,6,1,77,0,52,0,25,7]中大于等于10的元素选出来，放入新数组

// 声明一个新的数组用于存放新数据newArr
// 遍历原来的旧数组，找出大于等于10的元素
// 依次追加给新数组newArr

// 方法一：
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) {
    	// newArr[i] = arr[i]; 此写法会产生很多空元素
    	// 新数组索引号应该从0开始 依次递增
    	newArr[j] = arr[i];
        j++;
    }
}
console.log(newArr);

// 方法二：
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) {
    	// newArr[i] = arr[i]; 此写法会产生很多空元素
        // 新数组索引号应该从0开始 依次递增
        newArr[newArr.length] = arr[i];
        /* 1> newArr.length = 0  上式可看做newArr[0] = arr[i];
        2> newArr.length = 1 因为存入了第一个值77 上式可看做newArr[1] = arr[i];
        3> newArr.length = 2 因为存入了第一个值52 上式可看做newArr[2] = arr[i];
        4> newArr.length = 3 因为存入了第一个值25 上式可看做newArr[3] = arr[i]; */
	}
}
console.log(newArr);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

将数组[2,0,6,1,77,0,52,0,25,7]中的0去掉后，形成一个不包含0的新数组

// 需要一个新数组用于存放筛选后的数据
// 遍历原来的数组，把不是0的数据添加到新数组里面(此时要注意采用数组名+索引的格式接收数据)
// 新数组里面的个数，用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);
1
2
3
4
5
6
7
8
9
10
11
12

将数组[‘red’,‘green’,‘blue’,‘pink’,‘purple’]的内容反过来存放

// 输出：['purple','pink','blue','green','red']
// 声明一个新数组newArr
// 把旧数组索引号第四个取过来(arr.length - 1)，给新数组索引号第0个元素(newArr.length)
// 我们采取递减的方式 i--

var arr = ['red','green','blue','pink','purple'];
var newArr = [];
for (var i = arr.length - 1; i >= 0 ; i--) {
	newArr[newArr.length] = arr[i];
}
console.log(newArr);
1
2
3
4
5
6
7
8
9
10
11

冒泡排序

• 冒泡排序：是一种算法，把一系列的数据按照一定的顺序进行排列显示(从小到大或从大到小)。
  

var arr = [5, 4, 3, 2, 1];
// 外层循环管趟数
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;
        }
    }
}
console.log(arr);
1
2
3
4
5
6
7
8
9
10
11
12
13
14