相关疑难解决方法(0)

正如标题所解释的那样,我有一个非常基本的编程问题,我还没有能够理解.过滤掉所有(非常聪明)"为了理解递归,你必须首先理解递归." 各种在线线程的回复我仍然没有得到它.

理解当面对不知道我们不知道的事情时,我们可能倾向于提出错误的问题或者错误地提出正确的问题我会分享我"想"我的问题,希望有类似观点的人可以分享一些一点点知识,有助于我打开递归灯泡!

这是函数(语法用Swift编写):

func sumInts(a: Int, b: Int) -> Int {
    if (a > b) {
        return 0
    } else {
        return a + sumInts(a: a + 1, b: b)
    }
}

我们将使用2和5作为我们的论点:

println(sumInts(a: 2, b: 5))

显然答案是14.但我不清楚这个价值是如何实现的.

这些是我的两个挂断:

1. 递归调用该函数直到满足条件.那个条件是a> b.满足此条件时,返回0.乍一看,我希望返回值为0,这显然是不正确的.

2. 在每次迭代中打印出'a'的值会产生一个我期望的值:2,3,4,5(此时5 + 1> b满足第一个条件:a> b)但我仍然不喜欢看看如何实现14的价值.

我的第一个想法是,类似于以下内容的东西神奇地发生:

var answer = a;
answer += a+1 until a > b;
return answer;   

所以排除了魔法,我只是没有得到什么.我很想知道发生的事情不仅仅是隐含的.

如果有人能够解释在这种功能中技术上发生了什么以及为什么结果不是0以及最终如何a + sumInts(a: a + 1, b: b) = 14,我将永远负债累累.

任何人都可以建议说明递归函数的编程示例吗？有通常的老马,如斐波纳契系列和河内塔,但除了它们之外的任何东西都会很有趣.

我正在努力找出一个有效的quicksort算法.它工作正常,但是当元素数量巨大时,需要很长时间才能运行,并且数组的某些部分是预先排序的.我正在查阅维基百科的文章,在quicksort那里我找到了这样写的:

为了确保最多使用O(log N)空间,首先递归到数组的较小一半,然后使用尾调用递归到另一个.

对于这种小阵列上的调用(即长度小于实验确定的阈值t),使用插入排序,其具有较小的常数因子并因此在小阵列上更快.这可以通过将这些数组保持未排序并在末尾运行单个插入排序传递来实现,因为插入排序有效地处理几乎排序的数组.在识别每个小段时单独插入排序会增加启动和停止许多小排序的开销,但避免浪费在多个段边界上比较密钥的工作量,由于快速排序过程的工作原因,这些密钥将按顺序排列.它还改善了缓存的使用.

我目前正在递归两个分区.知道如何实现第一个提示吗？何谓递归先入阵的小一半,并使用尾部调用递归到其他？其次,我如何insertion-sort在快速排序中实施？它是否总能提高效率,或者只有在阵列的某些部分进行预先排序时？如果是第二种情况,那么当然我无法知道何时会发生这种情况.那我insertion-sort什么时候应该包括？

我知道可以用Python这样的语言创建一个自引用列表:

>>> my_list = [1,2]
>>> my_list.append(my_list)
>>> print my_list
[1,2,[...]]
>>> print my_list[0]
1
>>> print my_list[2]
[1,2,[...]]

什么算法从自引用列表中受益？我想不出一个.

谢谢.

我发现自己需要在源树中获取python文件的父目录,该源目录树是多个目录,具有一定的规律性.不得不多次打电话给dirname是笨重的.

我环顾四周,很惊讶没有发现这个帖子.

一般情况是:

import os.path as op
third_degree_parent = op.dirname(op.dirname(op.dirname(op.realpath(__file__))))

是否有更惯用的方法来执行此操作,不需要嵌套的dirname调用？

几天前有人对我说,递归会比迭代更好,如果可能的话,应该总是使用.

所以,我进入递归并尝试编写一个简单的程序来获得一个数字的阶乘.这是递归:

def fact(n):
    if n == 1:
        return 1
    return n * fact(n - 1)

虽然这样可以正常工作,但RuntimeError: maximum recursion depth exceeded只要n达到997以上就会得到.

所以我写了一个简单的函数,完全相同,但有一个for loop.

def fact(n):
    a = 1
    for x in range (0, n, 1):
        a = a * (n - x)
    return a

而n < 10000它在150毫秒内给出答案.

所以,我虽然可能递归速度较快,但数字较少,但不是.这需要更长时间:

所以我的问题是:
在Python中编写程序时是否有任何理由使用递归？
并且:
有任何问题只能通过递归来解决吗？

我试图得到嵌套JS对象中的键的计数.我能够达到第一级,但我有点陷入困境,我会如何深入挖掘嵌套对象并返回计数.

var properties = {
prop1: '',
prop2: '',
prop3: '',
prop4: {
    subProp1: '',
    subProp2: '',
    subProp3: {
        subSubprop1: ''
        }
    }
}

var getCount = function (data) {
var count = 0;
for (var k in data) {
    if (properties.hasOwnProperty(k)) {
        ++count;
    }
}
console.log( "this is the count for level 0: " + count //returns 4);
console.log( "this is the count for level 1: " + count //should return 3);
console.log( "this is the count for level …

我很确定我完全理解只有一个递归的方法是如何工作的。

Ex) 计算阶乘

public int factorial(int n){  //factorial recursion
    if(n==0){
        return 1;
    }
    else{
        return n*factorial(n-1);
    }
} 

对于这些方法，我什至可以想象堆栈中发生了什么以及在每个堆栈级别返回了什么值。

但是每当我遇到双重递归的方法时，噩梦就开始了。

下面是来自编码蝙蝠的双重递归的递归问题。

例如）给定一个整数数组，是否可以选择一组整数，使得该组和给定的目标相加？如果是，则为真。如果没有，则为假。您使用 3 个参数；起始索引start，一个 int Array nums，目标 int 值目标。

下面是这个问题的解决方案。

public boolean groupSum(int start, int[] nums, int target) {
    if (start >= nums.length) return (target == 0);
    if (groupSum(start + 1, nums, target - nums[start])) return true;
    if (groupSum(start + 1, nums, target)) return true;
    return false;
}

我对这个解决方案的理解是这样的。假设我得到了一个数组 {2,4,8}，起始索引 = 0，目标值为 10。所以 …

这是一个涉及更复杂的比较方式的问题,因此它不是重复的

我创建了一个JqTree,当用户更改其树结构时,应该比较"旧" JSON和"新" JSON结构,并且应该仅显示JSON已更改的值.

例如:

[{"name":"node1","id":1,"is_open":true,"children":
    [
      {"name":"child1","id":2},
      {"name":"child2","id":3}
    ]
}]

之后,客户端已经把child1下child2

[{"name":"node1","id":1,"is_open":true,"children":
  [
    {"name":"child2","id":3},
    {"name":"child1","id":2}
  ]
}]

我只想比较它们并检查哪些值已更改并用a显示它们alert,在这种情况下,它将是:

{"name":"child2","id":3},
{"name":"child1","id":2}

到目前为止,我有这个比较它们的小代码:

JSON.stringify(object1)=== JSON.stringify(object2); //我知道它不太可靠

但我正在寻找能够检查"差异"并从JSON中提取它的东西.

提前致谢.

这个功能有什么作用？你如何评价它？

如何追踪它？如何理解递归方法？

我只是无法理解递归,考试日期即将到来,我知道为了理解递归,我必须先了解递归.

但我只是不能写一个稍微复杂的递归方法,任何人都可以帮我使用最简单的英文单词.

public class BalancedStrings {

    public static void printBalanced(String prefix, int a, int b) {
        if (a > 0)
            printBalanced(prefix + "a", a - 1, b);
        if (b > 0)
            printBalanced(prefix + "b", a, b - 1);
        if (a == 0 && b == 0)
            System.out.println(prefix);
    }

    public static void printBalanced(int n) {
        if (n % 2 == 0) {
            printBalanced("", n / 2, n / 2);
        }
    }

    public static void main(String[] args) {
        printBalanced(4);
    } …