// TO DO
public SortableItem<T> CreateBike()
{
SortableItem<T> vehicle;
vehicle = new SortableItem<T>();
return vehicle;
}
// public void ShowUpdateTeamInfo(bool isCondition = true)
// {
// NotifyChanged((int)ENPropertyChanged.enUpdateTeam, isCondition);
// }
public FriendItem LookupFriendItem(int guid)
{
SortableItem item = null;
if (m_friendInfoDic.TryGetValue(guid, out item))
{
return(item as FriendItem);
}
return(null);
}
private SortableItem <T>[] CopyData(SortableItem <T>[] src, int start, int end)
{
SortableItem <T>[] result = new SortableItem <T> [end - start];
int j = 0;
for (int i = start; i < end; i++)
{
result[j] = src[i];
j++;
}
return(result);
}
public SortableItem<Car> CreateCar()
{
SortableItem<Car> vehicle;
vehicle = new SortableItem<Car>();
vehicle.Id = random.Next(min, max);
vehicle.Val = new Car();
vehicle.Val.make = VehicleMakes[(random.Next(min, max) % MaxMakes)];
vehicle.Val.model = VehicleModels[(random.Next(min, max) % MaxModels)];
vehicle.Val.registration = "REG" + Convert.ToString(vehicle.Id).PadLeft(8, '0');
return vehicle;
}
public List <SortableItem <T> > QSort(List <SortableItem <T> > items)
{
// If array is unit length, then return.
if (items.Count <= 1)
{
return(items);
}
else
{
// Generate three sub-arrays.
List <SortableItem <T> > lt = new List <SortableItem <T> >();
List <SortableItem <T> > eq = new List <SortableItem <T> >();
List <SortableItem <T> > gt = new List <SortableItem <T> >();
// Get the pivot
SortableItem <T> p = items[0];
// Iterate through the array elements
for (int i = 0; i < items.Count; i++)
{
// Element is less than pivot
if (items[i].Id < p.Id)
{
lt.Add(items[i]);
}
// Element is equal to pivot
else if (items[i].Id == p.Id)
{
eq.Add(items[i]);
}
// Element is greater than pivot
else
{
gt.Add(items[i]);
}
}
// Sort the partitions
lt = QSort(lt);
eq = QSort(eq);
gt = QSort(gt);
// Return the merged array
lt.AddRange(eq);
lt.AddRange(gt);
return(lt);
}
}
public float GetSortValue(SortableItem item, ENSortType sortType, out Dictionary <float, List <CSItem> > dicTeam, out List <float> tempTeam)
{
tempTeam = new List <float>();
dicTeam = new Dictionary <float, List <CSItem> >();
FriendItem friendItem = (FriendItem)item;
if (sortType != ENSortType.enLoadTime)
{
CSItem itemData = friendItem.GetItem();
return(GetSortValue(itemData, sortType, out dicTeam, out tempTeam));
}
return(friendItem.beforLoadTime());
}
public void Can_detect_cycles()
{
/*
* A
|
| ----------
| |
| B C
|
| -----------
|
| D E<-
| | |
| G F--
*/
var a = new SortableItem {
Key = "A"
};
var b = new SortableItem {
Key = "B", DependsOn = new string[] { "A" }
};
var c = new SortableItem {
Key = "C", DependsOn = new string[] { "a" }
};
var d = new SortableItem {
Key = "D", DependsOn = new string[] { "C" }
};
var e = new SortableItem {
Key = "E", DependsOn = new string[] { "f" }
};
var f = new SortableItem {
Key = "F", DependsOn = new string[] { "e" }
};
var g = new SortableItem {
Key = "G", DependsOn = new string[] { "D" }
};
var items = new SortableItem[] { c, e, b, d, a, g, f };
Assert.Throws <CyclicDependencyException>(() => items.SortTopological(StringComparer.OrdinalIgnoreCase));
}
public void Can_sort_topological()
{
/*
* A
|
| ----------
| |
| B C
|
| -----------
| |
| D E
| |
| H F
| |
| I G
*/
var a = new SortableItem {
Key = "A"
};
var b = new SortableItem {
Key = "B", DependsOn = new string[] { "A" }
};
var c = new SortableItem {
Key = "C", DependsOn = new string[] { "a" }
};
var d = new SortableItem {
Key = "D", DependsOn = new string[] { "C" }
};
var e = new SortableItem {
Key = "E", DependsOn = new string[] { "c" }
};
var f = new SortableItem {
Key = "F", DependsOn = new string[] { "e" }
};
var g = new SortableItem {
Key = "G", DependsOn = new string[] { "f" }
};
var h = new SortableItem {
Key = "H", DependsOn = new string[] { "D" }
};
var i = new SortableItem {
Key = "I", DependsOn = new string[] { "H" }
};
var items = new SortableItem[] { c, e, b, d, a, i, g, f, h };
var sortedItems = items.SortTopological(StringComparer.OrdinalIgnoreCase);
Console.WriteLine(String.Join(", ", sortedItems.Select(x => x.Key).ToArray()));
Assert.AreEqual(items.Length, sortedItems.Length);
Assert.Less(Array.IndexOf(sortedItems, a), Array.IndexOf(sortedItems, b));
Assert.Less(Array.IndexOf(sortedItems, a), Array.IndexOf(sortedItems, c));
Assert.Less(Array.IndexOf(sortedItems, a), Array.IndexOf(sortedItems, d));
Assert.Less(Array.IndexOf(sortedItems, a), Array.IndexOf(sortedItems, e));
Assert.Less(Array.IndexOf(sortedItems, c), Array.IndexOf(sortedItems, d));
Assert.Less(Array.IndexOf(sortedItems, c), Array.IndexOf(sortedItems, e));
Assert.Less(Array.IndexOf(sortedItems, d), Array.IndexOf(sortedItems, h));
Assert.Less(Array.IndexOf(sortedItems, h), Array.IndexOf(sortedItems, i));
Assert.Less(Array.IndexOf(sortedItems, e), Array.IndexOf(sortedItems, f));
Assert.Less(Array.IndexOf(sortedItems, f), Array.IndexOf(sortedItems, g));
}
