public void BasicInsert(T[] items, T item, int index, int repeat)
{
var list = new SeqList <T>(items);
for (var i = 0; i < repeat; i++)
{
list.Insert(index, item);
}
Assert.True(list.Contains(item)); //"Expect it to contain the item."
Assert.Equal(list.Count, items.Length + repeat); //"Expect to be the same."
for (var i = 0; i < index; i++)
{
Assert.Equal(list[i], items[i]); //"Expect to be the same."
}
for (var i = index; i < index + repeat; i++)
{
Assert.Equal(list[i], item); //"Expect to be the same."
}
for (var i = index + repeat; i < list.Count; i++)
{
Assert.Equal(list[i], items[i - repeat]); //"Expect to be the same."
}
}
//选取顺序表中不相同的元素组成新的顺序表
static SeqList <int> Purge(SeqList <int> la)
{
SeqList <int> lb = new SeqList <int>(la.Maxsize);
lb.Append(la[0]);
for (int i = 0; i <= la.GetLength() - 1; i++)
{
int j = 0;
//查看b表中有无与a表中相同的数据元素
for (j = 0; j <= lb.GetLength() - 1; ++j)
{
//有相同的数据元素
if (la[i].CompareTo(lb[j]) == 0)
{
break;
}
}
//没有相同的数据元素，将a表中的数据元素附加到b表的末尾。
if (j > lb.GetLength() - 1)
{
lb.Append(la[i]);
}
}
return(lb);
}
public void ClearNonEmptyList(T[] items)
{
var list = new SeqList <T>(items);
list.Clear();
Assert.Empty(list); //"Should be equal to 0."
}
public void ReverseTest()
{
ILinearList <int> seq_list = new SeqList <int>(5);
seq_list.Reverse();
Assert.IsTrue(seq_list.IsEmpty());
for (int i = 0; i < 5; i++)
{
seq_list.Append(i);
}
seq_list.Reverse();
Assert.AreEqual(4, seq_list.GetElem(0));
Assert.AreEqual(3, seq_list.GetElem(1));
Assert.AreEqual(2, seq_list.GetElem(2));
Assert.AreEqual(1, seq_list.GetElem(3));
Assert.AreEqual(0, seq_list.GetElem(4));
seq_list = new SeqList <int>(1);
seq_list.Append(1);
seq_list.Reverse();
Assert.AreEqual(1, seq_list.GetElem(0));
seq_list = new SeqList <int>(10);
for (int i = 0; i < 10; i++)
{
seq_list.Append(i);
}
seq_list.Reverse();
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(9 - i, seq_list.GetElem(i));
}
}
private void CreateHeap(SeqList <int> sq_list, int low, int high)
{
if ((low >= high) || (high > sq_list.Last))
{
return;
}
for (var i = high / 2; i >= low; --i)
{
var k = i;
var j = 2 * k + 1;
var tmp = sq_list[i];
while (j <= high)
{
if ((j < high) && (j + 1 <= high) &&
(sq_list[j] < sq_list[j + 1]))
{
++j;
}
if (tmp < sq_list[j])
{
sq_list[k] = sq_list[j];
k = j;
j = 2 * k + 1;
}
else
{
j = high + 1;
}
}
sq_list[k] = tmp;
}
}
public void DeleteTest()
{
ILinearList <int> seq_list = new SeqList <int>(5);
seq_list.Delete(0);
for (int i = 0; i < 5; i++)
{
seq_list.Append(i);
}
seq_list.Delete(4);
Assert.AreEqual(4, seq_list.GetLength());
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(i, seq_list.GetElem(i));
}
seq_list.Delete(0);
Assert.AreEqual(3, seq_list.GetLength());
Assert.AreEqual(1, seq_list.GetElem(0));
Assert.AreEqual(2, seq_list.GetElem(1));
Assert.AreEqual(3, seq_list.GetElem(2));
seq_list.Delete(1);
Assert.AreEqual(2, seq_list.GetLength());
Assert.AreEqual(1, seq_list.GetElem(0));
Assert.AreEqual(3, seq_list.GetElem(1));
}
public void RadixSort(SeqList <int> sq_list, int array_x = 10, int array_y = 100)
{
for (int i = 0; i < array_x /* 最大数字不超过999999999...(array_x个9) */; i++)
{
int[,] bucket = new int[array_x, array_y];
foreach (var item in sq_list.Data)
{
int temp = (item / (int)Math.Pow(10, i)) % 10;
for (int l = 0; l < array_y; l++)
{
if (bucket[temp, l] == 0)
{
bucket[temp, l] = item;
break;
}
}
}
for (int o = 0, x = 0; x < array_x; x++)
{
for (int y = 0; y < array_y; y++)
{
if (bucket[x, y] == 0)
{
continue;
}
sq_list[o++] = bucket[x, y];
}
}
}
}
public void InsertRangeList(T[] itemsX, T[] itemsY, int index, int repeat, Func <T[], IEnumerable <T> > constructIEnumerable)
{
var list = new SeqList <T>(constructIEnumerable(itemsX));
for (var i = 0; i < repeat; i++)
{
list.InsertRange(index, new SeqList <T>(constructIEnumerable(itemsY)));
}
foreach (var item in itemsY)
{
Assert.True(list.Contains(item)); //"Should contain the item."
}
Assert.Equal(list.Count, itemsX.Length + (itemsY.Length * repeat)); //"Should have the same result."
for (var i = 0; i < index; i++)
{
Assert.Equal(list[i], itemsX[i]); //"Should have the same result."
}
for (var i = index; i < index + (itemsY.Length * repeat); i++)
{
Assert.Equal(list[i], itemsY[(i - index) % itemsY.Length]); //"Should have the same result."
}
for (var i = index + (itemsY.Length * repeat); i < list.Count; i++)
{
Assert.Equal(list[i], itemsX[i - (itemsY.Length * repeat)]); //"Should have the same result."
}
}
public void SeqListTest()
{
var seq_list = new SeqList <int>(5);
Assert.AreEqual(5, seq_list.MaxSize);
Assert.AreEqual(-1, seq_list.Last);
}
//将两个有序表进行混合得到总的有序表
static SeqList <int> Merge(SeqList <int> la, SeqList <int> lb)
{
SeqList <int> lc = new SeqList <int>(la.Maxsize + lb.Maxsize);
int i = 0;
int j = 0;
while ((i <= (la.GetLength() - 1)) && (j <= (lb.GetLength() - 1)))
{
if (la[i] < lb[j])
{
lc.Append(la[i++]);
}
else
{
lc.Append(lb[j++]);
}
}
while (i <= (la.GetLength() - 1))
{
lc.Append(la[i++]);
}
while (j <= (lb.GetLength() - 1))
{
lc.Append(lb[j++]);
}
return(lc);
}
//堆排序=======================================================================
//建最大堆
private static void CreateHeap(SeqList <int> list, int low, int high)
{
if (low < high && high <= list.Last)
{
int j = 0;
int temp = 0;
int k = 0;
for (int i = high / 2; i >= low; i--)
{
k = i;
j = 2 * k + 1;
temp = list[i];
while (j <= high)
{
if (j < high && j + 1 <= high && list[j] < list[j + 1])
{
j++;
}
if (temp < list[j])
{
list[k] = list[j];
k = j;
j = 2 * k + 1;
}
else
{
j = high + 1;
}
}
list[k] = temp;
}
}
}
//快速排序
//最好情况下快速排序的时间复杂度为O（nlog 2 n）
//在最坏情况下快速排序算法的时间复杂度为O(n^2 )
//快速排序算法在一般情况下的时间复杂度为O（nlog 2 n）
private static void QuickSort(SeqList <int> list, int low, int high)
{
int i = low;
int j = high;
int temp = list[low];
while (low < high)
{
while (low < high && temp <= list[high])
{
high--;
}
list[low] = list[high];
//low++;
while (low < high && temp > list[low])
{
low++;
}
list[high] = list[low];
//high--;
}
list[low] = temp;//到这一步，一次划分完成
if (i < low - 1)
{
QuickSort(list, i, low - 1);
}
if (low + 1 < j)
{
QuickSort(list, low + 1, j);
}
}
public void ClearEmptyList()
{
var list = new SeqList <T>();
Assert.Empty(list); //"Should be equal to 0"
list.Clear();
Assert.Empty(list); //"Should be equal to 0."
}
public void NonExistingValues(T[] itemsX, T[] itemsY)
{
var list = new SeqList <T>(itemsX);
for (var i = 0; i < itemsY.Length; i++)
{
Assert.False(list.Contains(itemsY[i])); //"Should not contain item"
}
}
public void BasicContains(T[] items)
{
var list = new SeqList <T>(items);
for (var i = 0; i < items.Length; i++)
{
Assert.True(list.Contains(items[i])); //"Should contain item."
}
}
public void InsertValidations(T[] items)
{
var list = new SeqList <T>(items);
var bad = new int[] { items.Length + 1, items.Length + 2, int.MaxValue, -1, -2, int.MinValue };
for (var i = 0; i < bad.Length; i++)
{
Assert.Throws <ArgumentOutOfRangeException>(() => list.Insert(bad[i], items[0])); //"ArgumentOutOfRangeException expected."
}
}
public void RemovedValues(T[] items)
{
var list = new SeqList <T>(items);
for (var i = 0; i < items.Length; i++)
{
list.Remove(items[i]);
Assert.False(list.Contains(items[i])); //"Should not contain item"
}
}
public void ClearMultipleTimesNonEmptyList(T[] items, int times)
{
var list = new SeqList <T>(items);
for (var i = 0; i < times; i++)
{
list.Clear();
Assert.Empty(list); //"Should be equal to 0."
}
}
/// <summary>
/// 快速排序
/// </summary>
/// <param name="list"></param>
/// <param name="left"></param>
/// <param name="right"></param>
public void QuickSort(SeqList <int> list, int left, int right)
{
if (left < right)
{
int i = Division(list, left, right);
//对枢轴的左边部分进行排序
QuickSort(list, i + 1, right);
//对枢轴的右边部分进行排序
QuickSort(list, left, i - 1);
}
}
public void BasicToArray(T[] items)
{
var list = new SeqList <T>(items);
var arr = list.ToArray();
for (var i = 0; i < items.Length; i++)
{
Assert.Equal(((Object)arr[i]), items[i]); //"Should be equal."
}
}
/// <summary>
/// 堆排序
/// </summary>
/// <param name="sq_list"></param>
public void HeapSort(SeqList <int> sq_list)
{
CreateHeap(sq_list, 0, sq_list.Last);
for (var i = sq_list.Last; i > 0; --i)
{
var tmp = sq_list[0];
sq_list[0] = sq_list[i];
sq_list[i] = tmp;
CreateHeap(sq_list, 0, i - 1);
}
}
protected void VerifyList(SeqList <T> list, SeqList <T> expectedItems)
{
Assert.Equal(expectedItems.Count, list.Count);
//Only verify the indexer. List should be in a good enough state that we
//do not have to verify consistancy with any other method.
for (var i = 0; i < list.Count; ++i)
{
Assert.True(list[i] == null ? expectedItems[i] == null : list[i].Equals(expectedItems[i]));
}
}
public void GetLengthTest()
{
ILinearList <int> seq_list = new SeqList <int>(5);
Assert.AreEqual(0, seq_list.GetLength());
seq_list.Append(1);
Assert.AreEqual(1, seq_list.GetLength());
seq_list.Append(1);
Assert.AreEqual(2, seq_list.GetLength());
seq_list.Delete(0);
Assert.AreEqual(1, seq_list.GetLength());
}
public void AddRemoveValues(T[] items)
{
var list = new SeqList <T>(items);
for (var i = 0; i < items.Length; i++)
{
list.Add(items[i]);
list.Remove(items[i]);
list.Add(items[i]);
Assert.True(list.Contains(items[i])); //"Should contain item."
}
}
public void InsertRangeValidations(T[] items, Func <T[], IEnumerable <T> > constructIEnumerable)
{
var list = new SeqList <T>(constructIEnumerable(items));
var bad = new int[] { items.Length + 1, items.Length + 2, int.MaxValue, -1, -2, int.MinValue };
for (var i = 0; i < bad.Length; i++)
{
Assert.Throws <ArgumentOutOfRangeException>(() => list.InsertRange(bad[i], constructIEnumerable(items))); //"ArgumentOutOfRangeException expected"
}
Assert.Throws <ArgumentNullException>(() => list.InsertRange(0, null)); //"ArgumentNullException expected."
}
public void ContainsNullWhenReference(T[] items, T value)
{
if ((object)value != null)
{
throw new ArgumentException("invalid argument passed to testcase");
}
var list = new SeqList <T>(items);
list.Add(value);
Assert.True(list.Contains(value)); //"Should contain item."
}
public void IsEmptyTest()
{
ILinearList <int> seq_list = new SeqList <int>(5);
Assert.IsTrue(seq_list.IsEmpty());
seq_list.Append(0);
Assert.IsFalse(seq_list.IsEmpty());
seq_list.Append(1);
Assert.IsFalse(seq_list.IsEmpty());
seq_list.Clear();
Assert.IsTrue(seq_list.IsEmpty());
}
static void Main(string[] args)
{
ILinearList<string> lst = new SeqList<string>(500);
lst.Insert(0, "a1");
lst.Insert(1, "a2");
lst.Insert(2, "a3");
lst.Remove(1);
Console.WriteLine(lst.Length);
for (int i = 0; i < lst.Length; i++)
{
Console.WriteLine(lst[i]);
}
}
public void AppendTest()
{
ILinearList <int> seq_list = new SeqList <int>(5);
for (int i = 0; i < 5; i++)
{
seq_list.Append(i);
}
for (int i = 0; i < 5; i++)
{
Assert.AreEqual(i, seq_list.GetElem(i));
}
}
public void Constructor_IEnumerable(EnumerableType enumerableType, int listLength, int enumerableLength, int numberOfMatchingElements, int numberOfDuplicateElements)
{
var enumerable = CreateEnumerable(enumerableType, null, enumerableLength, 0, numberOfDuplicateElements);
var list = new SeqList <T>(enumerable);
var expected = enumerable.ToList();
Assert.Equal(enumerableLength, list.Count); //"Number of items in list do not match the number of items given."
for (var i = 0; i < enumerableLength; i++)
{
Assert.Equal(expected[i], list[i]); //"Expected object in item array to be the same as in the list"
}
}
public void ClearTest()
{
ILinearList <int> seq_list = new SeqList <int>(5);
for (int i = 0; i < 5; i++)
{
seq_list.Append(i);
}
Assert.AreEqual(5, seq_list.GetLength());
seq_list.Clear();
Assert.AreEqual(0, seq_list.GetLength());
Assert.AreEqual(-1, seq_list.Last);
}
