3

我正在研究一种可以解决我遇到的问题的算法，但我发现自己有点卡住了。这是场景：

我有一个对象，其中包含一个名为 order 的变量。

public class Item
{
     public int Order{get; set;};

     public int ID{get; set;}; // not incremented can be any value!
}

所以我有一个清单：

List<Item> list = new List<Item>().OrderBy((o) => o.Order);

并且可以随时更改订单值。因此，如果我想更改第一个项目订单值，则所有其他订单值都应相应更新，以免重复。

for (int i = 0; i <= list .Count - 1; i++)
{
    if (list [i].ID == inputID)
    {
        list [i].Order = inputNewPosition;
    }
    else
    {
        if (list [i].Order < inputNewPosition)
        {
            list [i].Order --;
        }
        else
        {
             list [i].Order ++;
        }
    }
}

如果我将最后一个项目订单更改为第一个，这将失败，因为这会使第一个项目订单为 0！

任何人都可以帮忙吗？

谢谢

4

3 回答 3

5

让我们看看列表中元素的四种情况（当我们遍历它们时）。如果（为了简洁起见）我们将old移动的项目作为其旧位置并new作为其新位置，我们在您的列表中为项目提供以下案例（在纸上画出以明确这一点）。

  1. 当前项是要移动的：直接移动
  2. 当前项目的顺序是 <new和 < old：不要移动它
  3. 当前项目的顺序是 ≥new和 < old：向右移动
  4. 当前项目的顺序是 ≤new和 > old：将其向左移动
  5. 当前项目的顺序是 >new和 > old：不要移动它

当我们开始枚举时，我们知道要移动的项目将在哪里结束（at new），但我们不知道它从哪里来（old）。然而，当我们从列表的开头开始枚举时，我们知道每一步都必须在列表中更靠后，直到我们真正看到它！所以我们可以用一个标志（seen）来表示我们是否已经看过它。所以seenfalse 意味着 <old而 true 意味着 >= old。

bool seen = false;
for (int i = 0; i < items.Length; i++)
{
    if (items[i].ID == inputID)
    {
        items[i].Order = inputNewPosition;
        seen = true;
    }
}

这个标志告诉我们当前项目是否 >= old。所以现在可以根据这些知识和上述规则开始分流。（所以new在上面的讨论中inputNewPosition，无论我们是在old我们用seen变量表示之前还是之后。）

bool seen;
for (int i = 0; i < items.Count; i++)
{
    if (items[i].ID == inputID) // case 1
    {
        items[i].Order = inputNewPosition;
        seen = true;
    }
    else if (seen) // cases 4 & 5
    {
        if (items[i].Order <= inputNewPosition) // case 4
        {
           items[i].Order--; // move it left
        }
    }
    else // case 2 & 3
    {
        if (items[i].Order >= inputNewPosition) // case 3
        {
            items[i].Order++; // move it right
        }            
    }
}

说了这么多，在每次更改时对集合进行排序可能更简单。默认排序算法对于几乎排序的集合应该是相当简单的。

于 2013-02-14T17:45:18.890 回答
0

您的问题不是很清楚，但对于要求，您可能最好在包含 Order 的对象上执行一个事件，并且可能有一个可以监视它的容器对象。但是，如果是这种情况，我怀疑您可能需要重新考虑您的算法，因为这似乎是一种非常尴尬的方式来处理按顺序显示的问题。

也就是说，问题要求是什么？如果我将项目#2 的顺序切换到#5，#3 会发生什么？它会留在原处，还是应该是#6？

于 2013-02-14T18:13:15.740 回答
0

这就是我解决问题的方法，但我认为可能有更聪明的方法......

我需要更新的对象是策略工作负载项。这些中的每一个都有一个相关的优先级。不能有具有相同优先级的策略工作负载项。因此，当用户更新优先级时，其他优先级需要相应地向上或向下移动。

这个处理程序接受一个请求对象。该请求有一个 id 和一个优先级。

 public class UpdatePriorityCommand
 {
     public int PolicyWorkloadItemId { get; set; }
     public int Priority { get; set; }
 }

此类表示以下代码中的请求对象。

//Get the item to change priority
PolicyWorkloadItem policyItem = await _ctx.PolicyWorkloadItems
                                          .FindAsync(request.PolicyWorkloadItemId);

//Get that item's priority and assign it to oldPriority variable
int oldPriority = policyItem.Priority.Value;

//Get the direction of change. 
//-1 == moving the item up in list
//+1 == moving the item down in list
int direction = oldPriority < request.Priority ? -1 : 1;

//Get list of items to update... 
List<PolicyWorkloadItem> policyItems = await _ctx.PolicyWorkloadItems
                                                 .Where(x => x.PolicyWorkloadItemId != request.PolicyWorkloadItemId)
                                                 .ToListAsync();

//Loop through and update values
foreach(var p in policyItems)
{
    //if moving item down in list (I.E. 3 to 1) then only update
    //items that are less than the old priority. (I.E. 1 to 2 and 2 to 3)
    //items greater than the new priority need not change (i.E. 4,5,6... etc.)

    //if moving item up in list (I.E. 1 to 3)
    //items less than or equal to the new value get moved down. (I.E. 2 to 1 and 3 to 2)
    //items greater than the new priority need not change (i.E. 4,5,6... etc.)
    if(
           (direction > 0 && p.Priority < oldPriority)
        || (direction < 0 && p.Priority > oldPriority && p.Priority <= request.Priority)
      )
    {  
        p.Priority += direction;
        _ctx.PolicyWorkloadItems.Update(p);
    }       
}

//finally update the priority of the target item directly
policyItem.Priority = request.Priority;

//track changes with EF Core
_ctx.PolicyWorkloadItems.Update(policyItem);

//Persist changes to database
await _ctx.SaveChangesAsync(cancellationToken);
于 2019-06-14T17:23:30.277 回答