我的算法练习记录

<pre name="code" class="plain">绪论:算法在计算机中基本上是通用的,仅仅只是不同的语言表现的方式有区别.
			
			1.集合类型数据用特定字符拼接为一个字符串
			var str:String = "";
			var arr:Array = [1,2,3,5,3,2];
			var sep:String = ";";
			for(var i:int = 0;i < arr.length; i++)
			{
				var n:int = arr[i];
				if(i < arr.length - 1)//前arr.length - 1个元素追加分隔符
					str += n + sep;
				else//最后一个直接加上
					str += n;
			}
			trace(str);
			上述算法相当于数组的join()方法.API方法有时候会有一定局限.
			
			2.提取某元素所在组数据
			如果有一个数据集合{n1,n2,n3,n4,n5......},里面的数据每N个为一个Group.
				已知集合对象和当中某个元素的索引i.要求把元素i所在Group的全部元素
			放在一个集合中.
			集合索引一般从0開始.
			var g:int = int(Math.ceil(i/N)) 对元素i与N相除,并对结果向上取整可得i是第几组数据
			第1组 0 到 N-1
			第2组 N 到 N+N - 1
			......
				第g组 (g-1)*N 到 g*N -1
			
			至此能够得到元素i所在组的起始索引
			var startIndex:int = (g-1)*N;
			var endIndex:int = g*N - 1;
			接下来仅仅须要对集合对象依照上述索引遍历就可以
			for(var index:int = start;index <= end;index++)//索引的Range是全闭区间
			{
				.......................
			}
			
			3.冒泡排序的奥妙
			理解以下的代码要一句句的连贯起来,依照计算机执行规律去理解,不能想当然.
			var arr:Array = [1,3,0,2,4,2];//length = 6
			写法一:
			for(var i:int = 0;i < arr.length;i++)
			{
				for(var j:int = 0;j < arr.length;j++)
				{
					var t:int = arr[i];
					if(arr[i] < arr[j])//  > 倒序   ;  < 正序
					{
						arr[i] = arr[j];
						arr[j] = t;
					} 
				}
			} 
			写法二:
			for(var i:int = 0;i < arr.length;i++)
			{
				for(var j:int = 0;j < arr.length - 1;j++)
				{
					var t:int = arr[i];
					if(arr[i] < arr[j])//  > 倒序   ;  < 正序
					{
						arr[i] = arr[j];
						arr[j] = t;
					} 
				}
			}
			
			写法三:
			for(var i:int = 0;i < arr.length - 1;i++)
			{
				for(var j:int = 0;j < arr.length - 1 - i;j++)
				{
					var t:int = arr[j + 1];
					if(arr[j + 1] < arr[j])//  > 倒序   ;  < 正序
					{
						arr[j + 1] = arr[j];
						arr[j] = t;
					} 
				}
			} 
			结果都是arr = [0,1,2,2,3,4]
			
			
			3.阶乘
			private function factorial(n:int):int
			{
				var s:int = 1;
				while(n > 1)//这里之前写为>0,想想还是不够好,由于0和1的阶乘都是1,不是必需进循环
				{
					s *= n;
					n --;
				}
				return s;
			}
			
			
			4.斐波那契数列--递归
			private function fibonacci(n:int):int
			{
				if(n <= 1)
					return n;
				else
					return fibonacci(n-2) + fibonacci(n-1);
			}
			//開始我 n <= 1 return 1;这样一来 fab(2) = 2,下标从0開始才对.
			//这个数列仅仅能是自然数.fab(0) = 0,fab(1) = 1是初始的两个数,以后的
			//数字才符合后面的数字是前面两个数字的和,至少有两个初始数字.
			
			5.寻找质数
			写法一:
			private function isPrime(n:int):Boolean
			{
				var sum:int = 0;
				for(var i:int = 2;i <= n-1;i++)
				{
					if(n % i != 0)
						sum ++;
				} 
				//2開始直到比它小1的数都不能和其整除
				if(sum == n-2)
					return true;
				else
					return false;
			}
			
			写法二:
			private function isPrime(n:int):Boolean
			{
				for(var i:int = 2;i <= n-1;i++)
					if(n % i == 0)
						return false;
				return true;
			}
			
			红色部分还能够写为:
			1.for(var i:int = 2;i < n;i++)
			2.for(var i:int = n - 1;i > 1;i--)
			
			写法三:
			private function isPrime(n:int):Boolean
			{
				var s:int = int(Math.sqrt(n));
				for(var i:int = s;i > 1;i--)
					if(n % i == 0)
						return false;
				return true;
			}
			上面採用了一个素数定理,详细证明不知,只是能够提高算法效率
			另一种筛法找质数,效率高,但消耗内存,也比較复杂,无论了.
			
			以下是找质数:
			private function primes(n:int):Array
			{
				var arr:Array = [];
				for(var i:int = 2;i <= n;i++)
				{
					if(isPrime(i))
						arr.push(i);
				}
				return arr;
			}
			
			6.一个循环打印一个国际象棋棋盘布局(纯粹练习算法玩的)
			方式一:
			int head = 0;
			for(int i = 1;i <= 64;i++)
			{
				if(head == 0)
				{
					if(i % 2 == 0)
						System.out.print("0");
					else
						System.out.print("1");
				}
				else
				{
					if(i % 2 != 0)
						System.out.print("0");
					else
						System.out.print("1");
				}
				
				
				if(i % 8 == 0)
				{
					if(head == 0)
						head = 1;
					else
						head = 0;
					System.out.println();
				}
				
			}
			
			方式二:
			int head = 0;
			for(int i = 1;i <= 64;i++)
			{
				if(head == 0)
				{
					System.out.print("0");
					if(i % 8 == 0)
					{
						head = 0;
						System.out.println();
					}
					else 
						head = 1;
				}
				else
				{
					System.out.print("1");
					if(i % 8 == 0)
					{
						head = 1;
						System.out.println();
					}
					else 
						head = 0;
				}
			}
			
			写法三:
			int head = 1;
			for (int i = 1; i <= 64; i++) {
				if (head == 0) {
					System.out.print("0");
					if (i % 8 == 0)
						head = 0;
					else
						head = 1;
				} else {
					System.out.print("1");
					if (i % 8 == 0)
						head = 1;
					else
						head = 0;
				}
				if (i % 8 == 0)
					System.out.println();
			}
			
			写法四:(我认为这个算法已经最精简了,如果你有更精简的请回复赐教):
			int head = 1;
			for (int i = 1; i <= 64; i++) {
				if (head == 0) 
				{
					System.out.print("0");
					head = (i % 8 == 0 ? 0 : 1);
				} 
				else
				{
					System.out.print("1");
					head = (i % 8 == 0 ? 1 : 0);
				}
				if (i % 8 == 0)
					System.out.println();
			}
			改动for循环的长度,我还能够画出很多其它格子的类国际象棋棋盘布局
			
			写法五:
			int head = 1;
			for (int i = 1; i <= 64; i++) {
				if(head == 0)
					System.out.print("0");
				else
					System.out.print("1"); 
				
				if (head == 0) 
					head = (i % 8 == 0 ?
 0 : 1);
				else
					head = (i % 8 == 0 ? 1 : 0);
				
				if (i % 8 == 0)
					System.out.println();
			}
			上面的代码尽管行数可能比四多点,可是,层次更清晰,分工明白,更好维护
			
			7.随机生成1-9位,各位不等的数字字符串
			private  function randDiffNO(bits:int = 1):String
			{
				var str:String = "";
				var arr:Array = [0,1,2,3,4,5,6,7,8,9];
				for(var i:int = 0;i < bits;i++)
				{
					//从数组中随机一个索引
					var index:int =  Math.random()*arr.length;
					//将这个索引相应的数字增加到字符串
					str += arr[index];
					//删除相应索引的数字
					arr.splice(index,1);
				} 
				return str;
			}