我的算法练习

绪论:算法在计算机中基本上是通用的,只不过不同的语言表现的方式有差别.

            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;
            }
时间: 2024-10-12 13:16:49

我的算法练习的相关文章

经典排序算法 - 冒泡排序Bubble sort

 原文出自于 http://www.cnblogs.com/kkun/archive/2011/11/23/bubble_sort.html 经典排序算法 - 冒泡排序Bubble sort 原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换, 这样一趟过去后,最大或最小的数字被交换到了最后一位, 然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子 例子为从小到大排序, 原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 | 第一趟排序(外循环) 第

转载:DenseNet算法详解

原文连接:http://blog.csdn.net/u014380165/article/details/75142664 参考连接:http://blog.csdn.net/u012938704/article/details/53468483 本文这里仅当学习笔记使用,具体细节建议前往原文细度. 论文:Densely Connected Convolutional Networks 论文链接:https://arxiv.org/pdf/1608.06993.pdf 代码的github链接:h

基于位置信息的聚类算法介绍及模型选择

百度百科 聚类:将物理或抽象对象的集合分成由类似的对象组成的多个类的过程被称为聚类.由聚类所生成的簇是一组数据对象的集合,这些对象与同一个簇中的对象彼此相似,与其他簇中的对象相异."物以类聚,人以群分",在自然科学和社会科学中,存在着大量的分类问题.聚类分析又称群分析,它是研究(样品或指标)分类问题的一种统计分析方法.聚类分析起源于分类学,但是聚类不等于分类.聚类与分类的不同在于,聚类所要求划分的类是未知的. 分类和聚类算法一直以来都是数据挖掘,机器学习领域的热门课题,因此产生了众多的

密码算法详解——AES

0 AES简介 美国国家标准技术研究所在2001年发布了高级加密标准(AES).AES是一个对称分组密码算法,旨在取代DES成为广泛使用的标准. 根据使用的密码长度,AES最常见的有3种方案,用以适应不同的场景要求,分别是AES-128.AES-192和AES-256.本文主要对AES-128进行介绍,另外两种的思路基本一样,只是轮数会适当增加. 1 算法流程 AES加解密的流程图如下: AES加密过程涉及到4种操作:字节替代(SubBytes).行移位(ShiftRows).列混淆(MixCo

矩阵乘法的Strassen算法详解

题目描述 请编程实现矩阵乘法,并考虑当矩阵规模较大时的优化方法. 思路分析 根据wikipedia上的介绍:两个矩阵的乘法仅当第一个矩阵B的列数和另一个矩阵A的行数相等时才能定义.如A是m×n矩阵和B是n×p矩阵,它们的乘积AB是一个m×p矩阵,它的一个元素其中 1 ≤ i ≤ m, 1 ≤ j ≤ p. 值得一提的是,矩阵乘法满足结合律和分配率,但并不满足交换律,如下图所示的这个例子,两个矩阵交换相乘后,结果变了: 下面咱们来具体解决这个矩阵相乘的问题. 解法一.暴力解法 其实,通过前面的分析

关于SVM数学细节逻辑的个人理解(三) :SMO算法理解

第三部分:SMO算法的个人理解 接下来的这部分我觉得是最难理解的?而且计算也是最难得,就是SMO算法. SMO算法就是帮助我们求解: s.t.   这个优化问题的. 虽然这个优化问题只剩下了α这一个变量,但是别忘了α是一个向量,有m个αi等着我们去优化,所以还是很麻烦,所以大神提出了SMO算法来解决这个优化问题. 关于SMO最好的资料还是论文<Sequential Minimal Optimization A Fast Algorithm for Training Support Vector

基于Spark MLlib平台的协同过滤算法---电影推荐系统

基于Spark MLlib平台的协同过滤算法---电影推荐系统 又好一阵子没有写文章了,阿弥陀佛...最近项目中要做理财推荐,所以,回过头来回顾一下协同过滤算法在推荐系统中的应用. 说到推荐系统,大家可能立马会想到协同过滤算法.本文基于Spark MLlib平台实现一个向用户推荐电影的简单应用.其中,主要包括三部分内容: 协同过滤算法概述 基于模型的协同过滤应用---电影推荐 实时推荐架构分析     一.协同过滤算法概述 本人对算法的研究,目前还不是很深入,这里简单的介绍下其工作原理. 通常,

算法 希尔排序

希尔排序 Shell Sort 介绍: 希尔排序(Shell Sort)也称缩小增量排序,是直接插入排序算法的一种更高效的改进版本. 该方法的基本思想是:先将整个待排元素序列分割成若干个子序列(由相隔某个"增量"的元素组成的)分别进行直接插入排序,然后依次缩减增量再进行排序,待整个序列中的元素基本有序(增量足够小)时,再对全体元素进行一次直接插入排序.因为直接插入排序在元素基本有序的情况下(接近最好情况),效率是很高的,因此希尔排序在时间效率比直接插入排序有较大提高. 执行流程: 首先

算法 排序NB二人组 堆排序 归并排序

参考博客:基于python的七种经典排序算法     常用排序算法总结(一) 序前传 - 树与二叉树 树是一种很常见的非线性的数据结构,称为树形结构,简称树.所谓数据结构就是一组数据的集合连同它们的储存关系和对它们的操作方法.树形结构就像自然界的一颗树的构造一样,有一个根和若干个树枝和树叶.根或主干是第一层的,从主干长出的分枝是第二层的,一层一层直到最后,末端的没有分支的结点叫做叶子,所以树形结构是一个层次结构.在<数据结构>中,则用人类的血统关系来命名,一个结点的分枝叫做该结点的"

【机器学习实战】第2章 K-近邻算法(k-NearestNeighbor,KNN)

第2章 k-近邻算法 <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script> KNN 概述 k-近邻(kNN, k-NearestNeighbor)算法主要是用来进行分类的. KNN 场景 电影可以按照题材分类,那么如何区分 动作片 和 爱情片 呢? 动作片:打斗次数更多 爱情片