数组函数冒泡排序

最新推荐文章于 2021-05-19 18:26:07 发布

敲代码的皮皮

最新推荐文章于 2021-05-19 18:26:07 发布

阅读量430

点赞数 1

文章标签： javascript

本文链接：https://blog.csdn.net/cc12345_10/article/details/116241386

版权

1.数组函数

/*
	pop() 
	从数组的尾部删除一个元素，每一次删除一个元素
	没有参数，返回值是删除的那个元素
	
	shift()
	从数组的头部删除一个元素，每一次删除一个元素
	没有参数，返回值是删除的那个元素
	
	splice()
	从数组的任何一个位置开始，进行删除，替换，添加任意元素
	参数：(以下序号代表参数的次序)
	1.指定开始操作的位置
	2.指定删除元素的长度，包括开始的位置
	3.从开始的位置，添加的新元素
	返回值
		当删除了元素的时候，返回的删除的元素组成的数组，如果没有删除，则返回空数组
	*/ 
   var arr1 = new Array('张居正','严嵩','严世潘','徐阶');
   var str = arr1.pop();
   console.log(str, arr1);
   
   arr1.shift();
   console.log(arr1);
   
   var arr2 = new Array('戚继光','李成梁','李如松','海瑞');
   var arr3 = arr2.splice(2,1,'努尔哈赤','冯保');
   console.log(arr3,arr2);
   /*
   当只有一个参数的时候，从该参数指定的位置，包含该参数位置上的元素，一直到最后，全部删除
   当有两个参数的时候，表示，从第一个参数的位置开始删除，删除长度为第二个参数值的所有内容
   
   */ 
   var arr4 = ['李舜臣','李如松','裕仁天皇'];
   arr4.splice(1);
   console.log(arr4);
   
   /*
   总结 push() unshift() pop() shift() splice() 这5个方法都改变原数组
   */
  /*
  2.数组提取
   indexOf()获取指定元素的下标
   参数有两个
   1.指定查找的元素
   2.指定开始查找的位置
   
   特点
	1.从指定开始查找，如果不写第二个参数，默认从0开始查找
	2.返回元素所在的下标位置
	3.如果找不到，则返回 -1，表示数组中没有要查找的元素
	4.第二个参数不能为负数
	5.低版本IE(6/7/8)不支持
  */ 
	
  var arr5 = ['李成梁','李成梁','戚继光','李如松','戚继光','海瑞'];
	
  console.log(arr5.indexOf('海贼王'));
   console.log(arr5.indexOf('李成梁',2));
   // 找到所有'戚继光'所在的下标，放入到新的数组中
   var arr6 = [];
   /*for(var i=0;i<arr5.length;i++){
	   if(arr5[i]=='戚继光'){
		   arr6.push(i);
	   }
   }
   console(arr6);*/
   
   console.log('戚继光', arr5.indexOf('戚继光'));
   
   for(var i=0;arr5.indexOf('戚继光',i)!=-1;){
   	   var temp = arr5.indexOf('戚继光',i);
	   arr6.push(temp);
	   i = temp+1;
   }
   console.log(arr6);
   /*
   lastIndexOf() 它和indexOf唯一的区别就是从指定的位置往前查找，其他都一样
   
   slice()截取子数组
   参数
   1.开始位置
   2.结束位置
   
   特点：
   1.包含开始位置，不包含结束位置
   2.参数为负数的时候，倒数第几位，从1开始计算
   3.参数只为能为整数，所有的非法字符都会被解析为0
   4.如果参数为1个，则截取到的子数组就是从该参数开始，一直到最后，也就是结束位置默认到最后
   5.如果没有参数，则是整个数组的复制操作
   6.开始位置必须在结束位置之前，否则截取不到任何数组
   
   注意：原数组不变
   */
  var arr7 = ['灵明石猴','赤尻马猴','通臂猿猴','六耳猕猴'];
  var arr8 = arr7.slice(1,2);
  console.log(arr7,arr8);
  
  var arr9 = arr7.slice(-4,-1);
  console.log(arr7,arr9);
  
  var arr10 = arr7.slice('a',-2);
  console.log(arr7,arr10);
  
  console.log('**********');
  var arr11 = arr7.slice();
  console.log(arr7,arr11);

2.数组函数

/*
	数组的监测，新增方法，IE低版(6/7/8)本不支持
	1.every() 监测数组中的元素是否都满足设置的条件，如果满足则返回true，否则返回false
	2.some() 监测数组中的元素是否有满足设置的条件，如果满足则返回true，否则返回false
	 参数 两个
	 1.条件函数
		条件函数的参数有3个
		1.数组中的元素
		2.数组中该元素对应的下标
		3.当前操作的数组
	 2.指定函数中的this指向
	*/ 
   var arr1 = [5,6,7,8,9,10];
   var bol1 = arr1.every(function(item){
	   // 在函数中，添加设置的条件，item指的是数组中的每一个元素
	   return item>4;
   });
   console.log(bol1);
   
   var bol2 = arr1.some(function(aa,index){
	   console.log(index);
	   return aa==10;
   });
   console.log(bol2);
   
   /*
   filter()
   数组元素过滤
   map()
   数组的映射，工作中常用于循环
   */
   var arr2 = [1,2,3,4,5,6,7,8,9,10];
   var arr3 = arr2.filter(function(ele){
	   return ele%2==0;
   });
   console.log(arr2,arr3);
   
   var arr4 = arr2.map(function(ele){
	   return ele+'px';
   });
   console.log(arr2,arr4);
   
   /*
   数组合并
   1.把多个数组合并成一个数组
   concat()
   参数可以是很多个，参数都是数组
   返回值是一个数组
   
   2.把数组中的元素合并成一个字符串
   join()
   参数只有一个，表示连接符，如果不设置，连接符默认是逗号
   返回值是一个字符串
   
   3.把字符串切割成一个数组
   split() 
   调用对象是一个字符串，返回值是数组
   参数是一个切割符，切割符必须是字符串当中存在的字符，或者是''
   
   */ 
  var arr5 = ['珍珍','爱爱','怜怜'];
  var arr6 = ['骊山老母','观音菩萨','零基普斯'];
  var arr7 = ['高翠兰'];
  var arr8 = arr5.concat(arr6,arr7);
  console.log(arr8);
  
  var str1 = arr5.join('==');
  document.write(str1);
  
  var str2 = '万里%长城%万里%梦';
  var arr9 = str2.split('%');
  console.log(arr9);
  
  /*
  数组倒序
  reverse()
  该方法没有返回值，改变数组本身
  */
  arr5.reverse();
  console.log(arr5);
  // 练习，把str3倒叙输出
  var str3 = '百世英雄百世空';
  var arr = str3.split('');
  arr.reverse();
  var str4 = arr.join('');
  document.write('<hr/>'+str4);
  
  /*
  数组排序
  sort() 
  该函数修改是原数组
  sort() 默认排序是，先把number转化为字符串类型，然后依次比较每一个字符胡串的大小
  字符串比较大小的原则:
  几个字符串比较大小，会依次比较每一个字符串中，对应位置的字符的字符编码的大小，直到比出大小之后，后面的就不再比较了
  
  字符编码
  数字还是0-9依次变大
  A-Z,a-z依次变大
  Z<a
  
  进行排序的时候，还可以给sort()传入一个自定义的函数，自行设置排序原则，该函数必须有返回值
  
  参数1：num1，参数2：num2
  
  return num1-num2：从小到大排序
  return num2-num1：从大到小排序
  return 0或者正数：原排序不变
  return 负数：原排序倒序
  */ 
 var arr11 = [1,0,3,13,2,24,33,14,15];
 // arr11.sort();
 // console.log(arr11);
 
 arr11.sort(function(num1,num2){
	 return num2-num1;
 });
 console.log(arr11);
 
 var arr12 = [1,0,3,13,2,24,33,14,15];
 arr12.sort(function(){
	 return 0;
 });
 console.log(arr12);
 
 var arr12 = [1,2,3,4,5,6,7,8,9];
 
 //数组打乱，sort() 函数中如果返回值<0,则交换两个元素的位置，如果返回值>=0,不交换位置
 arr12.sort(function(){
	 return Math.random()-0.5;
 });
 console.log(arr12);

3.冒泡排序

var arr = [1,2,3,4,5];
	//执行第一趟比较，比较4次, 把5放在了最后面
	for(var i=0;i<4;i++){
		if(arr[i]>arr[i+1]){
			var temp = arr[i];
			arr[i] = arr[i+1];
			arr[i+1] = temp;
		}
	}
	console.log(arr); // 3 4 1 2 5
	
	//执行第二趟比较，比较3次, 把4 5放在了最后面
	for(var i=0;i<3;i++){
		if(arr[i]>arr[i+1]){
			var temp = arr[i];
			arr[i] = arr[i+1];
			arr[i+1] = temp;
		}
	}
	console.log(arr); // 3  1 2 4 5
	
	//执行第三趟比较，比较2次, 把3 4 5放在了最后面
	for(var i=0;i<2;i++){
		if(arr[i]>arr[i+1]){
			var temp = arr[i];
			arr[i] = arr[i+1];
			arr[i+1] = temp;
		}
	}
	console.log(arr); // 1 2 3 4 5
	
	//执行第四趟比较，比较1次, 把2 3 4 5放在了最后面
	for(var i=0;i<1;i++){
		if(arr[i]>arr[i+1]){
			var temp = arr[i];
			arr[i] = arr[i+1];
			arr[i+1] = temp;
		}
	}
	console.log(arr); // 1 2 3 4 5
	
	/*
	经过如上总结：冒泡排序比较的次数 = 数组长度 - 趟数
	
	*/ 
   var arr1 = [23,45,1,23,45,56,7,6,8,0,34,65];
   //冒泡排序的写法
   for(var i=1;i<arr1.length;i++){ // 外层控制趟数
	   for(var j=0;j<arr1.length-i;j++){
	   	if(arr1[j]>arr1[j+1]){
	   		var temp = arr1[j];
	   		arr1[j] = arr1[j+1];
	   		arr1[j+1] = temp;
	   	}
	   }
   }
   
   console.log(arr1);

4.十五二十小游戏


<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>十五二十</title>
	</head>
	<body>
		<div class="girl">
			美女：
			<input type="text" id="chu" value="" placeholder="出的数" readonly="readonly" />
			&nbsp;&nbsp;
			<input readonly="readonly" type="text" id="han" value="" placeholder="喊的数" />
			
		</div>
		<div class="boy">
			帅哥出:
			<select id="boyChu">
				<option value="0">0</option>
				<option value="5">5</option>
				<option value="10">10</option>
			</select>
			帅哥喊: 
			<select id="boyHan">
				<option value="0">0</option>
				<option value="5">5</option>
				<option value="10">10</option>
				<option value="15">15</option>
				<option value="20">20</option>
			</select>
			
		</div>
		<button type="button" id="btn">开始</button>
	</body>
</html>
<script type="text/javascript">
	var chu = document.getElementById("chu"); //美女出
	var han = document.getElementById("han"); //美女喊
	var boyChu = document.getElementById("boyChu"); //帅哥出
	var boyHan = document.getElementById("boyHan"); //帅哥喊
	var btn = document.getElementById("btn");
	var arr1 = [0,5,10]; //出的数组
	var arr2 = [0,5,10,15,20]; //喊的数组
	
	btn.onclick = function(){
		// 随机美女出的数下标
		var index1 = Math.floor(Math.random()*3);
		// 随机美女喊的数下标
		var index2 = Math.floor(Math.random()*5); //3
		
		// 设置喊的数不小于出的数
		while(arr2[index2]<arr1[index1]){
			var index1 = Math.floor(Math.random()*3);
			var index2 = Math.floor(Math.random()*5);
		}
		
		//美女出的数
		var num1 = arr1[index1];
		//美女喊的数
		var num2 = arr2[index2]; //15
		
		//给元素赋值
		chu.value = num1;
		han.value = num2;
		
		//帅哥出的数
		var num3 = boyChu.value-0; //转化为数字
		//帅哥喊的数
		var num4 = boyHan.value-0; //转化为数字
		
		// 两人出的数综合
		var sum = num1+num3;
		
		//判断
		if(num2==sum && num4==sum){
			alert('平局');
		}else if(num2==sum){
			alert('美女赢');
		}else if(num4==sum){
			alert('帅哥赢');
		}else{
			alert('再来一局');
		}
		
		//code
	};
</script>