記一次帶層級結構列表資料計算效能優化
1、背景
最近，負責一個類財務軟體資料計算的效能優化工作。先說下=這專案的情況，一套表格，幾十張表格，每張表格資料都是層級結構的，通過序號確定父子級關係，如1，1.1,1.1.1,1.1.2，1.1.3,1.2,1.2.1,1.2.2,1.3.。。。而且，列表資料帶表內編輯功能，就跟Excel體驗一樣。沒錯，你猜對了，不出意外的，這是個CS專案，前端採用WPF，在計算之前，對應表格資料已經拉取到前端記憶體中，通過MVVM雙向繫結到UI列表。計算公式分橫向和縱向，葉子級的都是橫向計算，如金額 = 單價 * 數量；父級的縱向計算，如 1.金額 = 1.1金額 + 1.2金額 + 1.3金額。。。很明顯，只能先計算葉子級，再逐級往上計算父級，而且是自底向上的。
自然而然的，你會想到遞迴，而且之前專案中也是這麼整的，遞迴呼叫自底向上計算。問題是，每張表格資料量都很大，實際環境中，最多的出現了30W條。我們按照遞迴呼叫順序去分析下這個過程：首先，從30W裡找根級（雖然最終需要自底向上計算，但系統本身它是不知道誰是子級的，只能由父級往下去逐個找），找到之後，根據根級Id從30W資料中找到其所有子級，迴圈每個子級，根據每個子級ID，從30W資料找到該子級對應的子級。。。只到最終葉子級，可以計算了，該層遞迴出棧，計算其父級，父級完了計算父級的父級。。。
那麼，問題來了：首先，遞迴本身就是極耗空間的，這麼大資料量，記憶體浪費更是了不得，而且，資料檢索也把CPU給佔盡了；更嚴重的，這還只是一張，系統有30多張表格。。。實際測試也發現，計算一開啟，i5 CPU，8G的機器，CPU直接打滿，記憶體也飆升（要不是Windows對程序記憶體做限制，我估計記憶體也打滿了，實際測試出現過OutOfMemory異常。。。）。運氣好，30W資料，花個大幾分鐘能算完，運氣不好就等個大幾分鐘，OutOfMemory。。。這麼搞，肯定是不行的，開發機都不行，更別提客戶環境千差萬別，有些客戶機配置很惡劣，老舊XP，2G記憶體，32位。。。
2、方案
一把辛酸一把淚，問題給出來了，自然是要解決。上述方案的問題在於，查詢每個節點，都需要從30W資料裡邊遍歷，能不能訪問每個節點時候，不用去遍歷這30W資料呢？本身，這30W資料就是一個樹狀結構，假如事先把這30W資料構造成一顆樹，那麼只需要按照後續遍歷，豈不就避免了頻繁的30W遍歷？
好，確定了用樹遍歷解決，那是用普通樹，還是二叉樹（是不是好奇，為什麼會想到這個問題）？答案是，二叉樹，因為最開始，我就用的普通樹，但測試發現，雖然效能極大提升（幾分鐘到幾十秒），但還是有點兒難以接受，用VS效能探查器發現，普通樹需要跟蹤某級別未訪問節點（通俗點兒說就是，訪問完某個節點，需要從同根的子級中遍歷尋找下一個未訪問的節點），這個特別耗時，假如該級節點特別多，則會遇到上述同樣的問題，從大批量資料中檢索，雖然這個資料範圍已經比30W極大減少了。用二叉樹，就左子樹右子樹，是不需要這個的。
3、實現
首先，樹節點的定義：
/// <summary>
/// 二叉樹節點
/// </summary>
/// <typeparam name="T"></typeparam>
public class TreeNode<T>
where T : Data
{
public TreeNode()
{
this.Children = new List<T>();
}
public TreeNode(T data)
: this()
{
this.Data = data;
}
/// <summary>
/// 節點對應資料節點
/// </summary>
public T Data { get; set; }
/// <summary>
/// 樹節點
/// </summary>
public TreeNode<T> Parent { get; set; }
/// <summary>
/// 左子樹
/// </summary>
public TreeNode<T> Left { get; set; }
/// <summary>
/// 右子樹
/// </summary>
public TreeNode<T> Right { get; set; }
/// <summary>
/// 該節點對應業務節點的子業務節點集合
/// </summary>
public List<T> Children { get; private set; }
}
節點，節點資料，左子樹節點，右子樹節點，父級節點，比較簡單。這裡唯一需要說明的是，節點對應的子級資料集合，因為原始資料，是一個普通樹，最終我們是要把它轉化為一個二叉樹的，轉化之後，我們需要記錄某個資料節點它對應的原始子級資料集合是哪些，便於後續跟蹤和計算。
好，二叉樹節點定義好了，對二叉樹進行處理的前提，是先要構造二叉樹。資料結構中，有一種普通樹狀結構轉為二叉樹的方式是，第一個子節點作為左子樹，剩餘兄弟節點，都作為上一個子節點的右子樹存在，也就是說，左子樹子節點，右子樹兄弟節點。假如我們有這麼幾個資料節點：1,1.1,1.1.1,1.1.2,1.1.3,1.2,1.2.1,1.2.2,1.3，則構建完成之後，二叉樹應該是這樣子的：
具體程式碼，怎麼實現呢？這裡先說下前提，系統中資料是按照對應序號排序的，比如1,1.1,1.1.1,1.1.2,1.1.3,1.2,1.2.1，1.2.2,1.3。那麼，從一維列表構建二叉樹的程式碼如下：
/// <summary>
/// 根據實體列表構建二叉樹
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list"></param>
/// <returns></returns>
public static TreeNode<T> GenerateTree<T>(List<T> list, Func<T, bool> rootCondition, Func<T, T, bool> parentCondition)
where T : Data
{
if (!list.Any())
{
return null;
}
var rootData = list.FirstOrDefault(x => rootCondition(x));
TreeNode<T> root = new TreeNode<T>(rootData);
Stack<TreeNode<T>> stackParentNodes = new Stack<TreeNode<T>>();
stackParentNodes.Push(root);
foreach (var item in list)
{
if (item == rootData)
{
continue;
}
TreeNode<T> parent = stackParentNodes.Peek();
while (!parentCondition(item, parent.Data))
{
stackParentNodes.Pop();
if (stackParentNodes.Count == 0)
{
stackParentNodes.Push(root);
parent = root;
break;
}
parent = stackParentNodes.Peek();
}
var currentNode = new TreeNode<T>(item);
if (parent.Left == null)
{
parent.Left = currentNode;
currentNode.Parent = parent;
}
else
{
if (parent.Left.Right == null)
{
parent.Left.Right = currentNode;
currentNode.Parent = parent.Left;
}
else
{
parent.Left.Right.Parent = currentNode;
currentNode.Right = parent.Left.Right;
currentNode.Parent = parent.Left;
parent.Left.Right = currentNode;
}
}
parent.Children.Add(item);
stackParentNodes.Push(currentNode);
}
return root;
}
這段程式碼，參考網上的，出處我已經找不到了，如果哪位網友看見了，麻煩告訴我，我註明出處。說下這段程式碼的核心思想，首先有個父級棧，用來記錄上次遍歷的節點及其父節點，然後開始遍歷資料列表中每條記錄，在這過程中，從父節點棧中找該節點對應的父節點，不匹配的元素直接出棧，只到找到對應父節點。找到之後，如果父節點左子樹不存在，直接將當前節點掛在左子樹，如果左子樹存在，則該節點是當前左子樹的兄弟節點，需要作為該左子樹的右子樹去掛。這時候有個問題，如果左子樹的右子樹不存在，直接掛在左子樹的右子樹就可以，如果存在，則需要將其掛為右子樹，左子樹的原右子樹變成當前節點的右子樹。因為遍歷時候，是按照順序來的，這麼一來，則兄弟節點在樹上掛的順序，是逆序的，最終效果會如下：
有點兒擰，大家知道是那麼回事兒就行了。樹構建好了，接下來就是遍歷計算。很明顯，對於這種計算，是需要後續遍歷的，則實現程式碼如下：
/// <summary>
/// 後續遍歷二叉樹進行計算
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="root"></param>
/// <param name="leaveCompute"></param>
/// <param name="branchCompute"></param>
public static void Compute<T>(TreeNode<T> root, Action<T> leafCompute, Action<T, List<T>> branchCompute)
where T : Data
{
if (root == null)
{
return;
}
TreeNode<T> currentNode = null,
preNode = null;
Stack<TreeNode<T>> stackParentNodes = new Stack<TreeNode<T>>();
stackParentNodes.Push(root);
while (stackParentNodes.Any())
{
currentNode = stackParentNodes.Peek();
if ((currentNode.Left == null && currentNode.Right == null)
|| (preNode != null) && (preNode == currentNode.Left || preNode == currentNode.Right))
{
preNode = currentNode;
if (currentNode.Children.Any())
{
currentNode.Data.LeavesCount = currentNode.Children.Sum(x => x.LeavesCount);
branchCompute?.Invoke(currentNode.Data, currentNode.Children);
}
else
{
currentNode.Data.LeavesCount = 1;
leafCompute?.Invoke(currentNode.Data);
}
stackParentNodes.Pop();
}
else
{
if (currentNode.Right != null)
{
stackParentNodes.Push(currentNode.Right);
}
if (currentNode.Left != null)
{
stackParentNodes.Push(currentNode.Left);
}
}
}
}
核心思想是記錄遍歷過程中的父級節點及上次遍歷的節點。當前節點需要被訪問的條件是，當前節點左子樹右子樹都為空（葉子節點）或者上次訪問的節點是本節點的子節點，否則當前節點不應該被訪問，而是將其右子樹左子樹進棧以備考察。這個是全量計算的方式。還有一種情況是，改變了其中某個單元格，例如上述，我改了1.1.3其中的單價，則這時候也需要計算，但計算應該僅限於本級節點及父節點，你非要全量計算也沒問題，無非效能低點兒。那麼，計算本級和父級的功能，如下：
/// <summary>
/// 計算指定節點極其父級
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="node"></param>
/// <param name="branchCompute"></param>
public static void ComputeParent<T>(TreeNode<T> node, Action<T> leafCompute, Action<T, List<T>> branchCompute)
where T : Data
{
if (node == null)
{
return;
}
TreeNode<T> currentNode = node;
if (node.Children.Any())
{
currentNode.Data.LeavesCount = currentNode.Children.Sum(x => x.LeavesCount);
branchCompute?.Invoke(currentNode.Data, currentNode.Children);
}
else
{
currentNode.Data.LeavesCount = 1;
currentNode.Data.IsLeaf = true;
leafCompute?.Invoke(currentNode.Data);
}
while (currentNode != null)
{
var parentNode = currentNode.Parent;
if (parentNode != null && parentNode.Left == currentNode)
{
branchCompute?.Invoke(parentNode.Data, parentNode.Children);
}
currentNode = parentNode;
}
}
核心思想是，首先計算當前節點，然後，根據樹節點中儲存的parent節點資訊，逐級向上計算其父節點。比較簡單，不多說。後續遍歷計算有了，還有一種情況，就是要從樹裡邊查詢某個節點，這裡明顯是要前序遍歷的，因為扎到某個節點我就直接返回了，犯不著每個節點都過一遍及保留中途父節點資訊。實現如下：
/// <summary>
/// 查詢符合指定條件的節點
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static TreeNode<T> FindNode<T>(TreeNode<T> node, Func<T, bool> condition)
where T : Data
{
if (node == null)
{
return null;
}
Stack<TreeNode<T>> stackParentsNodes = new Stack<TreeNode<T>>();
TreeNode<T> currentNode = node;
while (currentNode != null || stackParentsNodes.Any())
{
if (currentNode != null)
{
if (condition(currentNode.Data))
{
return currentNode;
}
stackParentsNodes.Push(currentNode);
currentNode = currentNode.Left;
}
else
{
currentNode = stackParentsNodes.Pop().Right;
}
}
return null;
}
典型的前序遍歷，比較簡單，不多說。
4、總結
這麼一套解決方案下來，全套30多張表格的計算，由原來的十幾分鍾，改進到幾十秒。好了，本次分享就到這裡，希望能幫助到大家。