精华内容
下载资源
问答
  • 这是一套算法课程,从初级算法讲起,包含了算法的练习和课程上的实例资料,希望对想学习算法的朋友有帮助!谢谢!
  • elementaryAlgorithm 初级算法/基本算法 练习集
  • ACE初级算法设计

    2011-11-11 16:12:50
    ACE初级算法设计
  • 初级算法探索目录 LeetCode 探索初级算法-数组:01 删除排序数组中的重复项-20200314 LeetCode 探索初级算法-数组:02 买股票的最佳时机 II-20200315 LeetCode 探索初级算法-数组:03 旋转数组-20200316 ...

    初级算法探索目录


    Python 知识点复习

    LeetCode 探索初级算法-数组:01 删除排序数组中的重复项-20200314

    LeetCode 探索初级算法-数组:02 买股票的最佳时机 II-20200315

    LeetCode 探索初级算法-数组:03 旋转数组-20200316

    LeetCode 探索初级算法-数组:04 存在重复-20200317

    LeetCode 探索初级算法-数组:05 只出现一次的数字-20200317

    LeetCode 探索初级算法-数组:06 两个数组的交集 II-20200318

    LeetCode 探索初级算法-数组:07 加一-20200319

    LeetCode 探索初级算法-数组:08 移动零-20200320

    LeetCode 探索初级算法-数组:09 两数之和-20200321

    LeetCode 探索初级算法-数组:10 有效的数独-20200321

    LeetCode 探索初级算法-数组:11 旋转图像-20200322


    LeetCode 探索初级算法-字符串:12 反转字符串-20200323

    LeetCode 探索初级算法-字符串:13 整数反转-20200323

    LeetCode 探索初级算法-字符串:14 字符串中的第一个唯一字符-20200324

    LeetCode 探索初级算法-字符串:15 有效的字母易位词-20200327

    LeetCode 探索初级算法-字符串:16 验证回文字符串-20200327

    LeetCode 探索初级算法-字符串:17 字符串转换整数(aoti)-20200328

    LeetCode 探索初级算法-字符串:18 实现 strStr()-2020329

    LeetCode 探索初级算法-字符串:19 外观数组-20200330

    LeetCode 探索初级算法-字符串:20 最长公共前缀-20200331


    LeetCode 探索初级算法-链表:21 删除链表中的节点-20200404

    LeetCode 探索初级算法-链表:22 删除链表的倒数第N个节点-20200405

    展开全文
  • 初级算法学习步骤

    千次阅读 多人点赞 2018-07-29 18:51:51
    这是一篇初级算法学习的步骤总结,或许可以帮助你怎么去接触算法 阅读本文需要一定java语法基础和api文档查看基础,但算法其实看重的是思想而不是语言,所以都可以借鉴。 本人大二,参加过蓝桥杯。一直没时间吧...

    前言

    零散整理一个多月终于整理完了。。。。

    这是一篇初级算法学习的步骤总结,或许可以帮助你怎么去接触算法

    阅读本文需要一定java语法基础和api文档查看基础,但算法其实看重的是思想而不是语言,所以都可以借鉴。

    本人大二,参加蓝桥杯。一直没时间吧之前的总结整理出来,现在准备整理一下用java做算法的一些东西……学习了两个月左右算法,从啥都不会到小白再到算是初级……做一个总结,请高手多多指点,也给之后想参加学校初级算法赛的同学或者是想入门一下算法的同学一点点借鉴。感谢大家评论指点。里面部分我举例的题目可以跳转到我之前写的博客里,这个陆续在做。

    目录

    前言

    学习顺序

    详细内容

    一、数组

    二、字符串

    三、数据结构:

    1、基础数组、线性表:

    2、链表:

    3、集合(java):

    4、向量:(可增长数组)

    5、栈:

    6、队列、双端队列、优先队列:

    7、哈希表(映射表):

    8、树:

    9、图:

    四、排序

    五、查找

    六、4个基本算法思想

    七、数学问题,数论问题,数据结构问题,几何问题,字符串问题,大数运算问题:

    1、数学问题:

    2、数据结构问题:

    3、数论问题:

    4、几何问题:

    5、大数运算问题:

    6、字符串问题:

    八、五大常用算法

    一、分治法

    二、动态规划法

    三、贪心算法

    四、回溯算法

    五、分支界定

    九、看书刷题


    学习顺序

    算法可以说是解决问题的步骤

    按常理来说学习算法要先掌握一定的数据结构。但因为数组也是一大数据结构,而且也是非常常用的东西,所以在最初,做一些用数组解决的问题(其实java里的数据结构也都是基于数组和类来实现各种数据结构)。

    比如一维数组里:计算两个数组的交集,用数组实现约瑟夫环等等;二维数组里(平面坐标初级):扫雷,边缘检测问题,生命游戏等等。之后进行对数据结构的掌握,会了常用数据结构之后,就可以进行深入的算法研究了。

    所以这里的建议的顺序是:

    1. 熟习数组相关操作
    2. 熟习字符串相关操作
    3. 认识基础数据结构:线性表、顺序表、链表、栈、队列、树、哈希表、图等。并且自己实现以上数据结构
    4. 掌握使用提供的数据结构API。
    5. 排序算法、查找算法。
    6. 四个基本算法思想:穷举,递推,递归,概率。
    7. 数学问题,数论问题,数据结构问题,几何问题,字符串问题,大数运算问题。
    8. 五大常用算法:分治、动态规划(DP),贪心,回溯,分支界定。
    9. 多看算法题和算法书。

     

    详细内容

    注:这里都是用java语言作为例子解答代码进行讲解,同时附带的也都是java的api使用说明,但其实算法对语言依赖性不大,重要的是思想。本文提供给大家一个学习方案作为参考。

    一、数组

    内容:熟习数组的常用操作,可以做一些基础题,可以上leetcode或者别的算法题网站,刷掉初级算法题库里的数组10几个题目,这样对一维和二维数组的掌握灵活度就比较高了。

    一个比较典型的二维数组逻辑题目:

    旋转二维数组给定一个n×n的二维矩阵表示一个图像,输出将图像旋转90度的样子。(不要用另一个矩阵来旋转)

    题目具体内容点击标题可以进去查看。

    其他数组例题:

    两个数组的交集,数组实现约瑟夫环,简易扫雷,生命游戏等等。

    其他数组的操作大家可以自行去看看别的题,锻炼一下数组的运用思想。

     

    二、字符串

    内容:字符串的操作,比如回文串判定、字符串翻转等等。同样建议上题库做一些相应练习。在java里对应的API:string,stringbuilder,stringbuffer。

     

    三、数据结构:

    此章内容具体参照:java数据结构和他的API

    内容:这一部分需要自己先去学习一遍数据结构,然后自己写出来。掌握之后,再去查看api文档,最后学会如何使用api里的数据结构写算法,下面介绍的主要是api的对应方式。

    1、基础数组、线性表:

    (1)数组:

    API:Arrays。

    (2)线性表:

    API:ArrayList。

    2、链表:

    链表是以节点类为基础的,每个节点类有一个成员变量是下一个节点。

    API:LinkedList。

    3、集合(java):

    API:Collections。

    这个接口提供了很多常用方法,具体如何使用可以参照帮助文档。

    4、向量:(可增长数组)

    API:Vector接口提供方法与数组类似,具体查看API帮助手册。

    5、栈:

    自己先基于数组去实现。

    API:Stack接口提供查看,移除,压入,查找,判空操作

    6、队列、双端队列、优先队列:

    (1)队列:

    API:Queue。

    (2)双端队列:

    API:Deque。

    (3)优先队列:

       API:PriorityQueue档。

    7、哈希表(映射表):

    API:

    (1)Hashmap提供了键—值对应的功能。

    (2)TreeMap提供了可排序的映射表。

    8、树:

    树没有api,可以用上面学过的东西去实现它。

    9、图:

    图也是没有api的,用之前学过的结构可以构造。

     

     

    四、排序

    内容:在排序里,需要了解这九大排序算法:

    1、冒泡排序:每两个交换,每轮吧最大的放后面;

    2、选择排序:每轮选出最大的放后面;

    3、插入排序:一个线性表,一开始只有一个元素,加一个排一个;

    4、希尔排序:

    5、快速排序:

    6、堆排序:

    7、合并排序:

    8、基数排序:

    9、计数排序:

     

    五、查找

    这个阶段要了解到查找算法在平时的应用,最基础的是直接查找和二分查找,但是有时候在不同场景会有一些优化。

    1、二分法:对排序好的数组用,Collections提供了此方法

    2、二分法的各种优化搜索:

    3、数据结构中的查找:

    (1)顺序表:同数组,序号或者关键字顺序、二分查找。

    (2)链表:关键字查找,只能一个个往后找,返回引用。

    (3)树:树或者二叉树遍历一个个找,二叉搜索树可以根据大小找,原理和二分法一样。平衡二叉树同而搜索树,红黑树效率高。

    (4)图:深度优先遍历查找。

     

    六、4个基本算法思想

    此章节具体参照:4个基本算法思想:穷举、递推、递归、概率

    内容:这4个基本算法思想是解决基础问题的很实用的方法。这里开始其实就已经是把所有需要的知识准备好了,之后就要开始解题了。

    1、穷举:暴力破解,n层for循环。枚举每一种可能。

    2、递推:简单的动态规划,根据递推公式,累加。

    3、普通递归:化解问题逐渐变小(从n到1)

    4、概率:使用random数量足够大的时候,得到近似结果。

     

    七、数学问题,数论问题,数据结构问题,几何问题,字符串问题,大数运算问题:

    内容:这一块需要了解的是零散问题的应用。每一块我举几个例子,推荐大家还是上刷题网站吧零散的题给刷掉,不推荐直接做各个算法难题,先做这些零散题会对之后系统做算法有一些帮助。

    以下我诺列一些题目,大家可以自己查查,刷题网站上也有。

    1、数学问题:

    1. 罗马数字转换
    2. Math函数的应用(自行查看api帮助文档)。
    3. 保留小数点的操作:例如String.format(“%.2f”,string)

    2、数据结构问题:

    约瑟夫环:具体点击这里

    括号匹配:具体点击这里

    链表排序、最短路径等等。

    3、数论问题:

    素数、完全数为代表的问题。

    4、几何问题:

    java里有API:抽象类shape——具体类line2d,Point2d提供了一些集合方法。

    5、大数运算问题:

    API:BigInteger,提供加减乘除模,大小比较,转化等运算。

    6、字符串问题:

    API:String大致包含这些方法:是否包含,比较(可不考虑大小写),第一次出现索引(前后),两个字符串的某个区域是否相等(regionmatches),replace替换,split([,])分割,substring删减,tochararray变成字符数组,tolow/toup,trim忽略前后空白,valueof把别的转换成字符串。

     

    八、五大常用算法

    五大算法:分治,回溯,贪心,DP(动态规划),分支界定

    内容在这一块是需要重点看看的,前4个是重点,也有非常多的经典例题。这一部分还是比较需要时间的,以下仅仅是介绍,点开链接具有详细的每个算法讲解。

     

    1、分治法

    首先看一下二分搜索:一串数,取中间的数并且平分两半,如果比中间数大,就去上半部分找,然后再两半……这样查找就是分治思想:把一个问题分解成若干个一样的小块。

    具体详情:分治算法——五大常用算法之一

    基本概念:

    把一个复杂的问题分成两个或更多的相同或相似的子问题,再把子问题分成更小的子问题。直到最后子问题可以简单的直接求解,原问题的解即子问题的解的合并。

     

    2、动态规划法

    具体详情:动态规划——五大常用算法之一

    基本概念:

    动态规划(DP)就是:每走一步,都会根据之前的情况来决定这一步的走向,所以,这种多阶段最优化决策解决问题的过程就称为动态规划。使用动态规划法一般会有一个递推公式(递推就是简单动态规划)。当然,最难找到的也是这个递推公式。

     

    3、贪心算法

    具体详情:贪心算法——五大常用算法之一

    基本概念:

    在对问题求解时,总是做出在当前看来是最好的选择。不从整体最优上加以考虑,所做出的仅是在某种意义上的局部最优解。

    贪心算法没有固定的算法框架,算法设计的关键是贪心策略的选择。必须注意的是,贪心算法不是对所有问题都能得到整体最优解,选择的贪心策略必须具备无后效性,即某个状态以后的过程不会影响以前的状态,只与当前状态有关。

    所以对所采用的贪心策略一定要仔细分析其是否满足无后效性

     

    4、回溯算法

    具体详情:回溯算法——五大常用算法之一

    基本概念

          回溯算法实际上一个类似枚举的搜索尝试过程(排列组合),主要是在搜索尝试过程中寻找问题的解,当发现已不满足求解条件时,就“回溯”返回,尝试别的路径。

    回溯法是一种选优搜索法,按选优条件向前搜索,以达到目标。但当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再走的技术为回溯法,而满足回溯条件的某个状态的点称为“回溯点”。

         许多复杂的,规模较大的问题都可以使用回溯法,有“通用解题方法”的美称。

     

    5、分支界定

    这个算法个人没有仔细研究,可能是因为学的较浅没有经常用到。下面内容做一个参考:

    基本描述

        类似于回溯法,也是一种在问题的解空间树T上搜索问题解的算法。但在一般情况下,分支限界法与回溯法的求解目标不同。回溯法的求解目标是找出T中满足约束条件的所有解,而分支限界法的求解目标则是找出满足约束条件的一个解,或是在满足约束条件的解中找出使某一目标函数值达到极大或极小的解,即在某种意义下的最优解。

     

    九、看书刷题

    推荐书本:算法笔记,java常用算法手册,剑指offer

    推荐网站:LeetCode等各大刷题网站

    展开全文
  • LeetCode初级算法笔记整理,印象笔记导出的HTML格式文件。
  • 密码 力扣初级算法练习
  • js代码-初级算法-旋转数组
  • 本资料为博客中对应的Leecode中初级算法的数组题代码,编程语言为java
  • LeetCode 探索中的初级算法,手写算法,部分题有题目分析思路
  • LeetCode初级算法-数组内容,共10个题,代码手写,可能不太清楚
  • leetcode删除账号 leetcode初级算法,solutions in Java (需先登录leetcode账号)
  • js代码-初级算法-买卖股票的最佳时机 II
  • chuji_suanfa 用python实现力扣的初级算法
  • leetcode 答案力码 leetcode中初级算法的答案 这是我第二次来 leetcode 有很长时间我没有练习我的算法 2020.11.10 又开始了
  • 初级算法习题集

    2008-06-07 00:10:05
    初级算法习题集,建议初学不久者观看
  • 上一篇 : LeetCode初级算法训练-树 下一篇 : LeetCode初级算法训练-xxxxx 本来想重初中级和企业面试算法开始的,但是最后还是选择从基础的开始,因为我们并不是为了刷题而刷题,而是在刷题过程中锻炼一种算法思维,...

    简介

    上一篇 : LeetCode初级算法训练-树

    下一篇 : LeetCode初级算法训练-动态规划

    本来想重初中级和企业面试算法开始的,但是最后还是选择从基础的开始,因为我们并不是为了刷题而刷题,而是在刷题过程中锻炼一种算法思维,在大量的训练之后形成一种对算法的独特见解,培养那种对算法的的敏感度,看到题目,大脑中可以浮现一个解题蓝图,而且从初级开始慢慢建立信心,而且这也是在为后边复杂算法的解题思路打基础。

    LeetCode初级算法简介

    如果你也想训练自己的算法思维,也可以加入我,从初级算法开始,开启你的算法之旅:初级算法

    自己的一些思考:不要在看完题目后直接就看答案,然后去背题,这样行成的算法记忆是不牢固的,一定要有自己的思考;而且不要一开始就在IDEA上边去写,一定试着自己在leetCode提供的白板上边写一遍最后在放到IDEA上边去执行看有什么问题,以便巩固你的基础API的使用和熟练度;还有一点就是大胆些,不是面试我们试错成本低,尽可能把我们的想法融入到代码中

    因篇幅问题,博客中只列出示例和自己的解题答案,详细可以直接点击题目查看。

    合并两个有序数组

    给你两个有序整数数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。

    说明:
    初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
    你可以假设 nums1 有足够的空间(空间大小大于或等于 m + n)来保存 nums2 中的元素。

    示例:
    输入:
    nums1 = [1,2,3,0,0,0], m = 3
    nums2 = [2,5,6], n = 3
    输出: [1,2,2,3,5,6]

    这边
    第一种方式比较容易想到但是时间复杂度比较慢。没有利用两个数据有序的特点。

    class Solution {
      public void merge(int[] nums1, int m, int[] nums2, int n) {
        System.arraycopy(nums2, 0, nums1, m, n);
        Arrays.sort(nums1);
      }
    }
    

    第二种方式是创建一个新数组把nums1的数据移到nums3中,用双指针比对两个数组中的数据插入到nums1中,最后把剩下的数据copy到nums1中。

    class Solution {
        public void merge(int[] nums1, int m, int[] nums2, int n) {
            int[] nums3 = new int[m];
            System.arraycopy(nums1, 0, nums3, 0, m);
    
            int p = 0;
            int p1 = 0, p2 = 0;
    
            while (p1 < m && p2 < n) {
                nums1[p++] = nums3[p1] <= nums2[p2] ? nums3[p1++] : nums2[p2++];
            }
    
            if (p1 < m)
                System.arraycopy(nums3, p1, nums1, p1 + p2, m + n - p1 - p2);
            if (p2 < n)
                System.arraycopy(nums2, p2, nums1, p1 + p2, m + n - p1 - p2);
        }
    }
    
    第一个错误的版本

    第一个错误的版本
    你是产品经理,目前正在带领一个团队开发新的产品。不幸的是,你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的,所以错误的版本之后的所有版本都是错的。

    假设你有 n 个版本 [1, 2, …, n],你想找出导致之后所有版本出错的第一个错误的版本。

    你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

    示例:
    给定 n = 5,并且 version = 4 是第一个错误的版本。

    调用 isBadVersion(3) -> false
    调用 isBadVersion(5) -> true
    调用 isBadVersion(4) -> true

    所以,4 是第一个错误的版本。

    利用二分搜索,当左边界和有边界相等,那个数就是我们找的数。

    /* The isBadVersion API is defined in the parent class VersionControl.
          boolean isBadVersion(int version); */
    
    public class Solution extends VersionControl {
        public int firstBadVersion(int n) {
            int left = 1;
            int right = n;
            while(left < right) {
                int mid = left + (right - left) / 2;
                if(isBadVersion(mid)){
                    right = mid;
                } else{
                    left = mid + 1;
                }
            }
            return left;
        }
    
    }
    

    22 / 22 个通过测试用例
    状态:通过
    执行用时:16 ms
    内存消耗:36.6 MB

    二分都用了 16ms更何况从头开始遍历。

    展开全文
  • java初级算法

    2013-06-10 23:46:37
    一个非常非常适合初学者来看的算法,不看绝对后悔哦。
  • 初级算法-动态规划(2)

    千次阅读 2020-02-16 20:43:28
    之前在初级算法-动态规划 一文中少写了动态规划的另外一种解法就是矩阵解法 递归问题可以使用非递归的方式表达出来,时间复杂度是O(n),使用矩阵解法时间复杂度O(logn) public static int climbStairs2(int n) { if...

    之前在初级算法-动态规划 一文中少写了动态规划的另外一种解法就是矩阵解法

    递归问题可以使用非递归的方式表达出来,时间复杂度是O(n),使用矩阵解法时间复杂度O(logn)

    public static int climbStairs2(int n) {
            if(n < 1) {
                return 0;
            }
    
            if (n == 1 || n == 2) {
                return n;
            }
            // m * n 矩阵表达式 int[m][n]
            int [][] pre = {{1,1}, {1,0}};
            int [][] result = matrixPower(pre, n-2);
            return 2 * result[0][0] + result[1][0];
        }
    
        public static int[][] matrixPower(int[][] m, int p) {
            int[][] result = new int[m.length][m[0].length];
            for (int i =0;i< result.length; i++) {
                result[i][i] =1;
            }
    
            int[][] tmp = m;
            // 矩阵的N次方 3 = 2^0 + 2^1
            for(; p != 0; p >>=1) {
                if ((p&1)!=0) {
                    // 这位数上为1,则加入乘积和
                    result =multiMatrix(result, tmp);
                }
                // 2 次方的计算,每个位上都是 2^n
                tmp = multiMatrix(tmp, tmp);
            }
            return result;
        }
    
        /**
         * 矩阵乘法
         * @param m1
         * @param m2
         * @return
         */
        public static int[][] multiMatrix(int[][] m1, int[][] m2) {
            int[][] result = new int [m1.length][m2[0].length];
            for(int i=0;i <m2[0].length ; i++) {
                for (int j = 0; j < m1.length; j++) {
                    for (int k =0; k< m2.length; k++) {
                        result[i][j] += m1[i][k] * m2[k][j];
                    }
                }
            }
            return result;
        }
    
    
    展开全文
  • Java初级算法

    2013-09-17 11:22:21
    收集了一些基础的算法,可供初学者在无聊的时候写写,练习Java程序写法
  • 上一篇 : LeetCode初级算法训练-排序和搜索 下一篇 : LeetCode初级算法训练-动态规划 本来想重初中级和企业面试算法开始的,但是最后还是选择从基础的开始,因为我们并不是为了刷题而刷题,而是在刷题过程中锻炼一种...
  • 这是学习leetcode初级算法学习笔记,以便后续复习。 本部分于国庆最后一天10/8号更新完毕。本人相应的做法也标记在了后面,以提醒自己复习,当然我的做法肯定不是最好的,只是做个参考,欢迎到leetcode评论区讨论。 ...
  • C语言的初级算法大全

    千次阅读 2012-08-31 09:48:33
    C语言的初级算法大全 一、单链表 目录 1.单链表反转 2.找出单链表的倒数第4个元素 3.找出单链表的中间元素 4.删除无头单链表的一个节点 5.两个不交叉的有序链表的合并 6.有个二级单链表,其中每个元素都含有...
  • LeetCode初级算法--链表01:反转链表 搜索微信公众号:'AI-ming3526'或者'计算机视觉这件小事' 获取更多算法、机器学习干货 csdn:https://blog.csdn.net/baidu_31657889/ csdn:https://blog.csdn.net/abcgkj/ ...
  • LeetCode初级算法--数组02:旋转数组 搜索微信公众号:'AI-ming3526'或者'计算机视觉这件小事' 获取更多算法、机器学习干货 csdn:https://blog.csdn.net/baidu_31657889/ csdn:https://blog.csdn.net/abcgkj/ ...
  • 探索初级算法 Leetcode #1023。 驼峰式匹配 背景和问题陈述 在本指南中,我们将通过 Python 解决一个有趣的 LeetCode 问题。 这是我们遇到的问题: 如果我们可以在模式词中插入小写字母使其等于查询,则查询词与给定...
  • LeetCode初级算法参考答案 LeetCode《 》中通过的代码。 LeetCode题目需要登录才能看到。 src/test/目录下有部分题目的测试样例。 代码目录 数组 题目 代码 字符串 题目 代码 链表 题目 代码 树 题目 代码 排序和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 52,603
精华内容 21,041
关键字:

初级算法