精华内容
下载资源
问答
  • InnoDB行锁时通过给索引上索引项加锁来实现,...行锁种算法Record Lock :单个记录上锁锁总会锁住索引记录,锁住时key。如果InnoDB存储引擎表在建立时候没有设置任何一个索引,那么这时InnoDB会使用隐...

    InnoDB行锁时通过给索引上的索引项加锁来实现的,Oracle时通过在数据块中相对应数据行加锁来实现。

    InnoDB这种行锁实现特点意味着,只有通过索引条件检索条件数据,InnoDB才使用行锁,否则InnoDB将使用表锁。

    行锁的三种算法

    Record Lock :单个记录上的锁

    锁总会锁住索引记录,锁住的时key。如果InnoDB存储引擎表在建立的时候没有设置任何一个索引,那么这时InnoDB会使用隐式的主键进行锁定。

    Gap Lock:间隙锁,锁定一个范围,但不包含记录本身

    锁定索引记录间隙,确保索引记录的间隙不变

    间隙锁时针对事务隔离级别为可重复读或以上级别而配的

    Gap Lock在InnoDB的唯一作用就是防止其他事务的插入操作,以此防止幻读

    Next-Key Lock:Gap Lock+Record Lock,锁定一个范围,并且锁定记录本身

    在Next-Key Lock 算法下,InnoDB对于行的查询都是采用这种锁定的算法。可以有效的防止幻读。

    当查询的索引含有唯一属性时,InnoDB存储引擎会对Next-Key Lock 进行优化,将其降级为 Record Lock,即仅锁住索引本身,而不是范围。

    当查询的索引为辅助索引时,默认使用Next-Key Locking技术进行加锁,锁定范围是前一个索引到后一个索引之间范围。

    解决 Phantom Problem

    在默认的事务隔离级别下,即REPEATABLE READ下,InnoDB存储引擎次采用Next-Key Locking机制来避免Phantom Problem(幻读问题).这点可能不同与其他的数据库,比如Oracle数据库,因为其可能需要在SERIALIZABLE的事务隔离级别下才能解决Phantom Problem。

    Phantom Problem 是指在同一事务下,连续执行两次同样的SQL语句可能导致不同的结果,第二次SQL语句可能会返回之前不存在的行。

    set session tx_isolation='read-committed'; 设置事务隔离级别为不可重复读

    展开全文
  • x星球钞票面额只有:100元,5元,2元,1元,共4。 小明去x星旅游,他手里只有2张100元x星币,太不方便,恰好路过x星银行就去换零钱。...注意,需要提交个整数,不要填写任何多余内容。
  • 无环状态下两种情况,一种是在某个节点相交,然后后面链全部共有,第二种是两条链没有任何交集,第三种情况是不会出现,因为违背了链表中节点只有一个指针定义。 有环状态下链表相交,包含三种情...

    题目引入:如果两个单链表相交,则返回他们相交的第一个节点。

    算法分析:该问题其实包含的情况很复杂,我们一步步来分析。
    1. 首先应该结合单链表的结构,一个值域,一个指针域,当两个单链表相交时,有以下几种情况。
    2. 无环状态下的两种情况,一种是在某个节点相交,然后后面的链全部共有,第二种是两条链没有任何交集,第三种情况是不会出现的,因为违背了链表中节点只有一个指针的定义。
      无环状态下
    3. 有环状态下的链表相交,包含三种情况:
      有环情况下的相交
    4. 以下就针对无环和有环条件下的链表相交进行讨论。

    1 判断链表有无环的存在,如果有返回环路的第一个节点,如果没有,就返回空指针。

    1.1.1 使用HashSet的思想:

    由于HashSet的无重性,构建一个Set对象,依次遍历单链表,如果遍历过程中发现了某节点已经在Set集合中了,那么该节点就是一个有环的链表,返回该节点。

    1.1.2 相关代码:
    //判断是否有环,因为是单链表 当有环的时候 最后一个节点的next应该不为空
    //head 为链表的头节点或者第一个节点
        public Node getFirstLoopNode1(Node head){
            //声明一个hashSet进行检测
            HashSet<Node> set=new HashSet<Node>();
            while(head!=null){
                if(set.contains(head)){
                    return head;
                }
                set.add(head);//哈希set里面存的是内存地址
                head=head.next;
            }
            for(Node node:set){
                System.out.println("set val:"+node.value);
            }
            return null;
        }
    
    1.2 不使用HashSet的方式
    1.2.1 算法思想:

    这里会用到一个数学推论,即声明两个快慢指针,快指针(fast)一次走两步,慢指针(slow)一次走一步,如果快指针到了最后一个节点为 null 则说明该链表无环,返回null;如果fast和slow指针在某处相遇了,则说明链表一定有环,则再令快指针(fast)指向表的第一个节点,与慢指针同步遍历,最后快慢指针再次相遇的地方即是环路的第一个节点。
    指针移动
    有环时候

    1.2.2 代码实现:
     public Node getFirstLoopNode3(Node head){
            if(head==null || head.next==null || head.next.next==null){
                return null;
            }
            Node slow=head.next;
            Node fast=head.next.next;
            while(slow!=fast){
                if(fast.next==null || fast.next.next==null){
                    return null;
                }
                fast=fast.next.next;
                slow=slow.next;
            }
            fast=head;
            while(fast!=slow){
                fast=fast.next;
                slow=slow.next;
            }
            return fast;
        }
    

    2 在判断完链表是否有环之后,就是分链表有环、无环两种情况,进行判断两者相交的第一个节点。

    2.1 无环条件下
    2.1.1 借助HashSet进行判断
    算法思想:

    将链表1的节点放进HashSet中,再将链表2的节点依次遍历,并判断是否在Set中存在,如果有则两者相交的第一个节点就是该节点,直接返回,满足博文之初那个无环相交的情况。

    2.1.2 相关代码:
     //借助hashSet进行得到相交的第一个节点
        public Node getNoLoopLinkSet(Node head1,Node head2){
            if(head1==null || head2==null){
                return null;
            }
            HashSet<Node> set=new HashSet<Node>();
            this.helpNode=head1;
            while(this.helpNode!=null){
                set.add(this.helpNode);
                this.helpNode=this.helpNode.next;
            }
            this.helpNode=head2;
            while(this.helpNode!=null){
                if(set.contains(this.helpNode)){
                    return this.helpNode;
                }
                this.helpNode=this.helpNode.next;
            }
            return null;
        }
    
    2.2 不借助 HashSet 进行判断无环相交的第一个节点
    2.2.1 算法思想:

    首先,判断两链表是否有共同的尾节点,如果有,则说明两链表相交;如果没有,则说明两链表不相交,直接返回。当判断为两链表相交后,需要通过移动链表的方式进行得到两者相交的第一个节点,这就涉及到链表长度的问题,如果两者长度不同,假设一个长度 L1,另一个L2,如果L1>L2,则让链表1先移动(L1-L2)的长度,然后再和第二个链表同步移动指针,当他们在某个节点相同时,就是相交的第一个节点。

    在这里插入图片描述

    2.2.2 代码实现
     //不借助单链表进行得到两相交链表的第一个节点
        public Node getNoLoopFirstNode(Node head1,Node head2){
            if(head1==null || head2==null){
                return null;
            }
            int n=0;//记录两个链表的差
            Node cur1=head1;
            Node cur2=head2;
            while(cur1!=null){
                n++;//得到 链表1 的长度
                cur1=cur1.next;
            }
            while(cur2!=null){
                n--;//得到 链表1与2 的差
                cur2=cur2.next;
            }
            cur1=n > 0 ? head1:head2; //n大于0则 1 链表长度 > 2 链表长度
            cur2=cur1==head1 ? head2:head1;
            while(n>0 && n!=0){
                cur1=cur1.next;
                n--;
            }
            while(n<0 && n!=0){
                cur1=cur1.next;
                n++;
            }
            while(cur1!=cur2){
                cur1=cur1.next;
                cur2=cur2.next;
            }
            return cur1;
        }
    

    3 在有环条件下判断相交,且返回相交的第一个节点。

    3.1 有环时相交与否满足以下几种情况
    1. A B各为单个的有环链路,不相交
    2. A B相交在环路之前
    3. A B相交在环上,但可能点不一样

    在这里插入图片描述

    3.2 针对以上三种结构,算法思想如下
    1. 遍历A B链表,返回有环的第一个节点 loop1 和 loop2
    2. 如果loop1==loop2 则为上图的相交的情况(第二幅图),将loop1 或 loop2作为链表的尾,从头开始遍历直到找到第一个相交的点。返回即可。
    3. 如果 loop1 != loop2 则为 第一种情况或者第三种,这种情况下,就是从loop1 开始遍历,终止条件为 再次返回到 loop1 ,看看这期间有没有遇到 loop2 如果有,则返回 loop1 或者 loop2即为两链表相遇的节点,如果没有,就是两链表没有相交,返回null.
    3.3 代码实现
    public Node getLoopFirstNode(Node head1,Node head2){
            if(head1==null || head2==null){
                return null;
            }
            System.out.println("begin test.."+noLoopLink(head1)+" "+noLoopLink(head2));
            //判断两链表均有环
            if(!noLoopLink(head1) && !noLoopLink(head2)){
                Node loop1=getFirstLoopNode3(head1);
                Node loop2=getFirstLoopNode3(head2);
                Node cur1=null;
                Node cur2=null;
                int n=0;//找两链表长度的差值
                if(loop1==loop2){
                    cur1=head1;
                    cur2=head2;
                    while(cur1!=loop1){
                        n++;
                        cur1=cur1.next;
                    }
                    while(cur2!=loop2){
                        n--;
                        cur2=cur2.next;
                    }
                    cur1=n > 0?head1:head2;
                    cur2=cur1==head1?head2:head1;
                    n=Math.abs(n);//取绝对值
                    while(n!=0){
                        cur1=cur1.next;
                        n--;
                    }
                    //可以使用 n 取绝对值来实现不用判断的过程
                   /* while(n>0 && n!=0){
                        cur1=cur1.next;
                        n--;
                    }
                    while(n<0 && n!=0){
                        cur1=cur1.next;
                        n++;
                    }*/
                    //System.out.println("the cur1:"+cur1.value+" "+cur2.value);
                    while(cur1!=cur2){
                        cur1=cur1.next;
                        cur2=cur2.next;
                    }
                    return cur1;
                }else{
                    cur1=loop1.next;
                   // cur2=loop1;
                    while(cur1!=null && cur1!=loop1){
                        cur1=cur1.next;
                    }
                    return null;
                }
    
            }
            System.out.println("the link has no cycle..");
           return null;
        }
    

    以上为判断单链表相交的内容,如果有问题,欢迎指正!

    展开全文
  • 算法算法的衡量

    千次阅读 2016-10-19 18:50:12
    一、算法算法是为了解决某些问题而规定一个有限长操作序列。 二、一个算法必须满足以下五个重要特征:1、有穷性:对于任意...并且在任何条件下,算法只有一条执行路径。3、可行性:算法所有操作都必须足够
    一、算法:算法是为了解决某些问题而规定的一个有限长的操作序列。
    

    二、一个算法必须满足以下五个重要特征:
    
    1、有穷性:对于任意一组合法输入值,在执行又穷步骤之后一定能结束,即:算法中的每个步骤都能在有限时间内完成。
    
    2、确定性:在每种情况下所应执行的操作,在算法中都有确切的规定,使算法的执行者或阅读者都能明确其含义
    
    及如何执行。并且在任何条件下,算法都只有一条执行路径。
    
    3、可行性:算法中的所有操作都必须足够基本,都可以通过已经实现的基本操作运算有限次实现之。
    
    4、有输入:作为算法加工对象的量值,通常体现在算法当中的一组变量。有些输入量需要在算法执行的过程中输
    
    入,而有的算法表面上可以没有输入,实际上已被嵌入算法之中。
    
    5、有输出:它是一组与“输入”有确定关系的量值,是算法进行信息加工后得到的结果,这种确定关系即为算法功能。
    

    三、算法的设计原则:设计算法时,通常应考虑达到以下目标:
    
    1、正确性:首先,算法应当满足以特定的“规则说明”方式给出的需求。其次,对算法是否“正确”的理解可以有以下次个层次
    
        1、程序不好语法错误。
    
        2、程序对于几组输入数据能够得出满足需要的结果。
    
        3、程序对于精心选择的、典型、苛刻切带有刁难性的几组输入数据能够得出满足要求的结果。
    
        4、程序对于一切合法的输入数据都能得到满足要求的结果。
    
        ps:通常以第3层意义的正确性作为衡量一个算法是否合格的标准。
    
    2、可读性:算法为了人的阅读与交流,其次才是计算机执行。因此算法应该易于人的理解;另一方面,晦涩难懂
    
    的程序易于隐藏较多的错误而难以调试。
    
    3、健壮性:当输入的数据非法时,算法应当恰当的做出反应或进行相应处理,而不是产生莫名其妙的输出结果。
    
    并且,处理出错的方法不应是中断程序执行,而是应当返回一个表示错误或错误性质的值,以便在更高的抽
    
    象层次上进行处理。
    
    4、高效率与低存储量需求:通常算法效率值得是算法执行时间;存储量是指算法执行过程中所需要的最大存储空
    
    间,两者都与问题的规模有关。
    

    四、算法效率的衡量方法和准则:
    
    1、事后统计法:
    
        缺点:
    
        1、必须执行程序
    
        2、其他因素掩盖算法本质
    
    2、事前分析估算法:
    
        和算法执行时间相关的因素:
    
        1、算法选用的策略
    
        2、问题的规模
    
        3、编写程序的语言
    
        4、编译程序产生的机器代码的质量
    
        5、机器执行指令的速度
    

    五、一个特定算法的“运行工作量”的大小,只依赖于问题的规模(通常用整数量n表示),或者说,
    
    它是问题规模的函数。
    
    例如:随着问题规模n的增长,算法执行的时间的增长率和f(n)的增长率相同,则可计作:
    
    T(n) = O(f(n))
    
    称T(n)为算法的(渐近)时间复杂度
    

    六、如何估算算法的时间负责度?
    
    算法 = 控制结构 + 原操作(固有数据类型的操作)
    
    算法的执行时间 = ∑原操作(i)的执行次数 × 原操作(i)的执行时间
    
    算法的执行时间 与 原操作执行次数之和成正比
    
    从算法中选取一中对于所研究的问题来说是 基本操作 的原操作,以该基本操作 在算法中重复执行的次数 作为算
    
    法运行时间的衡量准则。
    

    七、算法的存储空间需求
    
    算法的空间复杂度
    
    S(n) = O(g(n))
    
    表示随着问题规模n的增大,算法运行所需存储量的增长率与g(n)的增长率相同。
    

    八、算法的存储量包括:
    
    1、程序本身所占空间;
    
    2、输入数据所占空间;
    
    3、辅助变量所占空间;
    
    若输入数据所占空间只取决于问题本身,和算法无关,则只需要分析除输入和程序之外的辅助变量所占额外空间。
    
    若所需额外空间相对于输入数据量来说是常数,则称此算法为 原地工作。
    
    若所需存储量依赖于特定输入,则通常按最坏情况考虑。
    
    展开全文
  • 算法

    2020-07-05 19:57:51
    并且,在任何条件下,算法只有唯一的一条执行路径,即对于相同输入只能得出相同输出。 3、可行性 算法中描述操作都是可以通过已经实现基本运算执行有限次来实现。 4、输入 零个或多个 5、输出 个或多个 ...

    算法(algorithm)是对特定问题求解步骤的一种描述,它是指令的有限序列,其中每一条指令表示一个或多个操作。
    算法的5个重要特性:
    1、有穷性 有穷步之后结束,且每一步都可在有穷时间内完成。

    2、确定性 每一条指令必须有确切的含义。并且,在任何条件下,算法只有唯一的一条执行路径,即对于相同的输入只能得出相同的输出。

    3、可行性 算法中描述的操作都是可以通过已经实现的基本运算执行有限次来实现的。

    4、输入 零个或多个

    5、输出 一个或多个

    算法设计的要求:

    1、正确性 算法应当满足具体问题的需求,至少应当包括对于输入、输出和加工处理等的明确的无歧义性的描述,设计或选择的算法应当能正确地反映这种需求。
    大体可分为4个层次:
    a、程序不含语法错误
    b、程序对于几组输入数据能够得出满足规格说明要求的结果·
    c、程序对于精心选择的典型、苛刻而带有刁难性的几组输入数据能够得出满足规格说明要求的结果
    d、程序对于一切合法的输入数据都能产生满足规格说明要求的结果。

    2、可读性
    3、健壮性 当输入数据非法时,算法也能适当地作出反应或进行处理,而不会产生莫名其妙的输出结果。
    4、效率与低存储量需求 效率指的是算法执行的时间。存储量需求是指算法执行过程中所需要的最大存储空间。效率和低存储量需求这两者都与问题的规模有关。

    展开全文
  • 迭代法是用于求方程或方程组近似根的一种常用的算法设计方法。设方程为f(x)=0,用某种数学方法导出等价的形式x=g(x),然后按以下步骤执行: (1) 选一个方程的近似根,赋给变量x0; (2) 将x0的值保存于变量x1...
  • 在动态规划算法零一背包问题中,我们知道了所谓零一背包是指每一种物品只有一个,所以它状态只有0和1两种,即拿或者不拿。而今天我们要来讨论物品不止有一个情况,物品不止有一个也分两种,一种是不作任何...
  • 算法(Algorithm)是对特定问题求解步骤的一种描述,它是指令有限序列,其中每一条指令表示一个或多个操作。 一个算法还具有以下5个重要特征。 有穷性。 一个算法必须总是(对任何合法输入值)在执行有穷步之后...
  • 1.问题 整数规划问题,0-1 背包问题 ...任何装法都只有一种方式, 因此都是最优解,因此轻者先装也是最优解。 (2)归纳假设:假设算法对于规模为 k 输入都能得到最优解。 考虑规模为 k+1 输入,N={1,2,
  • 算法算法分析

    2020-02-22 16:54:32
    (2)确定性:每条指令必须有确定含义,无二义性,在任何条件下,算法只有一条执行路径。 (3)可行性:一个算法是可以运行 (4)输入:有0个或多个输入。 (5)输出:有一个或多个输出。 ...
  • 算法算法分析总结

    千次阅读 2017-07-26 22:01:15
    算法:是对特定问题求解步骤的一种描述,是指令有限序列,其中每一条指令表示一个或多个操作。 算法的5个特性: (1)有穷性:一个算法总是(对于任何合法输入值)在执行有穷步之后结束,且每一步都可在有穷时间...
  • 机器智能-高频问题:AC-3算法

    千次阅读 2020-03-18 21:52:05
    一种约束传播算法,即在得到约束条件和值域情况下,算出所有变量满足约束条件取值范围。注意,AC-3算法能够处理的只有二元约束,即弧相容情况,或者说在约束条件中任何一个约束条件都只包含了两个一下变量...
  •  没有任何一种分类器可以在所有的问题中都有良好表现,即对于每一种分类算法,总有一定的问题是无法良好解决。实践表明,只有比较了多种学习算法的性能才能为特定的问题挑选出合适模型。这些模型针对不同...
  • 任何装法都只有一种方式,因此都是最优解,因此轻者先装也是最优解。 (2)归纳假设:假设算法对于规模为k输入都能得到最优解。 考虑规模为k+1输入,N={1,2,…,k+1},W={w1,w2,…,wk+1}是集装箱重量,w1≤w2≤…...
  • 回溯算法---过河问题(商人过河)

    千次阅读 2019-06-20 18:21:38
     有三个商人和三个仆人过河,只有一条能装下两个人船,在河的任何一岸上,如果仆人人数大于商人人数,那么该岸上商人就会有危险。你能不能找出一种安全渡河方法呢?    过河问题是一个比较出名的问题,...
  • 算法系列之三:妖怪与和尚过河问题

    万次阅读 多人点赞 2011-07-25 00:02:21
    有三个和尚(或传教士)和三个妖怪(或食人怪)过河,只有一条能装下两个人(和尚或妖怪)船,在河的任何一方或者船上,如果妖怪人数大于和尚人数,那么和尚就会有被吃掉危险。你能不能找出一种安全渡河...
  • 分治算法

    2021-03-20 10:43:47
    一种分目标完成程序算法,简单问题可用二分法完成。 ​ (1)分解,将要解决的问题划分成若干规模较小的同类问题; ​ (2)求解,当子问题划分得足够小时,用较简单的方法解决; ​ (3)合并,按原问题的要求...
  • 上一讲当中我们一起学习了动态规划算法零一背包问题,我们知道了所谓零一背包是指每一种物品只有一个,所以它状态只有0和1两种,即拿或者不拿。而今天我们要来讨论物品不止有一个情况,物品不止有一个也分...
  • 回溯算法---过河问题

    千次阅读 2013-09-13 14:09:25
     有三个商人和三个仆人过河,只有一条能装下两个人船,在河的任何一岸上,如果仆人人数大于商人人数,那么该岸上商人就会有危险。你能不能找出一种安全渡河方法呢?    过河问题是一个比较出名的问题...
  • 算法: 算法是对特定问题求解步骤的一种描述,它是指令有限序列,其中每一个条指令表示一个或多个操作。 算法5个重要特性: 有穷性: 一个算法必须总是(对任何合法输入值)在执行有穷步之后结束,且每一步都可在有穷...
  • 什么是算法

    2019-01-18 19:03:47
    算法是对特定问题求解步骤的一种描述,他是指令有限序列,其中每一条指令表示一个或者多个操作,此外,一个算法还具有下列5个重要特性: (1)有穷性:一个算法必须总是(对任何合法输入值)在执行有穷步之后...
  • 在遗传操作中只使用选择和变异操作,共设计了三种变异操作,其中两种变异操作均不会产生不可行解,只有一种变异操作可能会产生不可行解,需要作树检查和修改;这样就大大降低了不可行解产生机会,从而提高了遗传...
  • 01算法简介

    2017-01-02 12:16:41
    算法是对特定问题求解步骤的一种描述,它是指令有限序列,其中每一条指令表示一个或多个操作。算法有五个重要特征: 1)有穷性:一个算法必须总是在执行有穷步之后结束,且每一步都可在有穷时间内完成。 2)确定性...
  • 你会看到马里奥以一种太空漫游姿态在空中抛弧线。 导致这种情况原因很简单,因为我们计算和绘制每个div位置时候是在每帧更新,每帧移动2px。在60fps情况下,我们1秒钟会执行60帧,...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 328
精华内容 131
关键字:

任何问题的算法只有一种