递归

public class Sum { public static int count(int n) { if (n > 1) { return count(n - 1) + n; } else { return n; } } public static void main(String[] args) { System.out.println(Sum.count(100)); } } 　　 来源： https://www.cnblogs.com/xieshilin/p/12244526.html

一、递归调用定义 在函数内部，可以调用其他函数。 如果在调用一个函数的过程中直接或间接调用自身本身，则称为 递归调用 从某种意义上来说，递归调用可以实现无限循环 二、递归调用的特性 必须有一个明确的结束条件 每次进入更深一层递归时，问题规模相比上次递归都应有所减少 递归效率不高，递归层次过多会导致栈溢出 在计算机中，函数调用是通过栈（stack）这种数据结构实现的 每当进入一个函数调用，栈就会加一层栈帧 每当函数返回，栈就会减一层栈帧 由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出 三、递归实例 递归调用就是一个问路的过程。通过一个程序以及其执行过程来更好的理解递归调用 1 import time 2 person_list = ['Rachel', 'Monica', 'Ross', 'Joey'] 3 def ask_way(person_list): 4 print('-'*60) 5 if len(person_list) == 0: 6 return '没人知道' 7 person = person_list.pop(0) 8 if person == 'Ross': 9 return '%s说:我知道,流水人家就在小桥旁' %person 10 print('hi 亲爱的%s,知道流水人家在哪里吗？' %person) 11 print('%s回答道

快速排序 快速排序使用 分治法 （Divide and conquer）策略来把一个 序列 （list）分为2个子序列，然后递归地排序两个子序列。 快速排序是一个不稳定的算法，在经过排序之后，可能会对相同值的元素的相对位置造成改变。 快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。 快速排序只是使用数组原本的空间进行排序，所以所占用的空间应该是常量级的，但是由于每次划分之后是递归调用，所以递归调用在运行的过程中会消耗一定的空间，在一般情况下的 空间复杂度 为 O(logn) ，在最差的情况下，若每次只完成了一个元素，那么空间复杂度为 O(n) 。所以我们一般认为快速排序的空间复杂度为 O(logn) 。 方法一：遍历交换法。 取一个key元素，我一般取数组的最后一个元素。定义一个指针index从头向后遍历，再定义一个指针位pre于第一个元素之前。如果index元素比key小，pre向前移动一位，交换index和key的元素，把小的放前、大的放后。index遍历到最后，将pre+1和key进行交换，这样比key小的都在它前面，比key大的都在它后面了

对于广度优先遍历，使用递归方式实现非常普遍，这里我们讨论一下如何使用非递归来实现 算法 1、以图的邻接矩阵为例 2、使用一个queue来保存访问顺序，每次取队首元素，如果其有邻接点，则将其所有邻接点入队，并设置visit数组为1，最后再将其出队 3、循环结束条件为：队列为空 代码实现 以下图为例 public class BfsIterateAdjacentMatrix { private static Map < Integer , String > idVertexMap = new HashMap < Integer , String > ( ) { { put ( 0 , "V0" ) ; put ( 1 , "V1" ) ; put ( 2 , "V2" ) ; put ( 3 , "V3" ) ; put ( 4 , "V4" ) ; put ( 5 , "V5" ) ; put ( 6 , "V6" ) ; put ( 7 , "V7" ) ; } } ; private static int [ ] [ ] adjacentMatrix = new int [ ] [ ] { //V0,V1,V2,V3,V4,V5,V6,V7 { 0 , 1 , 1 , 0 , 0 , 0 , 0 , 0 } , { 1 , 0 , 0 , 1 , 1 , 0 , 0 , 0 }

今天我们就来说说递归 白话讲：就是自己调用自己 递归：指在当前方法内调用自己的这种现象 递归的分类 递归分为两类，直接递归和间接递归 直接递归称为方法自身调用自己 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法 递归的注意事项 递归一定要有条件限定，保证递归能够停止下来，否则会发生内存溢出 在递归中虽然有限定条件，但是递归次数不能太多，否则也会发生栈内存溢出 构造方法禁止递归，为何了：因为构造方法是创建对象使用的，总不能让对象一直创建下去把。 代码演示递归 public class Demo7 { public static void main(String[] args) { digui(1); } //定义一个静态方法 private static void digui(int i){ System.out.println(i); digui(++i); } } //结果如下图所示 我们加个条件试试 public class Demo7 { public static void main(String[] args) { digui(1); } //定义一个静态方法 private static void digui(int i){ System.out.println(i); //我们来添加一个递归结束的限定条件 if(i == 5000){ return;

剑指offer一共66道题，涉及到的数据结构有：数组、字符串、链表、树、二叉树、栈、队列，常用的数据操作和算法有：循环、递归、回溯、查找、排序、动规、位运算。下面将分类记录我的刷题思路 链表 从尾部到头部打印链表 (三种方法：借助栈、递归、列表的首位插入) 用栈（后入先出）保存，然后弹出； 既然想到了用栈，那一定可以 通过递归来实现 。每访问到一个结点，先递归输出其后的结点，在输出该结点自身即可； 使用Java或者python语言时，有一种比较巧妙的方法就是使用 列表的插入 方法，每次插入数据，都总是插入到首位。 来源： https://www.cnblogs.com/lthuang/p/12242901.html

二叉树的深度优先遍历 == 前序遍历 #include <iostream> #include <stack> using namespace std; typedef struct tree { int data; struct tree *l_child; struct tree *r_child; }TreeNode; TreeNode *insertNode(TreeNode *root,int data) { if(root == NULL) { TreeNode *newNode = new TreeNode(); newNode->data = data; newNode->l_child = NULL; newNode->r_child = NULL; root = newNode; } else if(data < root->data) { root->l_child = insertNode(root->l_child,data); } else { root->r_child = insertNode(root->r_child,data); } return root; } TreeNode *createTree(void) { int index = 0; TreeNode *root = NULL; root = insertNode(root

一、递归 1.All recursive solutions must satisfy three rules or properties: （1）A recursive solution must contain a base case ； （2）A recursive solution must contain a recursive case ； （3）A recursive solution must make progress toward the base case. 2.反向打印链表： （1）brute force # Print the contents of a singly linked list in reverse order. def printListBF(head): numNodes = 0 curNode = head while curNode is not None: curNode = curNode.next numNodes += 1 for i in range(numNodes): curNode = head for j in range(numNodes - 1): curNode = curNode.next print(curNode.data) （2）基于栈 from lliststack import Stack def

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。 利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。 递归结构包括两个部分： 1.定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。 2.递归体。解答：什么时候需要调用自身方法。 递归都可以改为非递归(循环和迭代) public class TestRecursion { public static void main ( String [ ] args ) { long d1 = System . currentTimeMillis ( ) ; //返回当前毫秒总数 System . out . printf ( "%d阶乘的结果:%s%n" , 10 , factorial ( 10 ) ) ; //%n = \n long d2 = System . currentTimeMillis ( ) ; System . out . printf ( "递归费时：%s%n" , d2 - d1 ) ; //耗时：32ms factorialIterator ( 10 ) ; } /** 求阶乘的递归方法*/ static long factorial ( int n

问题描述： 给出4个小于10的正整数，可以使用+-*/()的运算将这4个数连接起来得到一个表达式。问，是否存在一种计算方式可以使表达式的结果为24。 输入： 输入多行数据，每行包括4个小于10的正整数。最后一行数据为4个0，作为数据的终止。 输出： 对于每一组数据，如果可以得到24，则输出“YES”，否则输出“NO”。 样例输入与输出： 5 5 5 1 YES 1 1 4 2 NO 0 0 0 0 问题的分析及解决： 这个问题就是我们所熟知的算24这个数学游戏。我们先跳出如果用代码实现这个问题，思考一下，当给我们4个数字时，我们是用什么方式得出是否可以计算24这个问题。大部分人所用的方法都是连拼带凑的方法得出结论的，即尝试将几个数字进行+-*/运算，拼凑出是否为24。如果将这种思想转化为算法思想，我们首先想出的便是枚举，即把数字两两计算，并且把所有的可能性都列举出来，例如：我们已知A,B,C,D这4个数字，我们先尝试A,B;A,C;A,D;B,C;B,D;C,D这6组数的+-*/，并把这6组数得出的结果与剩下的值重复进行上述的操作，直至剩余最后2个数尝试进行+-*/，看看是否能够得出24这个值，如果最终的结果为24，那么输出YES，否则输出NO。 在编写代码的过程中，我们会发现，如果用非递归的方式写代码，将会嵌套好几层for循环，且代码显得非常的冗余，所以在循环重复计算时