\u00a0C# \u7c7b\u5e93\u9879\u76ee\u4e2d\u7684\u7b97\u6cd5\u8fdb\u884c\u8be6\u7ec6\u89e3\u6790，\u5e76\u63d0\u4f9b\u793a\u4f8b\u4ee3\u7801\u3001\u6d4b\u8bd5\u7528\u4f8b\u3001\u4e2d\u6587\u89e3\u91ca\u4ee5\u53ca\u9002\u7528\u573a\u666f，\u7279\u522b\u662f\u9488\u5bf9\u534a\u5bfc\u4f53\u4ea7\u7ebf\u3001\u6d4b\u8bd5\u673a\u6216\u8d34\u7247\u673a\u7b49\u8bbe\u5907\u7684\u8be6\u7ec6\u4ee3\u7801\u793a\u4f8b，\u6211\u5c06\u5206\u6b65\u5904\u7406\u60a8\u7684\u8bf7\u6c42\u3002<\/p>\n
\u7531\u4e8e\u5185\u5bb9\u8f83\u591a，\u6211\u5c06\u91cd\u70b9\u8bb2\u89e3\u51e0\u4e2a\u4ee3\u8868\u6027\u7b97\u6cd5\u548c\u6570\u636e\u7ed3\u6784，\u6db5\u76d6\u5176\u5b9e\u73b0\u3001\u6d4b\u8bd5\u7528\u4f8b\u3001\u9002\u7528\u573a\u666f，\u5e76\u5728\u6700\u540e\u63d0\u4f9b\u534a\u5bfc\u4f53\u4ea7\u7ebf\u76f8\u5173\u573a\u666f\u7684\u4ee3\u7801\u793a\u4f8b\u3002\u4e3a\u4e86\u4fdd\u6301\u6e05\u6670\u548c\u7b80\u6d01，\u6211\u4f1a\u6311\u9009\u51e0\u4e2a\u5178\u578b\u7b97\u6cd5（\u5982\u5feb\u901f\u6392\u5e8f\u3001\u8fea\u6770\u65af\u7279\u62c9\u6700\u77ed\u8def\u5f84\u3001\u4e8c\u53c9\u641c\u7d22\u6811）\u8fdb\u884c\u8be6\u7ec6\u8bf4\u660e，\u5e76\u9488\u5bf9\u534a\u5bfc\u4f53\u8bbe\u5907\u573a\u666f\u63d0\u4f9b\u5b9a\u5236\u5316\u793a\u4f8b\u3002\u5982\u679c\u60a8\u9700\u8981\u5176\u4ed6\u7279\u5b9a\u7b97\u6cd5\u7684\u8be6\u7ec6\u89e3\u6790，\u8bf7\u8fdb\u4e00\u6b65\u8bf4\u660e\u3002<\/p>\n
\u4e00\u3001\u7b97\u6cd5\u8be6\u89e3：\u5feb\u901f\u6392\u5e8f (Quick Sort)\u4e2d\u6587\u89e3\u91ca\u5feb\u901f\u6392\u5e8f\u662f\u4e00\u79cd\u9ad8\u6548\u7684 \u5206\u6cbb\u6cd5 \u6392\u5e8f\u7b97\u6cd5，\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(n log n)，\u6700\u574f\u60c5\u51b5\u4e3a O(n\u00b2)\u3002\u5b83\u901a\u8fc7\u9009\u62e9\u4e00\u4e2a\u201c\u57fa\u51c6\u201d（pivot），\u5c06\u6570\u7ec4\u5206\u4e3a\u4e24\u90e8\u5206：\u5c0f\u4e8e\u57fa\u51c6\u7684\u5143\u7d20\u548c\u5927\u4e8e\u57fa\u51c6\u7684\u5143\u7d20，\u7136\u540e\u9012\u5f52\u5730\u5bf9\u5b50\u6570\u7ec4\u6392\u5e8f\u3002\u5feb\u901f\u6392\u5e8f\u9002\u7528\u4e8e\u5185\u5b58\u6709\u9650\u7684\u573a\u666f，\u56e0\u4e3a\u5b83\u662f\u539f\u5730\u6392\u5e8f\u7b97\u6cd5\u3002\u9002\u7528\u573a\u666f<\/p>\n
\u793a\u4f8b\u4ee3\u7801\u4ee5\u4e0b\u662f\u57fa\u4e8e C# \u7684\u5feb\u901f\u6392\u5e8f\u5b9e\u73b0（\u53c2\u8003\u9879\u76ee\u7ed3\u6784）：csharp<\/p>\n
\u00a0<\/p>\n
public class QuickSort<T> where T : IComparable<T>
\n{
\n public void Sort(T[] array)
\n {
\n if (array == null || array.Length == 0) return;
\n QuickSortInternal(array, 0, array.Length – 1);
\n }<\/p>\n
private void QuickSortInternal(T[] array, int low, int high)
\n {
\n if (low < high)
\n {
\n int pivotIndex = Partition(array, low, high);
\n QuickSortInternal(array, low, pivotIndex – 1);
\n QuickSortInternal(array, pivotIndex + 1, high);
\n }
\n }<\/p>\n
private int Partition(T[] array, int low, int high)
\n {
\n T pivot = array[high];
\n int i = low – 1;<\/p>\n
for (int j = low; j < high; j++)
\n {
\n if (array[j].CompareTo(pivot) <= 0)
\n {
\n i++;
\n Swap(array, i, j);
\n }
\n }
\n Swap(array, i + 1, high);
\n return i + 1;
\n }<\/p>\n
private void Swap(T[] array, int i, int j)
\n {
\n T temp = array[i];
\n array[i] = array[j];
\n array[j] = temp;
\n }
\n}<\/p>\n
\u6d4b\u8bd5\u7528\u4f8b\u4ee5\u4e0b\u662f\u4f7f\u7528 MSTest \u6846\u67b6\u7684\u5355\u5143\u6d4b\u8bd5\u4ee3\u7801：csharp<\/p>\n
\u00a0<\/p>\n
using Microsoft.VisualStudio.TestTools.UnitTesting;<\/p>\n
[TestClass]
\npublic class QuickSortTests
\n{
\n [TestMethod]
\n public void Sort_ValidArray_ReturnsSortedArray()
\n {
\n \/\/ Arrange
\n var sorter = new QuickSort<int>();
\n int[] array = { 64, 34, 25, 12, 22, 11, 90 };
\n int[] expected = { 11, 12, 22, 25, 34, 64, 90 };<\/p>\n
\/\/ Act
\n sorter.Sort(array);<\/p>\n
\/\/ Assert
\n CollectionAssert.AreEqual(expected, array);
\n }<\/p>\n
[TestMethod]
\n public void Sort_EmptyArray_DoesNotThrow()
\n {
\n \/\/ Arrange
\n var sorter = new QuickSort<int>();
\n int[] array = { };<\/p>\n
\/\/ Act
\n sorter.Sort(array);<\/p>\n
\/\/ Assert
\n Assert.AreEqual(0, array.Length);
\n }<\/p>\n
[TestMethod]
\n public void Sort_SingleElementArray_ReturnsSameArray()
\n {
\n \/\/ Arrange
\n var sorter = new QuickSort<int>();
\n int[] array = { 42 };
\n int[] expected = { 42 };<\/p>\n
\/\/ Act
\n sorter.Sort(array);<\/p>\n
\/\/ Assert
\n CollectionAssert.AreEqual(expected, array);
\n }
\n}<\/p>\n
\u534a\u5bfc\u4f53\u4ea7\u7ebf\u793a\u4f8b\u5728\u534a\u5bfc\u4f53\u6d4b\u8bd5\u673a\u4e2d，\u5feb\u901f\u6392\u5e8f\u53ef\u7528\u4e8e\u5bf9\u6676\u5706\u6d4b\u8bd5\u6570\u636e（\u5982\u7535\u538b\u503c）\u8fdb\u884c\u6392\u5e8f，\u4ee5\u8bc6\u522b\u5f02\u5e38\u503c\u6216\u751f\u6210\u7edf\u8ba1\u62a5\u8868\u3002csharp<\/p>\n
\u00a0<\/p>\n
public class WaferTestData
\n{
\n public int WaferId { get; set; }
\n public double Voltage { get; set; }
\n public DateTime TestTime { get; set; }<\/p>\n
public WaferTestData(int waferId, double voltage, DateTime testTime)
\n {
\n WaferId = waferId;
\n Voltage = voltage;
\n TestTime = testTime;
\n }<\/p>\n
public class VoltageComparer : IComparable<WaferTestData>
\n {
\n public int CompareTo(WaferTestData other)
\n {
\n return Voltage.CompareTo(other.Voltage);
\n }
\n }
\n}<\/p>\n
public class WaferTestSorter
\n{
\n public void SortByVoltage(WaferTestData[] testData)
\n {
\n var sorter = new QuickSort<WaferTestData>();
\n sorter.Sort(testData);
\n }
\n}<\/p>\n
\/\/ \u4f7f\u7528\u793a\u4f8b
\n[TestMethod]
\npublic void SortWaferTestData_ByVoltage_ReturnsSorted()
\n{
\n var testData = new[]
\n {
\n new WaferTestData(1, 5.2, DateTime.Now),
\n new WaferTestData(2, 4.8, DateTime.Now),
\n new WaferTestData(3, 5.5, DateTime.Now)
\n };<\/p>\n
var sorter = new WaferTestSorter();
\n sorter.SortByVoltage(testData);<\/p>\n
Assert.IsTrue(testData[0].Voltage == 4.8);
\n Assert.IsTrue(testData[1].Voltage == 5.2);
\n Assert.IsTrue(testData[2].Voltage == 5.5);
\n}<\/p>\n
\u4e8c\u3001\u7b97\u6cd5\u8be6\u89e3：\u8fea\u6770\u65af\u7279\u62c9\u6700\u77ed\u8def\u5f84 (Dijkstra\u2019s Shortest Path)\u4e2d\u6587\u89e3\u91ca\u8fea\u6770\u65af\u7279\u62c9\u7b97\u6cd5\u7528\u4e8e\u5728\u52a0\u6743\u56fe（\u65e0\u8d1f\u6743\u8fb9）\u4e2d\u5bfb\u627e\u4ece\u8d77\u70b9\u5230\u5176\u4ed6\u6240\u6709\u8282\u70b9\u7684\u6700\u77ed\u8def\u5f84，\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O((V + E) log V)（\u4f7f\u7528\u4f18\u5148\u961f\u5217）\u3002\u5b83\u901a\u8fc7\u7ef4\u62a4\u4e00\u4e2a\u4f18\u5148\u961f\u5217，\u9010\u6b65\u9009\u62e9\u5f53\u524d\u8ddd\u79bb\u6700\u5c0f\u7684\u8282\u70b9，\u66f4\u65b0\u5176\u90bb\u5c45\u7684\u8ddd\u79bb\u3002\u9002\u7528\u573a\u666f<\/p>\n
\u793a\u4f8b\u4ee3\u7801\u4ee5\u4e0b\u662f\u8fea\u6770\u65af\u7279\u62c9\u7b97\u6cd5\u7684\u5b9e\u73b0（\u57fa\u4e8e\u9879\u76ee\u7684\u52a0\u6743\u6709\u5411\u56fe）：csharp<\/p>\n
\u00a0<\/p>\n
public class DijkstraShortestPaths
\n{
\n private double[] distTo;
\n private DirectedEdge[] edgeTo;
\n private IndexMinPQ<double> pq;<\/p>\n
public DijkstraShortestPaths(EdgeWeightedDigraph G, int s)
\n {
\n distTo = new double[G.V];
\n edgeTo = new DirectedEdge[G.V];
\n pq = new IndexMinPQ<double>(G.V);<\/p>\n
for (int v = 0; v < G.V; v++)
\n distTo[v] = double.PositiveInfinity;
\n distTo[s] = 0.0;<\/p>\n
pq.Insert(s, 0.0);
\n while (!pq.IsEmpty())
\n {
\n int v = pq.DelMin();
\n foreach (DirectedEdge e in G.Adj(v))
\n Relax(e);
\n }
\n }<\/p>\n
private void Relax(DirectedEdge e)
\n {
\n int v = e.From, w = e.To;
\n if (distTo[w] > distTo[v] + e.Weight)
\n {
\n distTo[w] = distTo[v] + e.Weight;
\n edgeTo[w] = e;
\n if (pq.Contains(w)) pq.DecreaseKey(w, distTo[w]);
\n else pq.Insert(w, distTo[w]);
\n }
\n }<\/p>\n
public double DistTo(int v) => distTo[v];
\n public IEnumerable<DirectedEdge> PathTo(int v)
\n {
\n Stack<DirectedEdge> path = new Stack<DirectedEdge>();
\n for (DirectedEdge e = edgeTo[v]; e != null; e = edgeTo[e.From])
\n path.Push(e);
\n return path;
\n }
\n}<\/p>\n
public class DirectedEdge
\n{
\n public int From { get; }
\n public int To { get; }
\n public double Weight { get; }<\/p>\n
public DirectedEdge(int from, int to, double weight)
\n {
\n From = from;
\n To = to;
\n Weight = weight;
\n }
\n}<\/p>\n
public class EdgeWeightedDigraph
\n{
\n public int V { get; }
\n private List<DirectedEdge>[] adj;<\/p>\n
public EdgeWeightedDigraph(int v)
\n {
\n V = v;
\n adj = new List<DirectedEdge>[v];
\n for (int i = 0; i < v; i++)
\n adj[i] = new List<DirectedEdge>();
\n }<\/p>\n
public void AddEdge(DirectedEdge e)
\n {
\n adj[e.From].Add(e);
\n }<\/p>\n
public IEnumerable<DirectedEdge> Adj(int v) => adj[v];
\n}<\/p>\n
\u6d4b\u8bd5\u7528\u4f8bcsharp<\/p>\n
\u00a0<\/p>\n
[TestClass]
\npublic class DijkstraShortestPathsTests
\n{
\n [TestMethod]
\n public void Dijkstra_ShortestPath_ReturnsCorrectDistance()
\n {
\n \/\/ Arrange
\n var G = new EdgeWeightedDigraph(4);
\n G.AddEdge(new DirectedEdge(0, 1, 5.0));
\n G.AddEdge(new DirectedEdge(0, 2, 10.0));
\n G.AddEdge(new DirectedEdge(1, 2, 3.0));
\n G.AddEdge(new DirectedEdge(2, 3, 2.0));
\n var dijkstra = new DijkstraShortestPaths(G, 0);<\/p>\n
\/\/ Act
\n double distTo3 = dijkstra.DistTo(3);<\/p>\n
\/\/ Assert
\n Assert.AreEqual(10.0, distTo3, 0.001); \/\/ 0 -> 1 -> 2 -> 3
\n }
\n}<\/p>\n
\u534a\u5bfc\u4f53\u4ea7\u7ebf\u793a\u4f8b\u5728\u8d34\u7247\u673a\u4e2d，\u673a\u68b0\u81c2\u9700\u8981\u5728\u7535\u8def\u677f\u4e0a\u7684\u591a\u4e2a\u70b9\u4e4b\u95f4\u79fb\u52a8，\u5b89\u88c5\u7535\u5b50\u5143\u4ef6\u3002\u8fea\u6770\u65af\u7279\u62c9\u7b97\u6cd5\u53ef\u4f18\u5316\u79fb\u52a8\u8def\u5f84，\u51cf\u5c11\u603b\u79fb\u52a8\u65f6\u95f4\u3002csharp<\/p>\n
\u00a0<\/p>\n
public class SmtPlacementOptimizer
\n{
\n public class ComponentPlacement
\n {
\n public int Id { get; }
\n public double X { get; }
\n public double Y { get; }<\/p>\n
public ComponentPlacement(int id, double x, double y)
\n {
\n Id = id;
\n X = x;
\n Y = y;
\n }<\/p>\n
public double DistanceTo(ComponentPlacement other)
\n {
\n return Math.Sqrt(Math.Pow(X – other.X, 2) + Math.Pow(Y – other.Y, 2));
\n }
\n }<\/p>\n
public List<int> FindOptimalPath(ComponentPlacement[] placements)
\n {
\n int n = placements.Length;
\n var G = new EdgeWeightedDigraph(n);
\n for (int i = 0; i < n; i++)
\n for (int j = 0; j < n; j++)
\n if (i != j)
\n G.AddEdge(new DirectedEdge(i, j, placements[i].DistanceTo(placements[j])));<\/p>\n
var dijkstra = new DijkstraShortestPaths(G, 0);
\n var path = dijkstra.PathTo(n – 1).Select(e => e.To).ToList();
\n path.Insert(0, 0);
\n return path;
\n }
\n}<\/p>\n
\/\/ \u6d4b\u8bd5\u7528\u4f8b
\n[TestMethod]
\npublic void SmtPlacementOptimizer_OptimalPath_ReturnsCorrectPath()
\n{
\n var placements = new[]
\n {
\n new ComponentPlacement(0, 0, 0),
\n new ComponentPlacement(1, 1, 1),
\n new ComponentPlacement(2, 2, 2)
\n };<\/p>\n
var optimizer = new SmtPlacementOptimizer();
\n var path = optimizer.FindOptimalPath(placements);<\/p>\n
Assert.AreEqual(3, path.Count);
\n Assert.IsTrue(path.SequenceEqual(new[] { 0, 1, 2 }));
\n}<\/p>\n
\u4e09\u3001\u7b97\u6cd5\u8be6\u89e3：\u4e8c\u53c9\u641c\u7d22\u6811 (Binary Search Tree)\u4e2d\u6587\u89e3\u91ca\u4e8c\u53c9\u641c\u7d22\u6811（BST）\u662f\u4e00\u79cd\u6811\u5f62\u6570\u636e\u7ed3\u6784，\u6bcf\u4e2a\u8282\u70b9\u6700\u591a\u6709\u4e24\u4e2a\u5b50\u8282\u70b9（\u5de6\u5b50\u8282\u70b9 < \u7236\u8282\u70b9 < \u53f3\u5b50\u8282\u70b9）\u3002\u5b83\u652f\u6301\u9ad8\u6548\u7684\u63d2\u5165\u3001\u5220\u9664\u548c\u67e5\u627e\u64cd\u4f5c，\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(log n)，\u4f46\u6700\u574f\u60c5\u51b5\u4e0b（\u9000\u5316\u4e3a\u94fe\u8868）\u4e3a O(n)\u3002\u9002\u7528\u573a\u666f<\/p>\n
\u793a\u4f8b\u4ee3\u7801csharp<\/p>\n
\u00a0<\/p>\n
public class BinarySearchTree<TKey, TValue> where TKey : IComparable<TKey>
\n{
\n private class Node
\n {
\n public TKey Key { get; set; }
\n public TValue Value { get; set; }
\n public Node Left { get; set; }
\n public Node Right { get; set; }<\/p>\n
public Node(TKey key, TValue value)
\n {
\n Key = key;
\n Value = value;
\n }
\n }<\/p>\n
private Node root;<\/p>\n
public void Put(TKey key, TValue value)
\n {
\n root = Put(root, key, value);
\n }<\/p>\n
private Node Put(Node node, TKey key, TValue value)
\n {
\n if (node == null) return new Node(key, value);
\n int cmp = key.CompareTo(node.Key);
\n if (cmp < 0) node.Left = Put(node.Left, key, value);
\n else if (cmp > 0) node.Right = Put(node.Right, key, value);
\n else node.Value = value;
\n return node;
\n }<\/p>\n
public TValue Get(TKey key)
\n {
\n Node node = Get(root, key);
\n return node == null ? default : node.Value;
\n }<\/p>\n
private Node Get(Node node, TKey key)
\n {
\n if (node == null) return null;
\n int cmp = key.CompareTo(node.Key);
\n if (cmp < 0) return Get(node.Left, key);
\n else if (cmp > 0) return Get(node.Right, key);
\n else return node;
\n }
\n}<\/p>\n
\u6d4b\u8bd5\u7528\u4f8bcsharp<\/p>\n
\u00a0<\/p>\n
[TestClass]
\npublic class BinarySearchTreeTests
\n{
\n [TestMethod]
\n public void PutAndGet_ValidKeyValue_ReturnsCorrectValue()
\n {
\n \/\/ Arrange
\n var bst = new BinarySearchTree<int, string>();
\n bst.Put(1, "One");
\n bst.Put(2, "Two");<\/p>\n
\/\/ Act
\n string value = bst.Get(1);<\/p>\n
\/\/ Assert
\n Assert.AreEqual("One", value);
\n }<\/p>\n
[TestMethod]
\n public void Get_NonExistentKey_ReturnsDefault()
\n {
\n \/\/ Arrange
\n var bst = new BinarySearchTree<int, string>();<\/p>\n
\/\/ Act
\n string value = bst.Get(1);<\/p>\n
\/\/ Assert
\n Assert.IsNull(value);
\n }
\n}<\/p>\n
\u534a\u5bfc\u4f53\u4ea7\u7ebf\u793a\u4f8b\u5728\u534a\u5bfc\u4f53\u6d4b\u8bd5\u673a\u4e2d，\u4e8c\u53c9\u641c\u7d22\u6811\u53ef\u7528\u4e8e\u5feb\u901f\u67e5\u627e\u6676\u5706\u6d4b\u8bd5\u6570\u636e（\u5982\u6309\u6676\u5706ID\u67e5\u627e\u6d4b\u8bd5\u7ed3\u679c）\u3002csharp<\/p>\n
\u00a0<\/p>\n
public class WaferTestResult
\n{
\n public int WaferId { get; set; }
\n public double DefectRate { get; set; }<\/p>\n
public WaferTestResult(int waferId, double defectRate)
\n {
\n WaferId = waferId;
\n DefectRate = defectRate;
\n }
\n}<\/p>\n
public class WaferTestManager
\n{
\n private BinarySearchTree<int, WaferTestResult> bst = new BinarySearchTree<int, WaferTestResult>();<\/p>\n
public void AddTestResult(int waferId, double defectRate)
\n {
\n bst.Put(waferId, new WaferTestResult(waferId, defectRate));
\n }<\/p>\n
public WaferTestResult GetTestResult(int waferId)
\n {
\n return bst.Get(waferId);
\n }
\n}<\/p>\n
\/\/ \u6d4b\u8bd5\u7528\u4f8b
\n[TestMethod]
\npublic void WaferTestManager_GetTestResult_ReturnsCorrectResult()
\n{
\n var manager = new WaferTestManager();
\n manager.AddTestResult(1001, 0.05);
\n manager.AddTestResult(1002, 0.03);<\/p>\n
var result = manager.GetTestResult(1001);<\/p>\n
Assert.AreEqual(0.05, result.DefectRate);
\n}<\/p>\n
\u56db\u3001\u603b\u7ed3\u4e0e\u6ce8\u610f\u4e8b\u9879<\/p>\n
\u5982\u679c\u60a8\u9700\u8981\u66f4\u8be6\u7ec6\u7684\u67d0\u7b97\u6cd5\u5b9e\u73b0\u3001\u6d4b\u8bd5\u7528\u4f8b，\u6216\u9488\u5bf9\u7279\u5b9a\u534a\u5bfc\u4f53\u8bbe\u5907（\u5982\u6676\u5706\u5207\u5272\u673a\u3001\u63a2\u9488\u6d4b\u8bd5\u673a）\u7684\u5b9a\u5236\u4ee3\u7801，\u8bf7\u8fdb\u4e00\u6b65\u8bf4\u660e，\u6211\u5c06\u63d0\u4f9b\u66f4\u6df1\u5165\u7684\u793a\u4f8b！<\/p>\n
\u00a0<\/p>\n
\u00a0<\/p>\n
\u00a0<\/p>\n
\u00a0<\/p>\n
\u00a0<\/p>\n
\u00a0<\/p>\n
\u00a0<\/p>\n
\u7ee7\u7eed<\/p>\n
\u597d\u7684！\u7531\u4e8e\u60a8\u8981\u6c42\u7ee7\u7eed，\u6211\u5c06\u8fdb\u4e00\u6b65\u6269\u5c55\u5bf9 C# \u7c7b\u5e93\u9879\u76ee\u4e2d\u5176\u4ed6\u7b97\u6cd5\u548c\u6570\u636e\u7ed3\u6784\u7684\u8be6\u7ec6\u89e3\u6790，\u91cd\u70b9\u8865\u5145\u4e00\u4e9b\u672a\u8986\u76d6\u7684\u4ee3\u8868\u6027\u5185\u5bb9，\u5e76\u63d0\u4f9b\u66f4\u6df1\u5165\u7684\u534a\u5bfc\u4f53\u4ea7\u7ebf\u76f8\u5173\u573a\u666f\u7684\u4ee3\u7801\u793a\u4f8b\u3002\u6211\u4f1a\u6311\u9009\u4ee5\u4e0b\u5185\u5bb9\u8fdb\u884c\u8be6\u89e3：<\/p>\n
\u6bcf\u4e2a\u90e8\u5206\u5c06\u5305\u542b\u4e2d\u6587\u89e3\u91ca\u3001\u9002\u7528\u573a\u666f\u3001\u793a\u4f8b\u4ee3\u7801\u3001\u6d4b\u8bd5\u7528\u4f8b，\u5e76\u7279\u522b\u4e3a\u534a\u5bfc\u4f53\u4ea7\u7ebf\u573a\u666f\u63d0\u4f9b\u8be6\u7ec6\u4ee3\u7801\u793a\u4f8b\u3002\u7531\u4e8e\u5185\u5bb9\u8f83\u591a，\u6211\u4f1a\u5c3d\u91cf\u4fdd\u6301\u6e05\u6670\u548c\u7b80\u6d01\u3002\u5982\u679c\u60a8\u6709\u7279\u5b9a\u7684\u7b97\u6cd5\u6216\u573a\u666f\u9700\u8981\u91cd\u70b9\u8bb2\u89e3，\u8bf7\u968f\u65f6\u8bf4\u660e！<\/p>\n
\u4e00\u3001\u7b97\u6cd5\u8be6\u89e3：\u7ea2\u9ed1\u6811 (Red-Black Tree)\u4e2d\u6587\u89e3\u91ca\u7ea2\u9ed1\u6811\u662f\u4e00\u79cd\u81ea\u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811，\u901a\u8fc7\u8282\u70b9\u7740\u8272（\u7ea2\u6216\u9ed1）\u548c\u4e00\u7cfb\u5217\u89c4\u5219（\u65cb\u8f6c\u3001\u989c\u8272\u8c03\u6574）\u4fdd\u8bc1\u6811\u7684\u9ad8\u5ea6\u59cb\u7ec8\u63a5\u8fd1 O(log n)，\u4ece\u800c\u786e\u4fdd\u63d2\u5165\u3001\u5220\u9664\u548c\u67e5\u627e\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(log n)\u3002\u7ea2\u9ed1\u6811\u7684\u89c4\u5219\u5305\u62ec：<\/p>\n
\u9002\u7528\u573a\u666f<\/p>\n
\u793a\u4f8b\u4ee3\u7801\u4ee5\u4e0b\u662f\u7ea2\u9ed1\u6811\u7684\u7b80\u5316\u548c\u5173\u952e\u5b9e\u73b0（\u57fa\u4e8e\u9879\u76ee\u7684 RedBlackTree \u7ed3\u6784，\u7b80\u5316\u4ee5\u7a81\u51fa\u6838\u5fc3\u903b\u8f91）：csharp<\/p>\n
\u00a0<\/p>\n
public class RedBlackTree<TKey, TValue> where TKey : IComparable<TKey>
\n{
\n private class Node
\n {
\n public TKey Key { get; set; }
\n public TValue Value { get; set; }
\n public Node Left { get; set; }
\n public Node Right { get; set; }
\n public bool IsRed { get; set; }<\/p>\n
public Node(TKey key, TValue value, bool isRed)
\n {
\n Key = key;
\n Value = value;
\n IsRed = isRed;
\n }
\n }<\/p>\n
private Node root;
\n private const bool RED = true;
\n private const bool BLACK = false;<\/p>\n
public void Put(TKey key, TValue value)
\n {
\n root = Put(root, key, value);
\n root.IsRed = BLACK; \/\/ \u6839\u8282\u70b9\u59cb\u7ec8\u4e3a\u9ed1\u8272
\n }<\/p>\n
private Node Put(Node h, TKey key, TValue value)
\n {
\n if (h == null) return new Node(key, value, RED);<\/p>\n
int cmp = key.CompareTo(h.Key);
\n if (cmp < 0) h.Left = Put(h.Left, key, value);
\n else if (cmp > 0) h.Right = Put(h.Right, key, value);
\n else h.Value = value;<\/p>\n
\/\/ \u5e73\u8861\u8c03\u6574
\n if (IsRed(h.Right) && !IsRed(h.Left)) h = RotateLeft(h);
\n if (IsRed(h.Left) && IsRed(h.Left.Left)) h = RotateRight(h);
\n if (IsRed(h.Left) && IsRed(h.Right)) FlipColors(h);<\/p>\n
return h;
\n }<\/p>\n
private bool IsRed(Node x) => x != null && x.IsRed;<\/p>\n
private Node RotateLeft(Node h)
\n {
\n Node x = h.Right;
\n h.Right = x.Left;
\n x.Left = h;
\n x.IsRed = h.IsRed;
\n h.IsRed = RED;
\n return x;
\n }<\/p>\n
private Node RotateRight(Node h)
\n {
\n Node x = h.Left;
\n h.Left = x.Right;
\n x.Right = h;
\n x.IsRed = h.IsRed;
\n h.IsRed = RED;
\n return x;
\n }<\/p>\n
private void FlipColors(Node h)
\n {
\n h.IsRed = RED;
\n h.Left.IsRed = BLACK;
\n h.Right.IsRed = BLACK;
\n }<\/p>\n
public TValue Get(TKey key)
\n {
\n Node node = Get(root, key);
\n return node == null ? default : node.Value;
\n }<\/p>\n
private Node Get(Node x, TKey key)
\n {
\n while (x != null)
\n {
\n int cmp = key.CompareTo(x.Key);
\n if (cmp < 0) x = x.Left;
\n else if (cmp > 0) x = x.Right;
\n else return x;
\n }
\n return null;
\n }
\n}<\/p>\n
\u6d4b\u8bd5\u7528\u4f8bcsharp<\/p>\n
\u00a0<\/p>\n
using Microsoft.VisualStudio.TestTools.UnitTesting;<\/p>\n
[TestClass]
\npublic class RedBlackTreeTests
\n{
\n [TestMethod]
\n public void PutAndGet_ValidKeyValue_ReturnsCorrectValue()
\n {
\n \/\/ Arrange
\n var rbt = new RedBlackTree<int, string>();
\n rbt.Put(1, "One");
\n rbt.Put(2, "Two");
\n rbt.Put(3, "Three");<\/p>\n
\/\/ Act
\n string value = rbt.Get(2);<\/p>\n
\/\/ Assert
\n Assert.AreEqual("Two", value);
\n }<\/p>\n
[TestMethod]
\n public void Get_NonExistentKey_ReturnsDefault()
\n {
\n \/\/ Arrange
\n var rbt = new RedBlackTree<int, string>();<\/p>\n
\/\/ Act
\n string value = rbt.Get(1);<\/p>\n
\/\/ Assert
\n Assert.IsNull(value);
\n }
\n}<\/p>\n
\u534a\u5bfc\u4f53\u4ea7\u7ebf\u793a\u4f8b\u5728\u534a\u5bfc\u4f53\u6d4b\u8bd5\u673a\u4e2d，\u7ea2\u9ed1\u6811\u53ef\u7528\u4e8e\u7ba1\u7406\u52a8\u6001\u66f4\u65b0\u7684\u6676\u5706\u6d4b\u8bd5\u6570\u636e（\u5982\u6309\u6676\u5706ID\u5b58\u50a8\u6d4b\u8bd5\u7ed3\u679c），\u652f\u6301\u9ad8\u6548\u7684\u63d2\u5165\u548c\u67e5\u8be2\u3002csharp<\/p>\n
\u00a0<\/p>\n
public class WaferTestData
\n{
\n public int WaferId { get; set; }
\n public double DefectRate { get; set; }
\n public DateTime TestTime { get; set; }<\/p>\n
public WaferTestData(int waferId, double defectRate, DateTime testTime)
\n {
\n WaferId = waferId;
\n DefectRate = defectRate;
\n TestTime = testTime;
\n }
\n}<\/p>\n
public class WaferTestManager
\n{
\n private RedBlackTree<int, WaferTestData> rbt = new RedBlackTree<int, WaferTestData>();<\/p>\n
public void AddTestResult(int waferId, double defectRate, DateTime testTime)
\n {
\n rbt.Put(waferId, new WaferTestData(waferId, defectRate, testTime));
\n }<\/p>\n
public WaferTestData GetTestResult(int waferId)
\n {
\n return rbt.Get(waferId);
\n }
\n}<\/p>\n
\/\/ \u6d4b\u8bd5\u7528\u4f8b
\n[TestMethod]
\npublic void WaferTestManager_GetTestResult_ReturnsCorrectResult()
\n{
\n var manager = new WaferTest cystic fibrosisManager();
\n manager.AddTestResult(1001, 0.05, DateTime.Now);
\n manager.AddTestResult(1002, 0.03, DateTime.Now);<\/p>\n
var result = manager.GetTestResult(1001);<\/p>\n
Assert.AreEqual(0.05, result.DefectRate);
\n}<\/p>\n
\u4e8c\u3001\u7b97\u6cd5\u8be6\u89e3：\u5e03\u8c37\u9e1f\u54c8\u5e0c\u8868 (Cuckoo Hash Table)\u4e2d\u6587\u89e3\u91ca\u5e03\u8c37\u9e1f\u54c8\u5e0c\u8868\u662f\u4e00\u79cd\u9ad8\u6548\u7684\u54c8\u5e0c\u8868\u5b9e\u73b0，\u4f7f\u7528\u4e24\u4e2a\u54c8\u5e0c\u51fd\u6570\u548c\u4e24\u4e2a\u4f4d\u7f6e\u5b58\u50a8\u6bcf\u4e2a\u952e\u503c\u5bf9\u3002\u5982\u679c\u63d2\u5165\u65f6\u53d1\u751f\u51b2\u7a81，\u4f1a\u5c06\u73b0\u6709\u5143\u7d20\u201c\u8e22\u51fa\u201d\u5e76\u91cd\u65b0\u63d2\u5165\u5230\u53e6\u4e00\u4e2a\u4f4d\u7f6e\u3002\u5b83\u7684\u67e5\u627e\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(1)，\u63d2\u5165\u548c\u5220\u9664\u7684\u5e73\u5747\u65f6\u95f4\u590d\u6742\u5ea6\u4e5f\u63a5\u8fd1 O(1)\u3002\u9002\u7528\u573a\u666f<\/p>\n
\u793a\u4f8b\u4ee3\u7801\u4ee5\u4e0b\u662f\u5e03\u8c37\u9e1f\u54c8\u5e0c\u8868\u7684\u5b9e\u73b0（\u7b80\u5316\u7248，\u57fa\u4e8e\u9879\u76ee\u7ed3\u6784）：csharp<\/p>\n
\u00a0<\/p>\n
public class CuckooHashTable<TKey, TValue>
\n{
\n private TKey[] keys1, keys2;
\n private TValue[] values1, values2;
\n private int capacity;
\n private int size;
\n private readonly Func<TKey, int> hash1;
\n private readonly Func<TKey, int> hash2;<\/p>\n
public CuckooHashTable(int capacity)
\n {
\n this.capacity = capacity;
\n keys1 = new TKey[capacity];
\n keys2 = new TKey[capacity];
\n values1 = new TValue[capacity];
\n values2 = new TValue[capacity];
\n size = 0;
\n hash1 = key => key.GetHashCode() % capacity;
\n hash2 = key => (key.GetHashCode() \/ capacity) % capacity;
\n }<\/p>\n
public void Put(TKey key, TValue value)
\n {
\n if (size >= capacity * 0.75) Resize();
\n PutInternal(key, value, 0);
\n }<\/p>\n
private bool PutInternal(TKey key, TValue value, int depth)
\n {
\n if (depth > capacity) return false; \/\/ \u907f\u514d\u65e0\u9650\u5faa\u73af<\/p>\n
int pos1 = hash1(key);
\n if (keys1[pos1] == null)
\n {
\n keys1[pos1] = key;
\n values1[pos1] = value;
\n size++;
\n return true;
\n }<\/p>\n
int pos2 = hash2(key);
\n if (keys2[pos2] == null)
\n {
\n keys2[pos2] = key;
\n values2[pos2] = value;
\n size++;
\n return true;
\n }<\/p>\n
\/\/ \u8e22\u51fa\u7b2c\u4e00\u4e2a\u8868\u4e2d\u7684\u5143\u7d20
\n TKey tempKey = keys1[pos1];
\n TValue tempValue = values1[pos1];
\n keys1[pos1] = key;
\n values1[pos1] = value;
\n return PutInternal(tempKey, tempValue, depth + 1);
\n }<\/p>\n
public TValue Get(TKey key)
\n {
\n int pos1 = hash1(key);
\n if (keys1[pos1] != null && keys1[pos1].Equals(key))
\n return values1[pos1];<\/p>\n
int pos2 = hash2(key);
\n if (keys2[pos2] != null && keys2[pos2].Equals(key))
\n return values2[pos2];<\/p>\n
return default;
\n }<\/p>\n
private void Resize()
\n {
\n \/\/ \u5b9e\u73b0\u91cd\u65b0\u5206\u914d\u548c\u91cd\u65b0\u63d2\u5165\u903b\u8f91（\u6b64\u5904\u7701\u7565\u4ee5\u7b80\u5316）
\n }
\n}<\/p>\n
\u6d4b\u8bd5\u7528\u4f8bcsharp<\/p>\n
\u00a0<\/p>\n
[TestClass]
\npublic class CuckooHashTableTests
\n{
\n [TestMethod]
\n public void PutAndGet_ValidKeyValue_ReturnsCorrectValue()
\n {
\n \/\/ Arrange
\n var cuckoo = new CuckooHashTable<int, string>(10);
\n cuckoo.Put(1, "One");
\n cuckoo.Put(2, "Two");<\/p>\n
\/\/ Act
\n string value = cuckoo.Get(1);<\/p>\n
\/\/ Assert
\n Assert.AreEqual("One", value);
\n }<\/p>\n
[TestMethod]
\n public void Get_NonExistentKey_ReturnsDefault()
\n {
\n \/\/ Arrange
\n var cuckoo = new CuckooHashTable<int, string>(10);<\/p>\n
\/\/ Act
\n string value = cuckoo.Get(1);<\/p>\n
\/\/ Assert
\n Assert.IsNull(value);
\n }
\n}<\/p>\n
\u534a\u5bfc\u4f53\u4ea7\u7ebf\u793a\u4f8b\u5728\u8d34\u7247\u673a\u4e2d，\u5e03\u8c37\u9e1f\u54c8\u5e0c\u8868\u53ef\u7528\u4e8e\u5feb\u901f\u67e5\u627e\u5143\u4ef6\u7684\u5750\u6807\u4fe1\u606f（\u4f8b\u5982，\u5143\u4ef6ID\u5230\u8d34\u7247\u4f4d\u7f6e\u7684\u6620\u5c04）\u3002csharp<\/p>\n
\u00a0<\/p>\n
public class ComponentPlacement
\n{
\n public int ComponentId { get; set; }
\n public double X { get; set; }
\n public double Y { get; set; }<\/p>\n
public ComponentPlacement(int componentId, double x, double y)
\n {
\n ComponentId = componentId;
\n X = x;
\n Y = y;
\n }
\n}<\/p>\n
public class SmtComponentLookup
\n{
\n private CuckooHashTable<int, ComponentPlacement> table;<\/p>\n
public SmtComponentLookup(int capacity)
\n {
\n table = new CuckooHashTable<int, ComponentPlacement>(capacity);
\n }<\/p>\n
public void AddComponent(int componentId, double x, double y)
\n {
\n table.Put(componentId, new ComponentPlacement(componentId, x, y));
\n }<\/p>\n
public ComponentPlacement GetComponent(int componentId)
\n {
\n return table.Get(componentId);
\n }
\n}<\/p>\n
\/\/ \u6d4b\u8bd5\u7528\u4f8b
\n[TestMethod]
\npublic void SmtComponentLookup_GetComponent_ReturnsCorrectPosition()
\n{
\n var lookup = new SmtComponentLookup(10);
\n lookup.AddComponent(1001, 10.5, 20.5);
\n lookup.AddComponent(1002, 15.0, 25.0);<\/p>\n
var component = lookup.GetComponent(1001);<\/p>\n
Assert.AreEqual(10.5, component.X);
\n Assert.AreEqual(20.5, component.Y);
\n}<\/p>\n
\u4e09\u3001\u7b97\u6cd5\u8be6\u89e3：\u62d3\u6251\u6392\u5e8f (Topological Sort)\u4e2d\u6587\u89e3\u91ca\u62d3\u6251\u6392\u5e8f\u7528\u4e8e\u6709\u5411\u65e0\u73af\u56fe（DAG），\u4e3a\u56fe\u4e2d\u7684\u6240\u6709\u8282\u70b9\u63d0\u4f9b\u4e00\u4e2a\u7ebf\u6027\u6392\u5e8f，\u4f7f\u5f97\u5bf9\u4e8e\u6bcf\u6761\u8fb9 (u, v)，u \u5728\u6392\u5e8f\u4e2d\u4f4d\u4e8e v \u4e4b\u524d\u3002\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(V + E)，\u901a\u5e38\u901a\u8fc7\u6df1\u5ea6\u4f18\u5148\u641c\u7d22（DFS）\u5b9e\u73b0\u3002\u9002\u7528\u573a\u666f<\/p>\n
\u793a\u4f8b\u4ee3\u7801\u4ee5\u4e0b\u662f\u62d3\u6251\u6392\u5e8f\u7684\u5b9e\u73b0（\u57fa\u4e8e\u9879\u76ee\u7684 TopologicalSorter）：csharp<\/p>\n
\u00a0<\/p>\n
public class TopologicalSort
\n{
\n private bool[] marked;
\n private Stack<int> reversePostorder;<\/p>\n
public TopologicalSort(Digraph G)
\n {
\n marked = new bool[G.V];
\n reversePostorder = new Stack<int>();
\n for (int v = 0; v < G.V; v++)
\n if (!marked[v])
\n Dfs(G, v);
\n }<\/p>\n
private void Dfs(Digraph G, int v)
\n {
\n marked[v] = true;
\n foreach (int w in G.Adj(v))
\n if (!marked[w])
\n Dfs(G, w);
\n reversePostorder.Push(v);
\n }<\/p>\n
public IEnumerable<int> Order() => reversePostorder;
\n}<\/p>\n
public class Digraph
\n{
\n public int V { get; }
\n private List<int>[] adj;<\/p>\n
public Digraph(int v)
\n {
\n V = v;
\n adj = new List<int>[v];
\n for (int i = 0; i < v; i++)
\n adj[i] = new List<int>();
\n }<\/p>\n
public void AddEdge(int v, int w)
\n {
\n adj[v].Add(w);
\n }<\/p>\n
public IEnumerable<int> Adj(int v) => adj[v];
\n}<\/p>\n
\u6d4b\u8bd5\u7528\u4f8bcsharp<\/p>\n
\u00a0<\/p>\n
[TestClass]
\npublic class TopologicalSortTests
\n{
\n [TestMethod]
\n public void TopologicalSort_ValidDAG_ReturnsCorrectOrder()
\n {
\n \/\/ Arrange
\n var G = new Digraph(4);
\n G.AddEdge(0, 1);
\n G.AddEdge(1, 2);
\n G.AddEdge(2, 3);
\n var sorter = new TopologicalSort(G);<\/p>\n
\/\/ Act
\n var order = sorter.Order().ToList();<\/p>\n
\/\/ Assert
\n Assert.IsTrue(order.SequenceEqual(new[] { 0, 1, 2, 3 }));
\n }
\n}<\/p>\n
\u534a\u5bfc\u4f53\u4ea7\u7ebf\u793a\u4f8b\u5728\u534a\u5bfc\u4f53\u5236\u9020\u4e2d，\u62d3\u6251\u6392\u5e8f\u53ef\u7528\u4e8e\u4f18\u5316\u5de5\u5e8f\u8c03\u5ea6\u3002\u4f8b\u5982，\u6676\u5706\u5236\u9020\u53ef\u80fd\u6d89\u53ca\u4ee5\u4e0b\u5de5\u5e8f：<\/p>\n
\u8fd9\u4e9b\u5de5\u5e8f\u6709\u4f9d\u8d56\u5173\u7cfb（\u5982\u6e05\u6d17\u5fc5\u987b\u5728\u6c89\u79ef\u4e4b\u524d）\u3002\u62d3\u6251\u6392\u5e8f\u53ef\u751f\u6210\u5408\u7406\u7684\u5de5\u5e8f\u987a\u5e8f\u3002csharp<\/p>\n
\u00a0<\/p>\n
public class ManufacturingProcess
\n{
\n public int ProcessId { get; set; }
\n public string ProcessName { get; set; }<\/p>\n
public ManufacturingProcess(int processId, string processName)
\n {
\n ProcessId = processId;
\n ProcessName = processName;
\n }
\n}<\/p>\n
public class ProcessScheduler
\n{
\n private Digraph graph;
\n private ManufacturingProcess[] processes;<\/p>\n
public ProcessScheduler(ManufacturingProcess[] processes)
\n {
\n this.processes = processes;
\n graph = new Digraph(processes.Length);
\n }<\/p>\n
public void AddDependency(int fromProcessId, int toProcessId)
\n {
\n graph.AddEdge(fromProcessId, toProcessId);
\n }<\/p>\n
public List<ManufacturingProcess> GetSchedule()
\n {
\n var sorter = new TopologicalSort(graph);
\n return sorter.Order().Select(id => processes[id]).ToList();
\n }
\n}<\/p>\n
\/\/ \u6d4b\u8bd5\u7528\u4f8b
\n[TestMethod]
\npublic void ProcessScheduler_GetSchedule_ReturnsCorrectOrder()
\n{
\n var processes = new[]
\n {
\n new ManufacturingProcess(0, "Clean"),
\n new ManufacturingProcess(1, "Deposition"),
\n new ManufacturingProcess(2, "Etching"),
\n new ManufacturingProcess(3, "Testing")
\n };<\/p>\n
var scheduler = new ProcessScheduler(processes);
\n scheduler.AddDependency(0, 1); \/\/ Clean -> Deposition
\n scheduler.AddDependency(1, 2); \/\/ Deposition -> Etching
\n scheduler.AddDependency(2, 3); \/\/ Etching -> Testing<\/p>\n
var schedule = scheduler.GetSchedule();<\/p>\n
Assert.IsTrue(schedule.Select(p => p.ProcessName).SequenceEqual(new[] { "Clean", "Deposition", "Etching", "Testing" }));
\n}<\/p>\n
\u56db\u3001\u534a\u5bfc\u4f53\u4ea7\u7ebf\u7efc\u5408\u793a\u4f8b\u4ee5\u4e0b\u662f\u4e00\u4e2a\u7efc\u5408\u793a\u4f8b，\u7ed3\u5408\u7ea2\u9ed1\u6811\u3001\u5e03\u8c37\u9e1f\u54c8\u5e0c\u8868\u548c\u62d3\u6251\u6392\u5e8f，\u6a21\u62df\u8d34\u7247\u673a\u548c\u6d4b\u8bd5\u673a\u7684\u534f\u540c\u5de5\u4f5c\u573a\u666f\u3002\u573a\u666f\u63cf\u8ff0\u5728\u534a\u5bfc\u4f53\u8d34\u7247\u673a（SMT）\u548c\u6d4b\u8bd5\u673a\u534f\u540c\u7cfb\u7edf\u4e2d：<\/p>\n
\u7efc\u5408\u4ee3\u7801\u793a\u4f8bcsharp<\/p>\n
\u00a0<\/p>\n
public class SmtAndTestSystem
\n{
\n private RedBlackTree<int, WaferTestData> testDataStore;
\n private CuckooHashTable<int, ComponentPlacement> componentLookup;
\n private ProcessScheduler scheduler;<\/p>\n
public SmtAndTestSystem(ManufacturingProcess[] processes, int hashTableCapacity)
\n {
\n testDataStore = new RedBlackTree<int, WaferTestData>();
\n componentLookup = new CuckooHashTable<int, ComponentPlacement>(hashTableCapacity);
\n scheduler = new ProcessScheduler(processes);
\n }<\/p>\n
public void AddTestResult(int waferId, double defectRate, DateTime testTime)
\n {
\n testDataStore.Put(waferId, new WaferTestData(waferId, defectRate, testTime));
\n }<\/p>\n
public WaferTestData GetTestResult(int waferId)
\n {
\n return testDataStore.Get(waferId);
\n }<\/p>\n
public void AddComponent(int componentId, double x, double y)
\n {
\n componentLookup.Put(componentId, new ComponentPlacement(componentId, x, y));
\n }<\/p>\n
public ComponentPlacement GetComponent(int componentId)
\n {
\n return componentLookup.Get(componentId);
\n }<\/p>\n
public void AddProcessDependency(int fromProcessId, int toProcessId)
\n {
\n scheduler.AddDependency(fromProcessId, toProcessId);
\n }<\/p>\n
public List<ManufacturingProcess> GetProcessSchedule()
\n {
\n return scheduler.GetSchedule();
\n }
\n}<\/p>\n
\/\/ \u6d4b\u8bd5\u7528\u4f8b
\n[TestMethod]
\npublic void SmtAndTestSystem_IntegratedTest_ReturnsCorrectResults()
\n{
\n var processes = new[]
\n {
\n new ManufacturingProcess(0, "Clean"),
\n new ManufacturingProcess(1, "SMT Placement"),
\n new ManufacturingProcess(2, "Testing")
\n };<\/p>\n
var system = new SmtAndTestSystem(processes, 10);<\/p>\n
\/\/ \u6dfb\u52a0\u6d4b\u8bd5\u6570\u636e
\n system.AddTestResult(1001, 0.05, DateTime.Now);
\n system.AddTestResult(1002, 0.03, DateTime.Now);<\/p>\n
\/\/ \u6dfb\u52a0\u5143\u4ef6\u4f4d\u7f6e
\n system.AddComponent(2001, 10.5, 20.5);
\n system.AddComponent(2002, 15.0, 25.0);<\/p>\n
\/\/ \u6dfb\u52a0\u5de5\u5e8f\u4f9d\u8d56
\n system.AddProcessDependency(0, 1); \/\/ Clean -> SMT Placement
\n system.AddProcessDependency(1, 2); \/\/ SMT Placement -> Testing<\/p>\n
\/\/ \u6d4b\u8bd5\u67e5\u8be2
\n var testResult = system.GetTestResult(1001);
\n var component = system.GetComponent(2001);
\n var schedule = system.GetProcessSchedule();<\/p>\n
\/\/ \u9a8c\u8bc1
\n Assert.AreEqual(0.05, testResult.DefectRate);
\n Assert.AreEqual(10.5, component.X);
\n Assert.IsTrue(schedule.Select(p => p.ProcessName).SequenceEqual(new[] { "Clean", "SMT Placement", "Testing" }));
\n}<\/p>\n
\u4e94\u3001\u603b\u7ed3\u4e0e\u6ce8\u610f\u4e8b\u9879<\/p>\n
\u5982\u679c\u60a8\u9700\u8981\u66f4\u6df1\u5165\u7684\u67d0\u7b97\u6cd5\u5206\u6790\u3001\u5176\u4ed6\u6570\u636e\u7ed3\u6784\u7684\u5b9e\u73b0，\u6216\u9488\u5bf9\u7279\u5b9a\u534a\u5bfc\u4f53\u8bbe\u5907（\u5982\u63a2\u9488\u6d4b\u8bd5\u673a\u3001\u6676\u5706\u5207\u5272\u673a）\u7684\u5b9a\u5236\u4ee3\u7801，\u8bf7\u8fdb\u4e00\u6b65\u8bf4\u660e，\u6211\u5c06\u63d0\u4f9b\u66f4\u8be6\u7ec6\u7684\u793a\u4f8b！<\/p>\n
\u00a0<\/p>\n","protected":false},"excerpt":{"rendered":"
\u6587\u7ae0\u6d4f\u89c8\u9605\u8bfb584\u6b21\uff0c\u70b9\u8d5e12\u6b21\uff0c\u6536\u85cf9\u6b21\u3002\u4e00\u3001\u7b97\u6cd5\u8be6\u89e3\uff1a\u7ea2\u9ed1\u6811 (Red-Black Tree)\u4e2d\u6587\u89e3\u91ca\u7ea2\u9ed1\u6811\u662f\u4e00\u79cd\u81ea\u5e73\u8861\u4e8c\u53c9\u641c\u7d22\u6811\uff0c\u901a\u8fc7\u8282\u70b9\u7740\u8272\uff08\u7ea2\u6216\u9ed1\uff09\u548c\u4e00\u7cfb\u5217\u89c4\u5219\uff08\u65cb\u8f6c\u3001\u989c\u8272\u8c03\u6574\uff09\u4fdd\u8bc1\u6811\u7684\u9ad8\u5ea6\u59cb\u7ec8\u63a5\u8fd1 O(log n)\uff0c\u4ece\u800c\u786e\u4fdd\u63d2\u5165\u3001\u5220\u9664\u548c\u67e5\u627e\u7684\u65f6\u95f4\u590d\u6742\u5ea6\u4e3a O(log n)\u3002\u6bcf\u4e2a\u90e8\u5206\u5c06\u5305\u542b\u4e2d\u6587\u89e3\u91ca\u3001\u9002\u7528\u573a\u666f\u3001\u793a\u4f8b\u4ee3\u7801\u3001\u6d4b\u8bd5\u7528\u4f8b\uff0c\u5e76\u7279\u522b\u4e3a\u534a\u5bfc\u4f53\u4ea7\u7ebf\u573a\u666f\u63d0\u4f9b\u8be6\u7ec6\u4ee3\u7801\u793a\u4f8b\u3002C# \u7c7b\u5e93\u9879\u76ee\u4e2d\u7684\u7b97\u6cd5\u8fdb\u884c\u8be6\u7ec6\u89e3\u6790\uff0c\u5e76\u63d0\u4f9b\u793a\u4f8b\u4ee3\u7801\u3001\u6d4b\u8bd5\u7528\u4f8b\u3001\u4e2d\u6587\u89e3\u91ca\u4ee5\u53ca\u9002\u7528\u573a\u666f\uff0c\u7279\u522b\u662f\u9488\u5bf9\u534a\u5bfc\u4f53\u4ea7\u7ebf\u3001\u6d4b\u8bd5\u673a\u6216\u8d34\u7247\u673a\u7b49\u8bbe\u5907\u7684\u8be6\u7ec6\u4ee3\u7801\u793a\u4f8b\uff0c\u6211\u5c06\u5206\u6b65\u5904\u7406\u60a8\u7684\u8bf7\u6c42\u3002<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[55,138,427],"topic":[],"class_list":["post-53258","post","type-post","status-publish","format-standard","hentry","category-server","tag-c","tag-138","tag-427"],"yoast_head":"\n