标签: recursive-datastructures

如果在ML中,递归数据类型的示例是:

datatype llist = Nil | Node of int * llist

什么是相互递归的数据类型,在ML中是什么样的？

当父对象执行时,作为另一个对象的成员的对象是否有资格进行垃圾收集？例如,让我们想象一下这种情况:

MyClass_1的代码:

public class MyClass_1 {

    // Member object
    private MyClass_2 myClass_2;

    // Getter
    public MyClass_2 getMyClass_2() {
        return this.myClass_2;
    }

    // Setter
    public void setMyClass_2(MyClass_2 myClass_2) {
        this.myClass_2 = myClass_2;
    }
}

MyClass_2的代码:

public class MyClass_2 {

    // Member object
    private MyClass_3 myClass_3;

    // Getter
    public MyClass_3 getMyClass_3() {
        return this.myClass_3;
    }

    // Setter
    public void setMyClass_3(MyClass_3 myClass_3) {
        this.myClass_3 = myClass_3;
    }
}

好的,现在我们做(MyClass_3的代码不相关):

// Instantiation of one root object
MyClass_1 object_1 = new MyClass_1();

// Composition of …

public void length() {
    System.out.println(length(head, 0));
}
public int length(Node he, int count) {
    if(he!=null) {
        // System.out.println(he.data +"   "+count++);
        // count++;
        // return length(he.next, count);
        return length(he.next, count++);
    }
    return count;
}

在上面的代码中,我必须找到链表的长度.如果我运行相同的代码,我得到的长度为0.但是,当我使用注释代码,我得到正确的长度.为什么会这样？

（这不是一个特别的Haskell问题。）

我有一个递归数据结构。我想在每个级别附加一些额外的信息。这是一个简化的示例，其中我在树的每个级别上添加X或Y：

import Data.Functor.Foldable

data Wrap a = X a | Y a
  deriving Show

data TreeF a b = Leaf a | TreeF a b b
  deriving Show

depth1 :: Wrap (TreeF Int ())
depth1 = X (Leaf 1)

depth2 :: Wrap (TreeF Int (Wrap (TreeF Int ())))
depth2 = Y (TreeF 1 (X $ Leaf 1) (Y $ Leaf 1))

-- depthInfinity :: Fix something something ...

（TreeF对我来说，定义是不自然的。我宁愿定义data Tree a = …

目的是使用Scala集合,其中不需要迭代或递归计算大小.

例如,List证明是递归构造(例如考虑/sf/answers/573847851/),并且为了获得大小,有必要迭代它; 即O(N)对列表中元素数量的操作.

那么要问这个操作是哪个集合O(1)？非常感谢.

我试图在JS中学习递归函数但由于某种原因结果未定义我想分别警告(4,3,2,1,0).

function someFun(number) {
  if (number < 0) {
    return 1;
  } 
  else {
    alert(number = someFun(number - 1))
  }
}
someFun(4)

我已经按照指南创建了一个使用以下数据类型的二叉搜索树:

data BinarySearchTree a = EmptyTree | TreeNode a (BinarySearchTree a) (BinarySearchTree a) deriving (Show, Read, Eq)

我是否正确地说'TreeNode'正在使用递归,即创建自己数据类型的2个元素'(BinarySearchTree a)(BinarySearchTree a)'？

我从来没有见过像这样的数据类型,任何简短的解释都会很棒!

我想为Show以下类型的列表编写一个实例：

newtype Mu f = Mu (forall a. (f a -> a) -> a)
data ListF a r = Nil | Cons a r deriving (Show)
type List a = Mu (ListF a)

模块Data.Functor.Foldable定义了它，但将其转换为Fix，我想避免这种情况。

如何定义该Show实例？

我已经为自然数字构建了自己的数据类型.

data Natural = Zero | Succ Natural 
instance Show Natural where 
         show (Zero) = "0"
         show (Succ Zero) = "S 0"
         show (Succ n) = "S(" ++ show n ++ ")"

我正在尝试创建一个函数来与基本数据类型(主要是Int)进行交互,如下所示:

intToNat:: Int -> Natural
intToNat 0 = Zero
intToNat n = (Succ n) - 1

natToInt:: Natural -> Int
natToInt Zero = 0
natToInt (Succ n) = 1 + natToInt n

嗯,这根本不起作用,问题是,我必须将此函数保持为递归函数.我不知道这个read功能是否有用.

更新:代码编译方式的方式是在函数中使用:

intToNat:: Int -> Natural
intToNat 0 = Zero
intToNat n = …