Haskell 对象排序是如何工作的？

首先，我应该说我从未见过任何Haskell代码。现在我有一个算法，我必须用另一种语言实现。不幸的是，这个算法依赖于Haskell的一些特性和特性，所以我想请您提供帮助，如何才能正确地实现它

代码如下：

data Utree = Tree[Utree]

instance Eq Utree where
    Tree(p) == Tree(q) = p == q
instance Ord Utree where
    Tree(p) <= Tree(q) = p <= q

norm(Tree(p)) = Tree(sort(map norm p))


iso p q = (norm p) == (norm q)

sort[] = []
sort(a:x) = ins a (sort x)

ins a [] = [a]
ins a (b:x)
   | a <= b = a:b:x
   | a > b = b:(ins a x)

data Utree=Tree[Utree]
实例Eq Utree在哪里
树（p）==树（q）=p==q
例如，奥德乌特瑞在哪里
树（p）utree通过比较它们的元素列表进行比较，这是从实例定义中可以看到的。
列表通常通过成对比较其元素来进行比较。例如，列表的==的实现如下所示：

[] == [] = True
(a:as) == (b:bs) = a == b && as == bs
_ == _ = False

         *               *
a =     / \        b =  / \
       x   *           x   *
          /           /
         *           *

关于Eq和Ord类的所有信息都可以在相关的Haskell报告中找到，我相信你手头有

列表的比较函数可能如下所示（实际上，它有点不同，但这与此处无关）：

[]>\uU9=False——空列表不大于任何其他列表
（a:as）>[]=True——非空大于空
（a:as）>（b:bs）
|ab=True
|否则=as>bs
utree通过比较它们的元素列表来进行比较，这是从实例定义中可以看到的。
列表通常通过成对比较其元素来进行比较。例如，列表的==的实现如下所示：

[] == [] = True
(a:as) == (b:bs) = a == b && as == bs
_ == _ = False

         *               *
a =     / \        b =  / \
       x   *           x   *
          /           /
         *           *

关于Eq和Ord类的所有信息都可以在相关的Haskell报告中找到，我相信你手头有

列表的比较函数可能如下所示（实际上，它有点不同，但这与此处无关）：

[]>\uU9=False——空列表不大于任何其他列表
（a:as）>[]=True——非空大于空
（a:as）>（b:bs）
|ab=True
|否则=as>bs
您的代码给出了比较两棵树的定义。例如，为了平等：

instance Eq Utree where
    Tree(p) == Tree(q) = p == q

它说两棵树的相等等于它们的子树列表的相等。所以在这个代码中，
p
和
q
是列表。列表上的相等在Haskell中是预先定义的，因为如果两棵树的长度相同且元素成对相等，则它们是相等的。由于
p
和
q
的元素是树，因此递归调用树上的相等比较

直观地说，这意味着如果两棵树的形状相同，它们是相等的

类似地，根据子树列表的顺序定义两棵树的顺序

instance Ord Utree where
    Tree(p) <= Tree(q) = p <= q

本例中的树如下所示：

[] == [] = True
(a:as) == (b:bs) = a == b && as == bs
_ == _ = False

         *               *
a =     / \        b =  / \
       x   *           x   *
          /           /
         *           *

所以
a
比
b
小，因为当我们看它们最左边的不同点时，
x
，
a
有一个空的子树，而
b
有一个节点。
您的代码给出了比较两棵树的定义。例如，为了平等：

instance Eq Utree where
    Tree(p) == Tree(q) = p == q

它说两棵树的相等等于它们的子树列表的相等。所以在这个代码中，
p
和
q
是列表。列表上的相等在Haskell中是预先定义的，因为如果两棵树的长度相同且元素成对相等，则它们是相等的。由于
p
和
q
的元素是树，因此递归调用树上的相等比较

直观地说，这意味着如果两棵树的形状相同，它们是相等的

类似地，根据子树列表的顺序定义两棵树的顺序

instance Ord Utree where
    Tree(p) <= Tree(q) = p <= q

本例中的树如下所示：

[] == [] = True
(a:as) == (b:bs) = a == b && as == bs
_ == _ = False

         *               *
a =     / \        b =  / \
       x   *           x   *
          /           /
         *           *

所以
a
比
b
小，因为当我们看它们最左边的不同点时，
x
，
a
有一个空的子树，而
b
有一个节点。
谢谢你的回复。我理解你的文字，但不理解代码。因此，通过子树列表对树进行比较。这是清楚的。但这对订购意味着什么呢？请问哪棵树比另一棵树大？如果a中包含的列表大于b中包含的列表，则树a大于树b。例如，Tree[Tree[]]>Tree[]它仍然不够清晰。空树是平等的。这是基本信息。但是，如果一棵树的根有两片直接的叶子，而另一棵树的根有一片叶子，那么哪棵树更大呢。这两棵树都有3个节点。列表在词汇上是相似的。例如“Z”>“Abc”。我将添加示例代码。+1作为一种努力，但正如我所说，我不能Haskell，所以这些示例对我来说是不可理解的。谢谢回复。我理解你的文字，但不理解代码。因此，通过子树列表对树进行比较。这是清楚的。但这对订购意味着什么呢？请问哪棵树比另一棵树大？如果a中包含的列表大于b中包含的列表，则树a大于树b。例如，Tree[Tree[]]>Tree[]它仍然不够清晰。空树是平等的。这是基本信息。但是，如果一棵树的根有两片直接的叶子，而另一棵树的根有一片叶子，那么哪棵树更大呢。这两棵树都有3个节点。列表在词汇上是相似的。例如“Z”>“Abc”。我将添加示例代码。+1以供参考，但正如我所说的，我无法理解Haskell，因此我无法理解这些示例。