Algorithm 确定Treeview中的最小更改

我有一个树状视图，用户可以在其中移动、删除子树、节点和创建节点

我不想一次保存每一个操作，但用户可以说应用我的更改。因此，我需要将新树与旧树进行比较，最重要的是，确定构建新树的最小操作集。解决这个问题的方法是什么

我使用的是ASP.NET/C，但这个问题与这项技术并不紧密相关

---

谢谢

正如斯维克所说，最好的选择是记录所有更改，并在用户单击“应用”按钮时应用它们

唯一可以改进的是，当用户进行更改时，您可以在记录中检查是否存在被此新更改否定的更改。在这种情况下，可以删除一个或多个条目。 我能想到的例子有

第二次移动节点会抵消第一次移动 删除最近创建的节点，反之亦然。在这种情况下，还应删除新记录条目。 删除一个节点并创建另一个节点或大小相等的子树可以替换为移动

---

这并不能以最少的记录条目提供最佳解决方案，但其目标可能是加速应用更改，这已经实现。您可以检测其他类型的操作序列，这些操作可以简化，但这可能不值得。检测如此复杂的操作序列可能成本太高而无益

有两种方法可以解决您的问题。您可以缓存所有用户的编辑操作，然后在批更新中应用它们。这解决了您的目标中不同时出现的问题

---

如果您想用一组优化的操作来替换用户操作，这些操作可以为某些优化定义生成相同的结果，那么这通常是一个非常难解决的问题。我相信，最著名的算法是基于一种叫做树间编辑距离的东西，在一个。请注意，这是非常密集的阅读。有一篇可读性更高的文章，介绍如何找到将一个XML文档更改为另一个XML文档的最佳编辑脚本。它的基础是首先将XML转换为树并对其进行处理，因此核心算法可能直接适用于您的问题。它甚至还附带了伪代码。

好吧，我认为整合操作是最好的选择，在我的情况下，我想不出会产生非最佳解决方案的场景。如果有人真的感兴趣，我已经在这里分享了我的整合代码：

 public class TreeOperationConsolidator : ITreeOperationConsolidator
{
    public IEnumerable<ITreeOperation> ConsolidateOperations(IEnumerable<ITreeOperation> operations)
    {
        List<ITreeOperation> result = new List<ITreeOperation>();
        foreach (var op in operations)
        {
            if (op.Operation == OperationType.Move)
            {
                ConsolidateMoveOperation(op, operations, result);
            }
            else if (op.Operation == OperationType.Rename)
            {
                ConsolidateRenameOperation(op, operations, result);
            }
            else if (op.Operation == OperationType.Create)
            {
                ConsolidateCreateOperation(op, operations, result);
            }
            else if (op.Operation == OperationType.Delete)
            {
                ConsolidateDeleteOperation(op, operations, result);
            }
        }
        return result;
    }

    private void ConsolidateDeleteOperation(ITreeOperation op, IEnumerable<ITreeOperation> operations, List<ITreeOperation> result)
    {
        bool newlyCreated = result.Any(o => o.SourceId == op.SourceId && o.Operation == OperationType.Create);

        result.RemoveAll(o => o.SourceId == op.SourceId);

        var children = (from o in result
                        where
                            (o.Operation == OperationType.Move && o.DestId == op.SourceId)
                            || (o.Operation == OperationType.Create && o.DestId == op.SourceId)
                        select o).ToList();

        foreach (var child in children)
        {
            result.Remove(child);
            ConsolidateDeleteOperation(new TreeOperation { Operation = OperationType.Temp, SourceId = child.SourceId }, operations, result);
        }

        if (newlyCreated == false && op.Operation != OperationType.Temp)
            result.Add(op);
    }

    private void ConsolidateCreateOperation(ITreeOperation op, IEnumerable<ITreeOperation> operations, List<ITreeOperation> result)
    {
        result.Add(op);
    }

    private void ConsolidateRenameOperation(ITreeOperation op, IEnumerable<ITreeOperation> operations, List<ITreeOperation> result)
    {
        var createOperation = result.FirstOrDefault(o => o.SourceId == op.SourceId && o.Operation == OperationType.Create);
        if (createOperation == null)
        {
            var renameOp = result.FirstOrDefault(o => o.SourceId == op.SourceId && o.Operation == op.Operation);
            if (renameOp != null)
            {
                result.Remove(renameOp);
            }
            result.Add(op);
        }
        else
        {
            createOperation.Argument = op.Argument;
        }
    }

    protected void ConsolidateMoveOperation(ITreeOperation op, IEnumerable<ITreeOperation> operations, List<ITreeOperation> result)
    {
        var createOperation = result.FirstOrDefault(o => o.SourceId == op.SourceId && o.Operation == OperationType.Create);
        if (createOperation == null)
        {
            var moveOp = result.FirstOrDefault(o => o.SourceId == op.SourceId && o.Operation == op.Operation);
            if (moveOp != null)
            {
                result.Remove(moveOp);
            }
            result.Add(op);
        }
        else
        {
            createOperation.DestId = op.DestId;
        }
    }
}

public class TreeOperation : ITreeOperation
{
    public string Argument { get; set; }

    public OperationType Operation { get; set; }

    public string SourceId { get; set; }

    public string DestId { get; set; }
}

public enum OperationType
{
    Move,
    Rename,
    Create,
    Delete,
    Temp
}

public interface ITreeOperationConsolidator
{
    IEnumerable<ITreeOperation> ConsolidateOperations(IEnumerable<ITreeOperation> operations);
}

public interface ITreeOperation
{
    string Argument { get; set; }

    OperationType Operation { get; set; }

    string SourceId { get; set; }

    string DestId { get; set; }
}

---

因此，您需要做的是跟踪树中的所有用户操作，即在会话或其他地方保存ITreeOperation的实例。在应用所有更改之前，请确保调用IEnumerable ConsolidateOperations IEnumerable operations。

您不能只记录用户所做的更改，然后一次保存这些更改吗？当然，我可以点画，但我希望防止不必要的更改，例如，用户只是在树中玩而已