Question

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

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

我正在使用ASP.NET / C＃，但问题并不是那种技术真的很紧张。

谢谢

Answer 1

像svick所说，最好的选择是记录所有更改并在用户单击“应用”按钮时应用它们。

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

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

这不提供记录条目数量最少的最佳解决方案，但可能的目标是加快应用所做的更改。您可以检测到可以简化的其他类型的操作序列，但这可能不值得。检测这种复杂的操作序列可能成本太高而无益。

Answer 2

您的问题有两种解决方法。您可以只缓存所有用户的编辑操作，然后在批量更新中应用它们。这解决了目标中“不是一次”的部分。

如果您想用一组产生相同结果的最佳动作替换用户动作（对于某些“最佳”定义），这通常是一个非常难以解决的问题。我相信，最着名的算法是基于称为“树之间的编辑距离”的东西，并在technical report by Zhang and Shasha中描述。请注意，这是非常密集的阅读。有一篇更具可读性的文章here，用于查找将一个XML文档更改为另一个XML文档的最佳编辑脚本。它基于首先将XML转换为树并进行处理，因此核心算法可能直接适用于您的问题。它甚至带有伪代码。

Answer 3

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

 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<ITreeOperation> ConsolidateOperations(IEnumerable<ITreeOperation> operations)。

确定Treeview中的最小更改

3 个答案: