遍历递归树求递推数列通项

已于 2024-08-17 02:09:43 修改
阅读量354 收藏
点赞数
分类专栏： 算法 数据结构 文章标签： 算法 数据结构
于 2021-12-19 18:53:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/naturerun/article/details/122027827
版权

考虑K阶变系数线性递推方程：

现给定初值a1,a2,—,ak和n>k,要求编程打印an,an-1,—,ak+1的值

该问题用常规的迭代法非常容易解决，现在要考虑的是用遍历递归调用树的方法求解。n=7,k=3时，递归调用树为

package programm;           //遍历递归树中所有节点，相同值会重复计算
import java.util.*;

public class RecursionTree 
{

    public static void main(String[] args)
    {
        final int K=3;
        final int N=7;
        int[] initial=new int[K];
        for (int i=0; i<K; i++)
            initial[i]=i+1;
        
        Stack<Node> stack=new Stack<Node>();
        stack.push(new Node(0, 0, N));
        boolean TF=true;
        int sign=0, n=stack.getTop().getIndex();
        
        while(!stack.isEmpty())
        {
            if (1<=n&&n<=K)
            {
                stack.getTop().setSum(stack.getTop().getSum()+initial[n-1]*(stack.getTop().getIndex()+stack.getTop().getFlag()));
                TF=false;
                n=stack.getTop().getIndex();
            }
            else
            { 
                if (TF==false)
                {
                    stack.getTop().setFlag(stack.getTop().getFlag()+1);
                    
                    if (stack.getTop().getFlag()>K)
                    {
                        Node temp=stack.pop();
                        temp.setSum(temp.getSum()+temp.getIndex());
                        
                        if (stack.isEmpty())
                        {
                            System.out.println("The "+temp.getIndex()+"nd item is "+temp.getSum());
                        }
                        else
                        {                
                            if (stack.getTop().getFlag()==1 && temp.getIndex()>sign)
                            {
                                sign=temp.getIndex();
                                System.out.println("The "+temp.getIndex()+"nd item is "+temp.getSum());
                            }
                        
                            stack.getTop().setSum(stack.getTop().getSum()+temp.getSum()*(stack.getTop().getIndex()+stack.getTop().getFlag()));
                            n=stack.getTop().getIndex();
                            TF=false;
                        }
                    }
                    else
                    {
                        if ((n=stack.getTop().getIndex()-stack.getTop().getFlag())>K)
                        {
                            stack.push(new Node(0, 0, n));
                            TF=true;
                        }
                        else
                        {
                            continue;
                        }
                    }
                }
                else
                {
                    stack.getTop().setFlag(stack.getTop().getFlag()+1);
                    if ((n=stack.getTop().getIndex()-1)>K)
                    {
                        stack.push(new Node(0, 0, n));
                        TF=true;
                    }
                    else
                    {
                        continue;
                    }
                }
            }
        }
    }

}

class Node
{
    private int sum;
    private int flag;
    private int index;    
    
    public Node(int sum, int flag, int index)
    {
        this.sum=sum;
        this.flag=flag;
        this.index=index;
    }
    
    public int getSum()
    {
        return sum;
    }
    
    public void setSum(int sum)
    {
        this.sum=sum;
    }
    
    public int getFlag()
    {
        return flag;
    }
    
    public void setFlag(int flag)
    {
        this.flag=flag;
    }
    
    public int getIndex()
    {
        return index;
    }
}

class Stack<E>
{
    ArrayList<E> list=new ArrayList<E>();
    
    public boolean isEmpty()
    {
        return list.isEmpty();    
    }
    
    public int getSize()
    {
        return list.size();
    }
    
    public E getTop()
    {
        return list.get(getSize()-1);
    }
    
    public E pop()
    {
        E interval=list.get(getSize()-1);
        list.remove(getSize()-1);
        return interval;
    }
    
    public void push(E Ob)
    {
        list.add(Ob);
    }
}

运行结果：

 以上方法的问题是，相同的项会被重复计算多次，如a4被重复计算了三次，所以以上方法需要改进。用数组保存已求出项的值，遍历
到相同项时直接从数组中找到并使用其值即可。要实现这一点，需要修改源程序41行，48行，60-61行。修改后的代码如下：
程序二：

package programm;   //不遍历递归树中所有节点,相同值不会重复计算
import java.util.*;

public class RecursionTree 
{

    public static void main(String[] args)
    {
        final int K=3;   //递推方程阶数
        final int N=7;   //要求的部分数列中下标最大的项的下标
        int[] initial=new int[K];   //初值a1----ak
        for (int i=0; i<K; i++)    //令初值a1----ak分别为1,2---,k
            initial[i]=i+1;
        
        Stack<Node> stack=new Stack<Node>();   //建立Node类型栈对象
        stack.push(new Node(0, 0, N));     //递归树根节点压入栈，该节点flag=sum=0，index=N
        boolean TF=true;    //true向前进至下一层,false回溯至上一层
        int sign=0, n=stack.getTop().getIndex();   //sign记录当前已遍历节点中下标最大的节点,n初始化为根节点下标
        int[] result=new int[N-K];   //记录ak+1---aN项值的数组
        
        while(!stack.isEmpty())   //栈不空
        {
            if (1<=n&&n<=K)  //到达递归树中可直接写出值的叶子结点
            {
                stack.getTop().setSum(stack.getTop().getSum()+initial[n-1]*(stack.getTop().getIndex()+stack.getTop().getFlag()));  //将叶子结点值乘以系数累加至父节点
                TF=false;
                n=stack.getTop().getIndex();    //回溯
            }
            else
            { 
                if (TF==false)
                {
                    stack.getTop().setFlag(stack.getTop().getFlag()+1);   //当前节点flag增一，试探下一子节点
                    
                    if (stack.getTop().getFlag()>K)    //当前节点所有子节点均试探完毕
                    {
                        Node temp=stack.pop();   //从栈中弹出当前节点
                        temp.setSum(temp.getSum()+temp.getIndex());   //加上尾数f(n),得到当前节点的值
                        
                        if (stack.isEmpty())  //栈空,temp引用根节点，根节点值已求出，存放在temp的sum中
                        {
                            result[N-K-1]=temp.getSum();   //在数组result中存放根节点即aN的值
                            System.out.println("The "+temp.getIndex()+"nd item is "+temp.getSum());  //打印aN的值
                        }
                        else
                        {                
                            if (stack.getTop().getFlag()==1 && temp.getIndex()>sign)  //找到当前已遍历节点中下标最大节点
                            {
                                sign=temp.getIndex();   //设置新的最大下标
                                result[temp.getIndex()-K-1]=temp.getSum();  //当前节点值存放至result数组中
                                System.out.println("The "+temp.getIndex()+"nd item is "+temp.getSum());  //打印当前节点值
                            }
                        
                            stack.getTop().setSum(stack.getTop().getSum()+temp.getSum()*(stack.getTop().getIndex()+stack.getTop().getFlag()));  //当前节点值乘以系数累加至父节点
                            n=stack.getTop().getIndex();
                            TF=false;  //回溯
                        }
                    }
                    else
                    {
                        if ((n=stack.getTop().getIndex()-stack.getTop().getFlag())>K)  //前进至非叶子结点
                        {
                            stack.getTop().setSum(stack.getTop().getSum()+result[n-K-1]*(stack.getTop().getIndex()+stack.getTop().getFlag()));  //当前节点值之前已算出，从数组result中找出该值乘以系数累加至父节点
                            n=stack.getTop().getIndex();
                            TF=false;      //回溯
                        }
                        else
                        {
                            continue;  //直接进至下一轮循环，累加叶子节点值和系数乘积至父节点
                        }
                    }
                }
                else
                {
                    stack.getTop().setFlag(stack.getTop().getFlag()+1); //进至新的一层,当前节点flag增一试探下一层节点
                    if ((n=stack.getTop().getIndex()-1)>K) //下一层第一个节点非叶子
                    {
                        stack.push(new Node(0, 0, n));    //该节点压入栈
                        TF=true;  
                    }                                      
                    else
                    {
                        continue;    //同上
                    }
                }
            }
        }
    }

}

class Node    //递归树节点类
{
    private int sum;     //当前节点值
    private int flag;    //当前节点的父节点下标和当前节点下标之差
    private int index;    //当前节点下标
    
    public Node(int sum, int flag, int index)   //构造方法
    {
        this.sum=sum;
        this.flag=flag;   
        this.index=index;
    }
    
    public int getSum()
    {
        return sum;
    }
    
    public void setSum(int sum)
    {
        this.sum=sum;
    }
                                    //访问器和修改器
    public int getFlag()
    {
        return flag;
    }
    
    public void setFlag(int flag)
    {
        this.flag=flag;
    }
    
    public int getIndex()
    {
        return index;
    }
}

class Stack<E>            //泛型栈类
{
    ArrayList<E> list=new ArrayList<E>();
    
    public boolean isEmpty()
    {
        return list.isEmpty();    
    }
    
    public int getSize()
    {
        return list.size();
    }
    
    public E getTop()
    {
        return list.get(getSize()-1);
    }
    
    public E pop()
    {
        E interval=list.get(getSize()-1);
        list.remove(getSize()-1);
        return interval;
    }
    
    public void push(E Ob)
    {
        list.add(Ob);
    }
}

可以验证运行结果和程序一相同，但是节省了运行时间
删掉程序一37行，修改24行和51行可以得到程序三，用于计算递推数列an=an-1+—an-kn>k a1=1—ak=k当给定n>k时an,—,ak+1的值。
程序三(n=7, k=2, a1=1, a2=2)：

package programm;          //an=an-1+---an-k型递归式求解，遍历所有节点
import java.util.*;

public class RecursionTree 
{

    public static void main(String[] args)
    {
        final int K=2;
        final int N=7;
        int[] initial=new int[K];
        for (int i=0; i<K; i++)
            initial[i]=i+1;
        
        Stack<Node> stack=new Stack<Node>();
        stack.push(new Node(0, 0, N));
        boolean TF=true;
        int sign=0, n=stack.getTop().getIndex();
        
        while(!stack.isEmpty())
        {
            if (1<=n&&n<=K)
            {
                stack.getTop().setSum(stack.getTop().getSum()+initial[n-1]);
                TF=false;
                n=stack.getTop().getIndex();
            }
            else
            { 
                if (TF==false)
                {
                    stack.getTop().setFlag(stack.getTop().getFlag()+1);
                    
                    if (stack.getTop().getFlag()>K)
                    {
                        Node temp=stack.pop();
                        
                        if (stack.isEmpty())
                        {
                            System.out.println("The "+temp.getIndex()+"nd item is "+temp.getSum());
                        }
                        else
                        {                
                            if (stack.getTop().getFlag()==1 && temp.getIndex()>sign)
                            {
                                sign=temp.getIndex();
                                System.out.println("The "+temp.getIndex()+"nd item is "+temp.getSum());
                            }
                        
                            stack.getTop().setSum(stack.getTop().getSum()+temp.getSum());
                            n=stack.getTop().getIndex();
                            TF=false;
                        }
                    }
                    else
                    {
                        if ((n=stack.getTop().getIndex()-stack.getTop().getFlag())>K)
                        {
                            stack.push(new Node(0, 0, n));
                            TF=true;
                        }
                        else
                        {
                            continue;
                        }
                    }
                }
                else
                {
                    stack.getTop().setFlag(stack.getTop().getFlag()+1);
                    if ((n=stack.getTop().getIndex()-1)>K)
                    {
                        stack.push(new Node(0, 0, n));
                        TF=true;
                    }
                    else
                    {
                        continue;
                    }
                }
            }
        }
    }

}

class Node
{
    private int sum;
    private int flag;
    private int index;    
    
    public Node(int sum, int flag, int index)
    {
        this.sum=sum;
        this.flag=flag;
        this.index=index;
    }
    
    public int getSum()
    {
        return sum;
    }
    
    public void setSum(int sum)
    {
        this.sum=sum;
    }
    
    public int getFlag()
    {
        return flag;
    }
    
    public void setFlag(int flag)
    {
        this.flag=flag;
    }
    
    public int getIndex()
    {
        return index;
    }
}

class Stack<E>
{
    ArrayList<E> list=new ArrayList<E>();
    
    public boolean isEmpty()
    {
        return list.isEmpty();    
    }
    
    public int getSize()
    {
        return list.size();
    }
    
    public E getTop()
    {
        return list.get(getSize()-1);
    }
    
    public E pop()
    {
        E interval=list.get(getSize()-1);
        list.remove(getSize()-1);
        return interval;
    }
    
    public void push(E Ob)
    {
        list.add(Ob);
    }
}

运行结果：

 显然，所求得的即为斐波那契数列的第4-8项
为了便于读者理解程序一二三，下面给出一个经过简化的程序四，实现思想和程序一二三基本相同且功能和程序三相同
程序四（n=7, k=2, a1=1, a2=2）:不难验证运行结果和程序三是一致的

package RecursionTree;    //简化版的an=an-1+---an-k型递归式求解，遍历所有节点
import java.util.*;

public class recursiontree
{
    public static void main(String[] args) 
    {
        final int K=2;
        final int N=7;
        int[] initial=new int[K];
        for (int i=0; i<K; i++)
            initial[i]=i+1;
        
        Stack<Node> stack=new Stack<Node>();
        stack.push(new Node(0, N));
        boolean TF=true;
        int sum=0;
        
        while (!stack.isEmpty())
        {
            if (1<=stack.getTop().getIndex() && stack.getTop().getIndex()<=K)
            {
                sum+=initial[stack.getTop().getIndex()-1];
                stack.pop();
                TF=false;
            }
            else
            {
                if (TF==false)
                {
                    stack.getTop().setFlag(stack.getTop().getFlag()+1);
                    if (stack.getTop().getFlag()>K)
                    {
                        stack.pop();
                        TF=false;
                    }
                    else
                    {
                        stack.push(new Node(0, stack.getTop().getIndex()-stack.getTop().getFlag()));
                        TF=true;
                    }
                }
                else
                {
                    stack.getTop().setFlag(stack.getTop().getFlag()+1);
                    stack.push(new Node(0, stack.getTop().getIndex()-1));
                    TF=true;
                }
            }
        }
        System.out.println("The "+N+"nd item is "+sum);
    }
}

class Node
{
    private int flag;
    private int index;    
    
    public Node(int flag, int index)
    {
        this.flag=flag;
        this.index=index;
    }    
    
    public int getFlag()
    {
        return flag;
    }
    
    public void setFlag(int flag)
    {
        this.flag=flag;
    }
    
    public int getIndex()
    {
        return index;
    }
}

class Stack<E>
{
    ArrayList<E> list=new ArrayList<E>();
    
    public boolean isEmpty()
    {
        return list.isEmpty();    
    }
    
    public int getSize()
    {
        return list.size();
    }
    
    public E getTop()
    {
        return list.get(getSize()-1);
    }
    
    public E pop()
    {
        E interval=list.get(getSize()-1);
        list.remove(getSize()-1);
        return interval;
    }
    
    public void push(E Ob)
    {
        list.add(Ob);
    }
}

naturerun
关注
专栏目录
php求斐波那契数的两种实现方式【递归与递推】
10-16
递推法通常通过循环实现，初始值设置为斐波那契数列的前两项，然后通过循环来逐步计算后续的每一项。在PHP中，可以通过for循环来实现，循环开始前初始化前两个数为1，然后从第三项开始，用三个变量来模拟迭代过程，...
递推方程的求解
我好像没写什么
09-19 2801
文章目录先修知识常见序列的求和公式求和例子估计和式上界的放大法二分检索算法的平均时间复杂度分析实例递推方程的几种求法迭代法换元迭代差消法化简高阶递推方程递归树方法递归树的概念迭代在递归树中的表示方法递归树的生成规则递归树生成实例生成的递归树对递归树上的量求和递归树的应用实例主定理主定理的应用背景主定理概念主定理证明过程主定理的应用不能使用主定理的例子 先修知识 常见序列的求和公式 求和例子 上...
算法学习 | 递归方程求解
qq_56450212的博客
10-16 7228
递推方程求解，包括特征方程、递归树、主方法
递归树求解递归方程
欢迎来到我的博客~
07-31 1万+
首先了解一下这个递归式 T(n)=4T(n/2)+n 是什么意思： 4表示我们将一个问题分解为 4 个子问题 n/2表示每个子问题的规模是原问题的 1/2 n表示合并需要的额外计算时间 方法一可用主定理【Master定理】 主定理【Master定理】提供了分治方法带来的递归表达式的渐进复杂度分析。 将规模为 n 的问题通过分治，得到 a 个规模为 n/b 的问题，每次递归带来的额外计算为 c(n^d) 即 T(n)=a(n/b)+c(nd) 若 a=bd , T(n)=O(ndlog(n...
算法初探——分治法
CodeCAT
08-20 749
分治法的算法设计划分、把整个问题划分成若干子问题 求解 合并 分析过程建立递归方程，求解
［数据结构］递归树：借助树求解递归算法的时间复杂度
Tattoo的博客
03-10 2455
文章目录递归树与时间复杂度分析实战一：分析快速排序的时间复杂度实战二：分析斐波那契数列的时间复杂度实战三：待补充，先学其他的．．． 递归树与时间复杂度分析 我们前面讲过，递归的思想就是，将大问题分解为小问题来求解，然后再将小问题分解为小小问题。这样一层一层地分解，直到问题的数据规模被分解得足够小，不用继续递归分解为止。 如果我们把这个一层一层的分解过程画成图，它其实就是一棵树。我们给这棵树起一个名...
递推与递归应用[参照].pdf
10-12
递推和递归是密切相关的思想，递归是通过函数调用自身来解决问题，而递推则是通过公式计算后续数据项。在实际编程中，递推通常比递归更有效，因为它避免了重复计算和调用栈的开销。然而，理解和掌握递推与递归的关系...
DSAinC++3-遍历迭代与递归1
08-04
第3章 遍历、迭代与递归 在计算机科学中，遍历、迭代和递归是三种常见的解决问题的方法，特别是在数据处理和算法设计中。遍历是访问集合所有元素的过程，通常按照一定的顺序，确保每个元素仅被访问一次。这种操作在...
Javascript迭代、递推、穷举、递归常用算法实例讲解
10-17
### Javascript迭代、递推、穷举、递归常用算法实例讲解 Javascript是一门灵活而强大的编程语言，它在算法实现上有多种方式，其中迭代、递推、穷举和递归是实现算法逻辑时常用的方法。下面，我将对这些方法进行详细...
递推-递归-分治-回溯.docx
最新发布
11-11
递归在处理树结构、图遍历等问题时特别有效。例如，计算阶乘可以使用递归函数，`factorial(n) = n * factorial(n-1)`，当 n 为1时递归结束。 分治策略将大问题分解为小问题，分别解决后再合并结果。常见的分治算法...
遍历算法：递归思想
AI_drag0n的博客
12-18 430
递归： 先递推，再回归：方法定义中调用方法本身的现象。  --------------------------  数学归纳法的思想 注意事项： 1.要有出口，否则就是死递归 2.次数不能太多，否则就内存溢出 3.构造方法不能递归使用 案例分析： 案例一：兔子问题(斐波那契数列) -----------------------------------  前后两数的商无限接近于黄金分...
递归树法求解递归式
江船夜雨听笛的博客
10-04 1万+
递归算法时间复杂度的计算方程式一个递归方程： 　　 　　在引入递归树之前可以考虑一个例子： 　　T(n) = 2T(n/2) + n2 　　迭代2次可以得： 　　T(n) = n2+ 2(2T(n/4) + (n/2)2) 　　还可以继续迭代，将其完全展开可得： 　　T(n) = n2+ 2((n/2)2+ 2((n/22)2+ 2((n/23)2+ 2((n/24)2+…+2((n/2i)2+ 2T(n/2i + 1)))…))))　　……(1) 　　而当n/...
递归算法深入浅出
pengzhisen123的博客
03-16 939
转载请加本文连接：http://blog.csdn.net/nthack5730/article/details/65537530  什么是递归 　　简单的说：递归就是程序不断调用自身，递归方法就是方法直接或间接调用自身的方法，递归是一个很有用的程序设计技术！ 递归有两大特点： 反复执行的过程（调用自身）结束反复执行过程的条件（方法跳出点） 递归缺点：
求解递归方程的方法：递归树法
m0_51226527的博客
06-29 2708
求解递归方程的方法：递归树法 示例一 T(n)=2T(n/2)+n-1,求T(n)上界 示例二 根据式 T(n)=3T(n/4)+ θ(n^2 )，写出其递归树，并计算其时间复杂度。(要求写出时间复杂度的推导过程 )
用递归树方法求解递归式
疙瘩村村书记
11-26 6106
用递归树方法求解递归式 递归式：T(n)=3T(n/4)+Θ(n2)T\left(n\right)=3T\left(n/4\right)+Θ\left(n^2\right)T(n)=3T(n/4)+Θ(n2) 我们先来了解一下这个递归式什么意思： 333 表示我们将一个问题分解为333个子问题； n/4n/4n/4 则表明每个子问题的规模是原问题的1/41/41/4； T()T\left(\ri...
递推方程求解方法
菜鸡程序员的进阶
07-13 3万+
总结一下递归方程的求解方法。1、迭代法不断用递推方程的右部替换左部，下面以汉诺塔为例进行求解。有时候直接迭代可能不太方便，可以使用换元迭代。下面以二分归并排序迭代方程为例进行求解。2、差消法     差消法一般应用在递归方程右边不仅仅只依赖于当前项的前一项，而是前很多项，这种递归方程直接用迭代法很麻烦。属于高阶递归方程，因此要先把高阶递归方程进行差消，再进行迭代。以快速排序的递归方程为例。3、递归...
递归方程的求解（代入、递归树和主方法）
筱羊冰冰
12-17 1万+
递归方程 递归方程之前提到过，就是部分算法在求解的过程中使用了将一个问题划分成几个等价的小问题，在这个过程中，我们就可以列出一个等式。 （如归并排序中，将一个大数组拆分成两个小数组分别计算，然后用O(n)的代价合并， T(n) = T(n/2)+O(n)就是一个递归方程） 那么，在得到一个递归方程之后，我们应该如何求解问题呢？ 替换法/代入法 我们都知道，归并排序的时间复杂度为O(nlogn)，那么我们以后看到和上面给出的归并排序差不多的递归方程时，我们可能心中就有了一些猜想。 没错，这个方式就是通过经验经
算法导论------递归算法的时间复杂度求解
热门推荐
麦田里的码农
12-04 7万+
1.算法设计与分析概述  在总结递归算法的时间复杂度分析之前，应该明确几组概念。   算法仅仅是求解问题的解决方案，这个解决方案本身并不是问题的答案，而是能获得答案的指令序列。只有通过执行算法才可以获得求解问题的答案。   从算法是否递归调用的角度看，算法可以分为非递归算法和递归算法。   非递归算法时间复杂度分析较为简单，通常是计算算法中基本语句执行次数，一般都是一个关于问题规模n的表达式，
递归与递推：Catalan数列详解与应用实例
在实际应用中，递归和递推技术被广泛用于解决诸如图形搜索（如迷宫问题）、树遍历、编译器语法分析、排序算法（如快速排序的分治策略）等众多问题。Catalan数列及其相关的递归概念在计算机科学中扮演着连接理论与...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值