数组练习题
1.用js实现随机选取10~100之间的10个数字，存入一个数组，并排序
//要是获取不重复的，则对随机数再进行去重。
function arrRandom() {
var arr = [];
for (var i = 0; i < 10; i++) {
var num = getRandomNum(10, 100);
arr.push(num);
}
return arr.sort(function (a, b) {
return a - b;
});
}console.log(arrRandom());
//2.获取范围内的随机数
function getRandomNum(startNum, endNum) {
if (startNum <= endNum) {
return parseInt(Math.random() * (endNum - startNum + 1) + startNum);
}
else {
return parseInt(Math.random() * (startNum - endNum + 1) + endNum);
}
}
2.编写尽可能简洁的javascript代码，找到在第一个数组array1中出现，而在第二个数组array2中没有出现的数字。
indexof()判断数字是否出现，join()用于把数组中的所有元素连接成一个字符串，元素是通过指定的分隔符进行分隔的。
//方法1--注意这种方法只能对比数字。
// 并且有个bug，要是数组一中第一个元素是1，数组二中最后一个元素尾数也是1，则认为数组一中的第一个元素和数组二中的最后一个元素相同。
function findNullOfArr(arrOne, arrTwo) {
var str = arrTwo.join("");
var result = [];
for (var i = 0; i < arrOne.length; i++) {
// 看到这里有个小点就是 indexOf 会做简单的类型转换，把数字转换成字符串 '2' 然后再执行。
if (str.indexOf(arrOne[i]) == -1) {
result.push(arrOne[i]);
console.log(typeof arrOne[i]);
}
}
return result;
}
var arr1 = [1, 22, 3, 44, 5, 6, 7];
var arr2 = [2, 3, 441];
var b = [findNullOfArr(arr1, arr2)];
console.log(b);
// 方法2--找到在第一个数组array1中出现，而在第二个数组array2中没有出现的数字。
function duplicates(arrOne, arrTwo) {
var final = [];
var result = [];
//数组一和数组二中都有的元素放进final。
for (var i = 0; i < arrOne.length; i++) {
for (var j = 0; j < arrTwo.length; j++) {
if (arrOne[i] == arrTwo[j] && final.indexOf(arrOne[i]) == -1) {
final.push(arrOne[i]);
}
}
}
//数组一和final比较，final没有的就放进去。
for (var i = 0; i < arrOne.length; i++) {
if (final.indexOf(arrOne[i]) == -1) {
result.push(arrOne[i]);
}
}
return result;
}
var arr1 = [2, 2, 3, 4, 5, 5, 7, "a"];
var arr2 = [8, 2, 3, 4, 5, 5];
console.log(duplicates(arr1, arr2));
3.数组去重。
var arrNum = [1,4,1,1,3,3,4,6,7,8,3,7,0,11,22,22];
方法1.遍历数组法
最简单的去重方法，实现思路：新建一新数组，遍历传入数组，值不在新数组就加入该新数组中；注意点：判断值是否在数组的方法“indexOf”是ECMAScript5 方法，IE8以下不支持，需多写一些兼容低版本浏览器代码，源码如下：
function arrNoRepeat(arr) {
var newArr = [];
for (var i = 0; i < arr.length; i++) {
if (newArr.indexOf(arr[i]) == -1) {
newArr.push(arr[i]);
}
}
return newArr;
}
var arr = [2, 2, 1, 4, 5, 4];
console.log(deleteRepeat(arr));
方法2.优化遍历数组法
该方法的实现代码相当酷炫，实现思路：获取没重复的最右一值放入新数组。（检测到有重复值时终止当前循环同时进入顶 层循环的下一轮判断）推荐
// 思路：获取没重复的最右一值放入新数组
var arr = [1, 3, 5, 7, 9, 1, 3, 5];
function unique5(array) {
var r = [];
for (var i = 0, l = array.length; i < l; i++) {
for (var j = i + 1; j < l; j++)
if (array[i] === array[j]) j = ++i;
r.push(array[i]);
}
return r;
}
console.log(unique5(arr));
4.现有一个数组（元素为数字，并且有可能重复），请给Array.prototype增加一个方法（方法名自取），该方法能去掉数组中全部最大和最小的数字。
数组最大值
Array.prototype.max = function(){ return Math.max.apply(null,this);}
数组最小值
Array.prototype.min = function(){ return Math.min.apply(null,this);}
5.给定一个数组实现字符串反转，要求原地实现。
使用循环数组的方法：
var arr = new Array();
function myreverse(arr){
for(var i =0;i < arr.length/2;i ++){
var temp = arr[i];//交换变量
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}}
6.如何准确判断一个javascript对象是数组？
标准方法：
if(object.prototype.toString.call(a) == '[object Array]'){ //是数组对象}
常用方法：
if(a.constructor == Array){ //是数组对象}
7.写出一个javascript的函数，实现对一个数组去重的功能。
构建一个新的数组存放结果。
for循环中每次从原数组中取出一个元素，用这个元素循环与结果数组对比。
若结果数组中没有该元素，则存到结果数组中。
Array.prototype.unique1 = function(){
var res = [this[0]];
for(var i =1;i < this.length;i ++){
var repeat = false;
for(var j = 0;j < res.length;j ++){
if(this[i] == res[j]){
repeat = true;
break;
} }
if(!repeat){
res.push(this[i]);
} }
return res;}
var b = arr.unique1()
alert(b);
8.请写出一个函数，功能是删除数组的指定下标元素。
array.pop();//删除最后一个元素，并返回该元素.
array.shift();//删除第一个元素，数组元素位置自动前移，返回被删除的元素
array.splice(start,delCount);//从start的位置开始向后删除delCount个元素
// 3.请写出一个函数，功能是删除数组的指定下标元素。
function deleteNumArr(arr, index) {
if (isNaN(index) || index > arr.length - 1) {
return false;
}
else {
arr.splice(index, 1);
return arr;
}
}
var arr = [2, 3, 4, 5, 6];
alert(deleteNumArr(arr, 1));
9.请写一个函数removeVoid(arr)，删除该数组中值为“null，undefined”的项，返回原数组。
function removeVoid(arr) {
for (var i = 0; i < arr.length; i++) {
if (arr[i] == "" || arr[i] == "undefined" || !arr[i]) {//!arr[i])过滤不是数组的元素，比如null（空值）。
arr.splice(i, 1);
}
}
return arr;
}
var arr = [, 1, undefined, 2, null, 5];
alert(removeVoid(arr));
10.数组去重，给Array本地对象增加一个原型方法。
Array.prototype.delrepeat = function(){
var arr = this;
var _arr = new Array();
for(var i in arr){
if(i == 'delrepeat') continue;
if(_arr.length == 0) _arr.push(arr[i]);
for(var j = 0;j _arr.length - 2) _arr.push(arr[i]);
}
return _arr;
}
11.用js实现随机选取10~100之间的10个数字，存入一个数组，并排序。
function getRandom(istart,iend){//列出需要被选中的数据
var a1 = [];
for(var i = 0;i < 91;i ++){
a1[i] = i + 10; }
//挑选出随机数据
var a2 = [];
for(var j = 0;j < 10;j ++){
a2.push(a1.splice(Math.floor(Math.random()*a1.length),1));
a2.sort();
alert(a2);}
getRandom(10,100);
12.把两个数组合并，并删除第二个元素。
var array1 = ['a','b','c'];
var array2 = ['d','e','f'];
var array3 = array1.concat(array2);
array3.splice(1,1);
13.根据每个元素的i属性，由小到大排序如下数组。
var arr=[{i:5,v:1},{i:2,v:4},{i:3,v:2},{i:1,v:5},{i:4,v:3}];
解析：
arr.sort(function(a,b){ return a.i-b.i; })
对于一个数组，sort()默认按字符编码排序：
var testArray=[3,324,5345,6546,134,5654,665];testArray.sort();alert(testArray);
输出结果是：134 3 324 5345 5654 6546 665
现在要让它按照数值大小排序：
var testArray=[3,324,5345,6546,134,5654,665];testArray.sort(function(a,b){return a-b;});alert(testArray);
这里传递一个比较函数给sort,比较函数的逻辑是：如果两参数的差值小于0，则表示a必须出现在b前面，否则在b后面。
输出结果是：3 134 324 665 5345 5654 6546
1. 读取学生的10门课的成绩, 然后输出10门课成绩的最高分, 最低分, 总分, 平均分.
提示:把10门课的成绩保存如一个数组中.
<!DOCTYPE html>
<!--题目：读取学生的10门课的成绩, 然后输出10门课成绩的最高分, 最低分, 总分, 平均分.
提示:把10门课的成绩保存如一个数组中.-->
varsum =0;
varave =0;
vararr = [90,100,10,20,30,40,50,60,70,80];
console.log(arr);
//排序
arr.sort(function(a, b){
returna - b;
});
//最高分
functionlarge(arr){
returnarr[arr.length -1];
};
//最低分
functionsmall(arr){
returnarr[0];
};
//总分
functiontotal(arr){
for(vareleofarr) {
sum += ele;
}
returnsum;
};
//平均分
functionave(arr){
returnsum / arr.length;
}
//输出
console.log("总分： "+ total(arr));
console.log("最高分： "+ large(arr));
console.log("最低分： "+ small(arr));
console.log("平均分： "+ ave(arr));
<!--记得再次用原型替换3进行调试-->
用函数封装起来：（更具面向对象的思想）
<!DOCTYPE html>
Title
functionStudent(){
this.scores = [];
this.init =function(){
for(vari =0; i <3; i++){
varscore = +prompt("请输入学生的成绩:");
this.scores.push(score);
}
};
this.max =function(){
varscores =this.scores;
varm = scores[0];// ["100", "200", "40"]
for(vari =1; i < scores.length; i++){
if(m < scores[i]){
m = scores[i];
}
}
returnm;
}
this.min =function(){
varscores =this.scores;
varm = scores[0];// ["100", "200", "40"]
for(vari =1; i < scores.length; i++){
if(m > scores[i]){
m = scores[i];
}
}
returnm;
}
this.sum =function(){
vars =0;
for(vareofthis.scores){
s += e;
}
returns;
}
this.avg =function(){
returnthis.sum() /this.scores.length;
}
}
vars1 =newStudent();
s1.init();//初始化学生的成绩
console.log(s1.max());
2. 创建100个随机的10到60的随机整数, 然后分别统计每个数字出现的次数
<!DOCTYPE html>
Title
<!--创建100个随机的10到60的随机整数, 然后分别统计每个数字出现的次数-->
//arr是放随机数产生的数字,newArr是放重复元素和重复个数的二维数组
vararr = [];
varnewArr = [];
//js的数组可以动态增加,使用数组字面量创建
for(vari =0; i <100; i++) {
//用random判断随机数其实不是perfect（正态分布)
arr[i] =parseInt(Math.random() *50+10);
}
console.log("随机数（正态分布）：\n"+ arr);
//对数组进行排序
arr.sort(function(a, b){
returna - b;//升序
});
console.log("随机升序排序：\n"+ arr);
//判断数组元素的重复个数，这样算法是相对而言比较高效的，省掉了低效的代码率
for(vari =0; i < arr.length;) {
varcount =0;
for(varj = i; j < arr.length; j++) {
if(arr[i] == arr[j]) {
count++;
}else{
break;
}
}
newArr.push([arr[i], count]);
i += count;
}
//输出二维数组
for(vari =0; i < newArr.length; i++) {
console.log(newArr[i][0] +"重复次数:"+ newArr[i][1]);
}
在这顺便讲解一下随机数生成的方法，以后只要涉及到随机数，就套路进去就行，就跟数学公式一样。（证明略）
如何使用js生成n到m间的随机数字，主要目的是为后期的js生成验证码做准备。
方法1：Math.random()函数返回0和1之间的伪随机数，可能为0，但总是小于1，[0,1)
生成n-m，包含n但不包含m的整数：
Step1：算出 m-n的值，假设等于w
Step2：Math.random()*w
Step3：Math.random()*w+n
Step4：parseInt(Math.random()*w+n, 10) 在这里10表示10进制，默认就是10进制。
方法2：生成n-m，不包含n但包含m的整数：
Step1：算出 m-n的值，假设等于w
Step2：Math.random()*w
Step3：Math.random()*w+n
Step4：Math.floor(Math.random()*w+n) + 1
注：Math.floor() 返回小于等于数字参数的最大整数，对数字进行下舍入
一般记住这两种方法就行了。
另解:(在那里要不要加1，看自己的情况，掌握怎么算的)：
<!DOCTYPE html>
Title
// [0, 1) [0, 51) [10, 61) [10, 60]
// m = 10 n= 60
functionrandomInt(m, n){//区间: [m, n]
returnparseInt(Math.random() * (n - m +1) + m);
}
/*创建一个长度是 count, 元素的值的范围 是 [m, n]的数组*/
functioncreateArray(count, m, n){
vararr = [];
for(vari =0; i < count; i++){
arr.push(randomInt(m, n));
}
returnarr;
}
functiontongji(){
varobj = {};
vararr = createArray(400,10,19);
for(varnum =10; num <=19; num++){
varc =0;
for(vareofarr){
if(e == num){
c++;
}
}
obj[num +""] = c;
}
returnobj;
}
varresult = tongji();
console.log(10+"的个数:"+ result["10"]);
console.log(result["11"]);
console.log(result);
3. 定义一个函数, 判断数组中是否所有的数字都大于0
提示: 传入一个数组, 返回布尔值
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<!--定义一个函数, 判断数组中是否所有的数字都大于0
提示: 传入一个数组, 返回布尔值
-->
<body>
<script>
var arr=[10,20,3,1,3.1,9,1,34,90,0,-100,100];
var flag=true;
for(var i=0;i<arr.length;i++){
if(arr[i]<0){
flag=false;
console.log("数组存在第一个非正值为："+arr[i]+" 其数组下标为 "+i);
break;
}
}
if(flag){
console.log("数组恒正~");
}else{
console.log("因此，数组不是恒正的~");
}
</script>
</body>
</html>
4. 封装函数: 把两个数组共同的元素放入一个新的数组, 并返回新的数组
提示: 传入两个数组, 返回值为新的数组
<!DOCTYPE html>
Title
<!--封装函数: 把两个数组共同的元素放入一个新的数组, 并返回新的数组
提示: 传入两个数组, 返回值为新的数组
-->
vararr1 = [1,2,3,"aaa","hello",999,-1];
vararr2 = [3,78,"aaa","bbb",99,1,-1,"hello"];
varnewArr = [];
//两层嵌套，效率很低。
functioncommon(arr1, arr2){
for(vari =0; i < arr1.length; i++) {
for(varj =0; j < arr2.length; j++) {
if(arr1[i] === arr2[j]) {
newArr.push(arr1[i]);
}
}
}
}
common(arr1, arr2);
console.log(newArr);
5. 定义一个函数: 可以把数组中的下标为 3 的元素移到数组的开头.
提示: 传入一个数组
<!DOCTYPE html>
Title
<!--定义一个函数: 可以把数组中的下标为 3 的元素移到数组的开头.
提示: 传入一个数组
-->
vararr = [1,2,3,4,5,6,7,8,9,111];
console.log("原数组： "+ arr);
//函数alter将下标为3的移动到开头
functionalter(arr){
vartemp = arr[3];
arr.splice(3,1);
arr.splice(0,0, temp);
}
alter(arr);
console.log("移动后数组： "+ arr);
6. 有一个从大到小排好序的数组{99，85，82，63，60}。
现从页面输入一个数，要求按原来的规律将它插入数组中。
假设你输入的80，则应该插入到82和63之间。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<!--题目：有一个从大到小排好序的数组{99，85，82，63，60}。
现从页面输入一个数，要求按原来的规律将它插入数组中。
假设你输入的80，则应该插入到82和63之间。
-->
<!--
此题方法集锦：
法1：投机取巧 直接先把数字插入到数组头部或者尾部，然后一块排序，很ok吧。
法2：用折半查找二分法，在大样本数据下比较高效，本题解法实则时间复杂度达到O（n）,而折半O（log2n）
-->
<body>
<script>
//需插入的数字
var insertNum=16;
//假设未排序，自己先排序一下
var arr=[88,98,2,5,8,10,25,36];
arr.sort(function (a,b) {
return b-a; //降序排列
});
console.log("降序排列的数组为："+arr);
// 此循环得到的i值就是排序好的数组最接近insertNum值得那个最大下标，虽然效率很差。
for(var i=0;i<arr.length;i++){
if(arr[i]>=insertNum){
var temp=i;
}
}
//插入到下标为temp+1的位置
arr.splice(temp+1,0,insertNum);
//输出info
console.log("插入数字"+insertNum+"后的新数组为： "+arr);
</script>
</body>
</html>
另解：
<script>
/*7. 有一个从大到小排好序的数组{99，85，82，63，60}。
现从页面输入一个数，要求按原来的规律将它插入数组中。
假设你输入的80，则应该插入到82和63之间。*/
functioninsert(arr, num){
for(vari =0; i < arr.length; i++){
if(arr[i] < num){
arr.splice(i,0, num);
return;// 直接结束函数
}
}
arr.push(num);
}
vararr = [99,85,82,63,60];
insert(arr,610);
console.log(arr);
7. 一个数字中有20个元素，对前10个元素使用升序，后10个元素使用降序。
元素都是整数。
<!DOCTYPE html>
Title
//数组元素20个
vararr = [100,12,34,67,23,16,6,9,24,79,2,90,33,69,1,34,-2,0,666,1000];
//切片
vararr1=arr.slice(0,10);
vararr2=arr.slice(10);
//前升序
arr1.sort(function(a,b){
returna-b;
});
//后降序
arr2.sort(function(a,b){
returnb-a;
});
//组合新数组(cs6)并输出
varnewArr = [...arr1,...arr2];
console.log("前升序后降序的数组为： "+ newArr);
