精华内容
下载资源
问答
  • 主要介绍了使用java API实现zip递归压缩文件夹及解压,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了springboot + vue 实现递归生成多级菜单,本文通过实例代码给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 基于《编译原理教程(第四版)》胡元义 第三章 语法分析 伪代码(P52-53)实现递归下降分析器。 自顶向下的语法分析 实现方式:c语言 内容包括: (1) 文法 (2) 源代码 分析的字符串为i*(i+i)# 注意:c语言...
  • js代码-递归循环1-100的和
  • 这里本人自己写的是折半查找算法(又称二分查找)的c++代码实现, 用的是递归的方法和非递归的方法, 里面的代码已经编译通过,并且优化好, 有需要的朋友可以下载借鉴一下
  • 主要介绍了Python 实现递归法解决迷宫问题的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 页面上要分页展示层级关系的数据信息,很容易就想到递归,我能想到的主要有两种做法:1 在SQL中使用递归,2 一条简单的SQL将所有要展示的信息获取,使用JAVA代码逻辑进行递归封装。 本文采用的是第二种,主要是考虑...

    页面上要分页展示层级关系的数据信息,很容易就想到递归,我能想到的主要有两种做法:1 在SQL中使用递归,2 一条简单的SQL将所有要展示的信息获取,使用JAVA代码逻辑进行递归封装。

    本文采用的是第二种,主要是考虑到如果数据量过大,使用SQL递归感觉查询较慢,页面等待时间过长(自我感觉,并没有实际验证),但由于是采用的第二种做法,导致无法使用PageHelper三连完成分页(此时SQL返回的是所有记录,并没有递归效果,所以此时做分页毫无意义), 所以需要使用java代码逻辑实现递归完成后在进行简单的分页封装

    PageHelper三连:

    /**
    * pageNo : 第几页
    * pageSize : 每页显示多少条
    */
    
    PageHelper.startPage(pageNo, pageSize);
    Page<TestVO> pageTestList = testDao.getListById(id);
    PageInfo<TestVO> pageInfo = new PageInfo<>(pageTestList);

    以下是实现的简单例子,总结方便自己回顾,也希望可以给其他同学提供一点儿思路

    要展示的信息的实体类:

    class TeacherAndStudent {
    
        private Integer id;
        //姓名
        private String name;
    
        //上级ID
        private Integer superiorId;
    
        //等级 1校长 2主任 3教师 4学生
        private Integer level;
    
        private List<TeacherAndStudent> junior;
    
        public TeacherAndStudent(Integer id, String name, Integer superiorId, Integer level) 
        {
            this.id = id;
            this.name = name;
            this.superiorId = superiorId;
            this.level = level;
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getSuperiorId() {
            return superiorId;
        }
    
        public void setSuperiorId(Integer superiorId) {
            this.superiorId = superiorId;
        }
    
        public Integer getLevel() {
            return level;
        }
    
        public void setLevel(Integer level) {
            this.level = level;
        }
    
        public List<TeacherAndStudent> getJunior() {
            return junior;
        }
    
        public void setJunior(List<TeacherAndStudent> junior) {
            this.junior = junior;
        }
    
        @Override
        public String toString() {
            return "TeacherAndStudent{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", superiorId=" + superiorId +
                    ", level=" + level +
                    ", junior=" + junior +
                    '}';
        }
    }

    分页信息实体类(可以直接从网上扒):

    class PageInfo<T> implements Serializable {
        private static final long serialVersionUID = 1L;
        //当前页
        private int pageNum;
        //每页的数量
        private int pageSize;
        //总记录数
        private long total;
        //总页数
        private int pages;
        //结果集
        private List<T> list;
        //是否为第一页
        private boolean isFirstPage = false;
        //是否为最后一页
        private boolean isLastPage = false;
    
    
        public PageInfo() {
        }
    
        /**
         * 包装Page对象
         *
         * @param list
         */
        public PageInfo(List<T> list) {
            if (list instanceof Page) {
                Page page = (Page) list;
                this.pageNum = page.getPageNum();
                this.pageSize = page.getPageSize();
    
                this.pages = page.getPages();
                this.list = page;
                this.total = page.getTotal();
            } else if (list instanceof Collection) {
                this.pageNum = 1;
                this.pageSize = list.size();
    
                this.pages = 1;
                this.list = list;
                this.total = list.size();
            }
            if (list instanceof Collection) {
                //判断页面边界
                judgePageBoudary();
            }
        }
    
        /**
         * 判定页面边界
         */
        private void judgePageBoudary() {
            isFirstPage = pageNum == 1;
            isLastPage = pageNum == pages;
        }
    
        public int getPageNum() {
            return pageNum;
        }
    
        public void setPageNum(int pageNum) {
            this.pageNum = pageNum;
        }
    
        public int getPageSize() {
            return pageSize;
        }
    
        public void setPageSize(int pageSize) {
            this.pageSize = pageSize;
        }
    
        public long getTotal() {
            return total;
        }
    
        public void setTotal(long total) {
            this.total = total;
        }
    
        public int getPages() {
            return pages;
        }
    
        public void setPages(int pages) {
            this.pages = pages;
        }
    
        public List<T> getList() {
            return list;
        }
    
        public void setList(List<T> list) {
            this.list = list;
        }
    
        public boolean isIsFirstPage() {
            return isFirstPage;
        }
    
        public void setIsFirstPage(boolean isFirstPage) {
            this.isFirstPage = isFirstPage;
        }
    
        public boolean isIsLastPage() {
            return isLastPage;
        }
    
        public void setIsLastPage(boolean isLastPage) {
            this.isLastPage = isLastPage;
        }
    
        @Override
        public String toString() {
            final StringBuffer sb = new StringBuffer("PageInfo{");
            sb.append("pageNum=").append(pageNum);
            sb.append(", pageSize=").append(pageSize);
            sb.append(", total=").append(total);
            sb.append(", pages=").append(pages);
            sb.append(", list=").append(list);
            sb.append(", isFirstPage=").append(isFirstPage);
            sb.append(", isLastPage=").append(isLastPage);
            sb.append(", navigatepageNums=");
            sb.append('}');
            return sb.toString();
        }
    }

    递归核心函数:

    private static List<TeacherAndStudent> treeList(List<TeacherAndStudent> list, Integer rootId) {
            List <TeacherAndStudent> newList = new ArrayList<>();
    
            for (TeacherAndStudent teacherAndStudentTemp : list) {
                if(teacherAndStudentTemp.getSuperiorId() == rootId.intValue()) {
                    List<TeacherAndStudent> tempList = treeList(list, teacherAndStudentTemp.getId());
                    teacherAndStudentTemp.setJunior(tempList);
                    newList.add(teacherAndStudentTemp);
                }
            }
    
            return newList;
        }

    主函数以及简单的分页参数:

    public static void main(String[] args) {
            List<TeacherAndStudent> list = new ArrayList<>();
    
            list.add(new TeacherAndStudent(1, "赵校长", 0,1));
    
            list.add(new TeacherAndStudent(2, "赵主任", 1,2));
            list.add(new TeacherAndStudent(3, "钱主任", 1,2));
    
            list.add(new TeacherAndStudent(4, "赵老师", 2,3));
            list.add(new TeacherAndStudent(5, "钱老师", 2,3));
            list.add(new TeacherAndStudent(6, "孙老师", 2,3));
            list.add(new TeacherAndStudent(7, "李老师", 2,3));
            list.add(new TeacherAndStudent(8, "周老师", 3,3));
            list.add(new TeacherAndStudent(9, "吴老师", 3,3));
    
            list.add(new TeacherAndStudent(10, "赵同学", 4,4));
            list.add(new TeacherAndStudent(11, "钱同学", 4,4));
            list.add(new TeacherAndStudent(12, "孙同学", 4,4));
            list.add(new TeacherAndStudent(13, "李同学", 5,4));
    
            list.add(new TeacherAndStudent(14, "周同学", 5,4));
            list.add(new TeacherAndStudent(15, "吴同学", 6,4));
    
            List<TeacherAndStudent> newList = treeList(list, 1);
    
            System.out.println(newList);
    
            int pageSize = 10;
            int pageNo = 1;
    
            int totalCount = newList.size();
            int pages = totalCount / pageSize + (totalCount % pageSize == 0 ? 0 : 1);
    
            int fromIndex = (pageNo - 1 < 0 ? 0 : (pageNo - 1)) * pageSize;
            int toIndex = pageSize * pageNo > totalCount ? totalCount : (pageSize * pageNo);
    
            boolean isFirstPage = pageNo == 1;
            boolean isLastPage = pageNo == pages;
    
            PageInfo<TeacherAndStudent> pageHelperResult = new PageInfo<>();
            pageHelperResult.setList(newList.subList(fromIndex, toIndex));
            pageHelperResult.setPageNum(pageNo);
            pageHelperResult.setPageSize(pageSize);
            pageHelperResult.setTotal(totalCount);
            pageHelperResult.setPages(pages);
            pageHelperResult.setIsFirstPage(isFirstPage);
            pageHelperResult.setIsLastPage(isLastPage);
    
        }

    递归查询的结果如下(未分页):

    如果大家有更好的思路和方法欢迎评论,我们共同学习,共同进步。

    参考资料:

    java递归获取某个父节点下面的所有子节点 : https://blog.csdn.net/tomcat_2014/article/details/51113961

    java递归查询公司下所有部门及子部门 : https://blog.csdn.net/u014079773/article/details/53338116

    java中对list进行分页显示数据到页面 : https://blog.csdn.net/Tang_Mr/article/details/76212184

    java.util.List接口的方法subList()进行分页 : https://blog.csdn.net/lululove19870526/article/details/46742515

    ArrayList的subList方法: https://www.cnblogs.com/ljdblog/p/6251387.html  

    展开全文
  • 今天小编就为大家分享一篇Python递归调用实现数字累加的代码,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • C语言简单递归求阶乘代码示例

    千次阅读 2020-11-05 19:59:16
    系列文章目录 提示:这里可以添加系列文章的所有文章的目录,目录需要自己手动添加 例如:第一章 Python 机器学习入门之pandas的使用 提示:写完文章后,目录可以自动生成,如何生成可参考右边的帮助.../*递归求...

     


    前言

    递归是一种很重要的算法,特别时对于初学算法人员来说!


     

    一、递归求阶乘

    递归本质也是一种循环!

    二、代码内容

    1.代码示例

    /*递归求阶乘*/
    #include<stdio.h>
    int fun(long long m)
    {
    	if(m==1)
    	{
    		return 1;
    	}
    	else
    	{
    		return m*fun(m-1);
    	}
    }
    int main()
    {
    	long long int m;
    	printf("Input Your Number:\n"); 
    	scanf("%d",&m);
    	printf("The End:%d",fun(m));
    	return 0;
    }
     

    2.最后结果

     

     


     

    展开全文
  • 递归是一种常见的编程技巧,实名递归相信大家都不陌生,但如果想要实现匿名递归呢?比如想要返回一个匿名递归函数,又或者是定义一个匿名递归函数并直接调用它,该怎样去...函数还可以赋给一个变量,不过要实现递归,函
  • 递归应用C语言实现

    2018-02-09 10:16:44
    包含多个经典的递归应用代码: 1.fibonacci.c 是斐波拉契数列递归解法 2.hanoi.c 是汉诺塔递归算法 3.permutation.c 是全排列递归算法 4.queen.c 是八皇后递归算法 5. reverse.c 是递归的测试代码 6.strlrn.c 是求...
  • 这也就是说函数调用出现在调用者函数的尾部,因为是尾部,所以其有一个优越于传统递归之处在于无需去保存任何局部变量,从内存消耗上,实现节约特性。 下面以递归计算加法的实例来说明: 我们用
  • 通过一段简短的代码实现了ThinkPHP实现递归无级分类,,需要的朋友可以参考下
  • 主要介绍了JAVA用递归实现全排列算法的相关资料,文中示例代码非常详细,帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • js代码-递归实现n的阶乘
  • java代码-递归实现组合数选取
  • 本文实例讲述了JS尾递归实现方法及代码优化技巧。分享给大家供大家参考,具体如下: 在学习数据结构和算法的时候,我们都知道所有的递归都是可以优化成栈+循环的。 对于特定的递归函数,一般我们都是手动对它们...
  • 采用直接改写法,不理解左递归消除方法很难读懂代码。 要求 CFG文法判断 左递归的类型 消除直接左递归和间接左递归 界面 源码 import os import tkinter as tk import tkinter.messagebox import tkinter.f
  • 主要介绍了JavaScript实现无限级递归树的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 最近不少面试问到格雷码的递归问题,写了个用递归方式实现格N位雷码的产生于输出,程序代码量很少,可以直接运行。可以下载看看。
  • 对于二叉树,有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义,因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法,就要采用栈去模拟实现
  • 主要介绍了Java递归方法求5!的实现代码,需要的朋友可以参考下
  • C# 实现阶乘 (递归,非递归) 实现代码,需要的朋友可以参考一下
  • 递归算法及经典递归例子代码实现

    万次阅读 2018-11-09 09:08:55
    作者:ikownyou  ...一、什么叫做递归? 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法; 递归函数就是直接或间接调用自身的函数,也就是自身调用自己; 二、一般什么时候使用递归?  ...

    作者:ikownyou 
    来源:CSDN 
    原文:https://blog.csdn.net/ikownyou/article/details/65633581 
    版权声明:本文为博主原创文章,转载请附上博文链接!

    一、什么叫做递归?

    一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法;

    递归函数就是直接或间接调用自身的函数,也就是自身调用自己;

    二、一般什么时候使用递归?

       递归时常用的编程技术,其基本思想就是“自己调用自己”,一个使用递归技术的方法即是直接或间接的调用自身的方法。递归方法实际上体现了“以此类推”、“用同样的步骤重复”这样的思想,它可以用简单的程序来解决某些复杂的计算问题,但是运算量较大。
        还有些数据结构如二叉树,结构本身固有递归特性;此外,有一类问题,其本身没有明显的递归结构,但用递归程序求解比其他方法更容易编写程序,如八皇后问题、汉诺塔问题等。

        正因为递归程序的普遍性,我们应该学会使用递归来求解问题。直接递归程序与间接递归中都要实现当前层调用下一层时的参数传递,并取得下一层所返回的结果,并向上一层调用返回当前层的结果。至于各层调用中现场的保存与恢复,均由程序自动实现,不需要人工干预。因此,在递归程序的设计中关键是找出调用所需要的参数、返回的结果及递归调用结束的条件。

    三、实例
    1.递归求和1+2+3+.....+n

    public static Integer recursionSum(Integer n){
       if(n>0){
          return n+recursionSum(n-1);
       }else{
          return 0;
       }
    }
    2.递归阶乘n! = n * (n-1) * (n-2) * ...* 1(n>0)

    public static Integer recursionMulity(Integer n){
       if(n==1){
          return 1;
       }
       return n*recursionMulity(n-1);
    }
    3.河内塔问题


    4.判定一系列字符串中是否有相同的内容


    public static boolean fun(int n,String[] a){
       boolean b = false;
       if(n == a.length){
          b = true;
       }else{
          for(int i = n; i < a.length-1; i++){
             System.out.println(n+"    "+(i+1));
             if(a[n].equals(a[i+1])){
                return false;
             }
          }
          n++;
          fun(n,a);
       }
       return b;
    }
    --------------------- 

    常见的例子就先介绍到这儿, 还是需要大家平时在工作中多多去实践, 多多去体会, 方可达到融会贯通, 举一反三的效果, 程序源于生活, 却有高于生活!

    展开全文
  • C 二分查找 递归与非递归实现代码,需要的朋友可以参考一下
  • 以下是对归并排序的递归实现与非递归实现代码进行了详细的介绍,需要的朋友可以过来参考下
  • 使用递归实现快速排序(Java实现)

    千次阅读 2018-10-13 19:58:47
    使用递归实现快速排序(Java实现) 1.先确定一个key值(也就是参考值),初状态定义如下 2.实现key的左边都是小于key的值,右边都是大于key的值 int key = arr[start];//防止访问溢出 while(start &amp;lt; end...

    使用递归实现快速排序(Java实现)

    一、

    1.先确定一个key值(也就是参考值),初状态定义如下
    在这里插入图片描述
    2.实现key的左边都是小于key的值,右边都是大于key的值

     int key = arr[start];//防止访问溢出
                while(start < end){
                    for(; end > start; end--){
                        if(arr[end] < key){
                            arr[start] = arr[end];
                            start++;
                            break;
                        }
                            
                    }
                    for(; start < end; start++){
                        if(arr[start] > key){
                            arr[end] = arr[start];
                            end--;
                            break;
                        }
                            
                    }
                    arr[start] = key;
                }
    

    3.用递归实现左右排序

     QuickSort(arr,copyStart,start);//左递归
     QuickSort(arr,start+1,copyEnd);//右递归
    

    完整程序

    public class Test{
    
        public static void main(String[] args){
            int[] arr = new int[]{3,5,6,1,2,8,9,3};
            for(int i = 0; i < arr.length; i++){
                System.out.print(arr[i]+"  ");
            }
                System.out.print("\n");
            QuickSort(arr,0,arr.length);
    
            for(int i = 0; i < arr.length; i++){
                System.out.print(arr[i]+"  ");
            }
        } 
        public static void QuickSort(int arr[],int start,int sz){
            int end = sz - 1;
            int copyEnd = sz;
            int copyStart = start;
            if(end > start){
                int key = arr[start];//防止访问溢出
                while(start < end){
                    for(; end > start; end--){
                        if(arr[end] < key){
                            arr[start] = arr[end];
                            start++;
                            break;
                        }
                            
                    }
                    for(; start < end; start++){
                        if(arr[start] > key){
                            arr[end] = arr[start];
                            end--;
                            break;
                        }
                            
                    }
                    arr[start] = key;
                }
                QuickSort(arr,copyStart,start);//左递归
                QuickSort(arr,start+1,copyEnd);//右递归
            }
    
        }
    
    
    }
    
    二、
    public class Test {
        private static int Partition(int[] arr, int start, int end) {
            int key = arr[start];
            while (start < end) {
                while (arr[end] >= key && end > start)
                    end--;
                arr[start] = arr[end];
                while (arr[start] <= key && end > start)
                    start++;
                arr[end] = arr[start];
            }
            arr[start] = key;
            return start;
        }
        public static void quickSort(int[] arr, int start, int end) {
            if (start < end) {
                int index = Partition(arr, start, end);
                quickSort(arr, start, index - 1);
                quickSort(arr, index + 1, end);
            }
        }
        public static void main(String[] args) {
            int[] data = new int[]{1,3,2,9,7,4,6,8,20,17,25,21};
            quickSort(data,0,data.length-1);
            for (int temp : data) {
                System.out.print(temp+"、");
            }
        }
    }
    
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 418,669
精华内容 167,467
关键字:

代码实现递归