public void ToStringShouldPrintValuesInOrder()
{
int[] array = new int[] { 5, 12, 15, -61, 0 };
SingleLinkedNode <int> actual = SingleLinkedNode <int> .CreateFromArray(array);
string toString = actual.ToString();
Assert.IsNotNull(toString, "Should not be null string");
Assert.IsNotEmpty(toString, "Should not be empty string");
Assert.AreEqual("5, 12, 15, -61, 0", toString, "String is incorrect");
}
public void LastShouldReturnFinalNode()
{
int[] array = new int[] { 12, 15, -61, 0, 5 };
SingleLinkedNode <int> actual = SingleLinkedNode <int> .CreateFromArray(array);
SingleLinkedNode <int> last = actual.Last();
Assert.IsNotNull(last, "Last should not be null");
Assert.IsTrue(last.IsLast, "IsLast should be true for last node");
Assert.AreEqual(5, last.Value, "Value should be equal to final array value");
}
public override string ToString()
{
StringBuilder s = new StringBuilder();
SingleLinkedNode <T> p = first;
while (p != null)
{
s.Append(p);
}
return(s.ToString());
}
public void SearchShouldReturnNodeWhenValueFound()
{
int[] array = new int[] { 12, 15, -61, 0, 5 };
SingleLinkedNode <int> actual = SingleLinkedNode <int> .CreateFromArray(array);
SingleLinkedNode <int> result = actual.Search(15);
Assert.IsNotNull(result, "Should not return null");
Assert.AreEqual(15, result.Value, "Value");
Assert.AreEqual(-61, result.Next.Value, "Next value");
}
/// <summary>
/// Add a node at the begining of the list
/// </summary>
/// <param name="data">value of the node</param>
public override void AddFirst(T data)
{
// Create a node with the data
SingleLinkedNode <T> newNode = new SingleLinkedNode <T>(data);
if (this.Head.Next != null)
{
newNode.Next = this.Head.Next;
}
this.Head.Next = newNode;
}
public bool Contain(T item)
{
bool isContain = false;
SingleLinkedNode <T> p = head;
while ((p.Next != null) && (!isContain))//一旦找到就可以提前退出循环
{
isContain = item.Equals(p.Next.Item);
p = p.Next;
}
return(isContain);
}
public override string ToString()
{
StringBuilder s = new StringBuilder();
SingleLinkedNode <T> p = head;
while (p.Next != null)
{
s.Append(p.Next);
p = p.Next;
}
return(s.ToString());
}
public SingleLinkedList(T[] itemArray) : this()//使用一个数组创建线性表
{
SingleLinkedNode <T> rear, q;
rear = head;//指向链表尾结点
for (int i = 0; i < itemArray.Length; i++)
{
q = new SingleLinkedNode <T>(itemArray[i]);//新建一个结点
rear.Next = q;
rear = q;
}
}
public static int Sum(SingleLinkedList <int> list1)
{
int sum = 0;
SingleLinkedNode <int> p = list1.Head;
while (p.Next != null)
{
sum += p.Next.Item;
p = p.Next;
}
return(sum);
}
//出圈的人用OutValue表示
public static void JosephusStart2(int n, int s, int d)
{
int OutValue = 0;
//创建包含所有人的一个链表
CircularLinkedList <int> person = new CircularLinkedList <int>();
for (int i = 1; i <= n; i++)
{
person.Add(i);
}
//定位到开始的那个人
SingleLinkedNode <int> start_p = person.Head;
for (int i = 0; i < s; i++)
{
start_p = start_p.Next;
}
int cnt = 0, total = person.Count;
StringBuilder out_sequence = new StringBuilder();
while (total > 1)
{
start_p = start_p.Next;
if (start_p.Item != OutValue)
{
cnt++;
}
if ((cnt != 0) && (cnt % d == 0))//有一个人出圈
{
out_sequence.Append(start_p.Item + " -> ");
start_p.Item = OutValue;
while (start_p.Item == 0)
{
start_p = start_p.Next;
}
cnt = 0;
total--;
person.Show();
Console.WriteLine();
}
}
//只剩最后一个人
while (start_p.Item == 0)
{
start_p = start_p.Next;
}
out_sequence.Append(start_p.Item);
Console.WriteLine("Out sequence:");
Console.WriteLine(out_sequence.ToString());
}
/// <summary>
/// Find the element
/// </summary>
/// <param name="data">an element to find</param>
/// <returns>Target node</returns>
private SingleLinkedNode <T> FindNode(T data)
{
SingleLinkedNode <T> current = this.Head.Next;
while (current != null)
{
if (current.Data.Equals(data))
{
return(current);
}
}
return(null);
}
public T[] ToArray()
{
T[] array = new T[Count];
SingleLinkedNode <T> p = head;
int i = 0;
while (p.Next != null)
{
array[i] = p.Next.Item;
p = p.Next;
i++;
}
return(array);
}
/// <summary>
/// Pops the last added item from the top of the stack.
/// </summary>
/// <remarks>This is an O(1) operation since the size of the stack does not affect how long this operation takes.</remarks>
/// <returns>The last item added to the stack.</returns>
/// <exception cref="StackUnderflowException">Thrown when a call is made to an empty stack.</exception>
public T Pop()
{
if (IsEmpty)
{
throw new StackUnderflowException("Cannot pop from an empty stack");
}
T returnValue = mInnerList.Value;
mInnerList = mInnerList.Next;
Count--;
return(returnValue);
}
/// <summary>
/// Overrides the hook method to set the previous node for an any implementation that uses a double linked list.
/// This override ensures that the double linked list Previous node reference is maintained.
/// </summary>
/// <param name="newNode">The new node.</param>
/// <param name="previousNode">The node being set as the new node's previous node.</param>
protected override void SetPrevious(SingleLinkedNode <T> newNode, SingleLinkedNode <T> previousNode)
{
if (newNode != null && newNode.GetType() == typeof(DoubleLinkedNode <T>))
{
if (previousNode == null)
{
((DoubleLinkedNode <T>)newNode).Previous = null;
}
else if (previousNode.GetType() == typeof(DoubleLinkedNode <T>))
{
((DoubleLinkedNode <T>)newNode).Previous = (DoubleLinkedNode <T>)previousNode;
}
}
}
/// <summary>
/// Add the node at the end of the list
/// </summary>
/// <param name="data">value of the node</param>
public override void AddLast(T data)
{
// Create a node with the data
SingleLinkedNode <T> newNode = new SingleLinkedNode <T>(data);
// Traverse till the end
SingleLinkedNode <T> current = this.Head;
while (current.Next != null)
{
current = current.Next;
}
current.Next = newNode;
}
public void AddRange(T[] itemArray)
{
SingleLinkedNode <T> p = head;
while (p.Next != null)
{
p = p.Next;
}
for (int i = 0; i < itemArray.Length; i++)
{
SingleLinkedNode <T> new_item = new SingleLinkedNode <T>(itemArray[i]);
p.Next = new_item;
p = p.Next;
}
}
public T Pop()
{
T k = default(T);
if (!Empty)
{
k = top.Item;
top = top.Next;
base.Head.Next = top;
return(k);
}
else
{
throw new InvalidOperationException("Stack is Empty: " + this.GetType());
}
}
public void Remove(T item)
{
SingleLinkedNode <T> p = head;
SingleLinkedNode <T> q = head.Next;
while (q.Next != null)
{
if (item.Equals(q.Item))
{
p.Next = q.Next;
break;
}
p = p.Next;
q = q.Next;
}
}
/// <summary>
/// Enqueues an item at the front of the queue.
/// </summary>
/// <remarks>This is an O(1) operation since the size of the queue does not matter.</remarks>
/// <param name="value">The item to be added.</param>
public void EnqueueFirst(T value)
{
SingleLinkedNode <T> node = CreateNode(value);
node.Next = mInnerList;
if (IsEmpty)
{
mLast = node;
}
else
{
SetPrevious(mInnerList, node);
}
mInnerList = node;
mCount++;
}
public void Add(T item)
{
SingleLinkedNode <T> new_item = new SingleLinkedNode <T>(item);
SingleLinkedNode <T> p = first;
if (first == null)
{
first = new_item;
}
else
{
while (p.Next != null)
{
p = p.Next;
}
p.Next = new_item;
}
}
public void RemoveAt(int index)
{
if ((index < 0) || (index >= Count))
{
throw new IndexOutOfRangeException("Index out of Range!!!");
}
else
{
SingleLinkedNode <T> p = head;
SingleLinkedNode <T> q = head.Next;
for (int i = 0; i < index; i++)
{
p = p.Next;
q = q.Next;
}
p.Next = q.Next;
}
}
/// <summary>
/// Adds the supplied <paramref name="value"/> to the end of the queue.
/// </summary>
/// <remarks>This is an O(1) operation as it does not depend on the size of the queue to add a new item.</remarks>
/// <param name="value">The value to be added.</param>
public void Enqueue(T value)
{
SingleLinkedNode <T> node = CreateNode(value);
if (IsEmpty)
{
mInnerList = node;
}
else
{
mLast.Next = node;
SetPrevious(node, mLast);
}
mLast = node;
mCount++;
}
public void InstanceShouldThrowExceptionIfNextIsNotDoubleLinkedNodeType()
{
Assert.DoesNotThrow(() => DoubleLinkedNode <int> .Instance(0, null, null),
"Passing null as next or previous should be fine - indicates first item being added to the list");
DoubleLinkedNode <int> node = DoubleLinkedNode <int> .Instance(0, null, null);
DoubleLinkedNode <int> nextNode = DoubleLinkedNode <int> .Instance(1, null, node);
node.Next = nextNode;
DoubleLinkedNode <int> lastNode = DoubleLinkedNode <int> .Instance(2, null, nextNode);
nextNode.Next = lastNode;
SingleLinkedNode <int> invalidNode = SingleLinkedNode <int> .Instance(-1, node);
_ = Assert.Throws(typeof(ArgumentException), () => { node.Next = invalidNode; }, "Should throw an exception due to invalid type of node");
}
public void InsertRange(int index, T[] itemArray)
{
if ((index < 0) || (index >= Count))
{
throw new IndexOutOfRangeException("Index out of range!!!");
}
else
{
if (index == 0)
{
//保存原来的第一个元素
SingleLinkedNode <T> p = first;
first = new SingleLinkedNode <T>(itemArray[0]);
//新链表的第一个元素
SingleLinkedNode <T> q = first;
for (int i = 1; i < itemArray.Length; i++)
{
//新的数组有多少个元素就必须新建多少个对象
SingleLinkedNode <T> new_item = new SingleLinkedNode <T>(itemArray[i]);
q.Next = new_item;
q = q.Next;
}
q.Next = p;
}
else
{
SingleLinkedNode <T> p = first;
SingleLinkedNode <T> q = first.Next;
for (int i = 1; i < index; i++)
{
p = p.Next;
q = q.Next;
}
for (int i = 0; i < itemArray.Length; i++)
{
//新的数组有多少个元素就必须新建多少个对象
SingleLinkedNode <T> new_item = new SingleLinkedNode <T>(itemArray[i]);
p.Next = new_item;
p = p.Next;
}
p.Next = q;
}
}
}
public int IndexOf(T item)
{
int index = 0;
SingleLinkedNode <T> p = head;
while (p.Next != null)
{
if (item.Equals(p.Next.Item))//一旦找到匹配的就立刻退出函数
{
return(index);
}
else
{
index++;
p = p.Next;
}
}
return(-1);
}
/// <summary>
/// 使用自定义的单向链表实现，将元素删除（未实现）
/// </summary>
public static void singleListSolvePro(int n, int s, int d)
{
int[] a = new int[n];
for (int i = 0; i < n; i++)
{
a[i] = i + 1;
}
// 将n个人依次插入线性表
CircularLinkedList <int> ring = new CircularLinkedList <int>(a);
//ring.Show(true);
SingleLinkedNode <int> p = ring.Head;
int t = 0, k = 0;
while (p != null)
{
if (ring.Count == 1)
{
break;
}
if (k < s - 1)
{
k++;
// 因为链表长度肯定大于s，因此不判断next为空
p = p.Next;
continue;
}
t++;
if (t % d == 0)
{
p.Next = p.Next.Next;
//ring.Show(true);
}
else
{
p = p.Next;
}
}
//Console.WriteLine("Out : " + ring[i]);
ring.Show(true);
//Console.WriteLine("\n{0} is the last person.", );
}
//出圈的人直接从链表中去掉
public static void JosephusStart1(int n, int s, int d)
{
//创建包含所有人的一个链表
CircularLinkedList <int> person = new CircularLinkedList <int>();
for (int i = 1; i <= n; i++)
{
person.Add(i);
}
//定位到开始的那个人
SingleLinkedNode <int> start_p = person.Head;
for (int i = 0; i < s; i++)
{
start_p = start_p.Next;
}
int cnt = 0;
StringBuilder out_sequence = new StringBuilder();
while (person.Count > 1)
{
start_p = start_p.Next;
cnt++;
if ((cnt != 0) && (cnt % d == 0))
{
//利用cnt暂时存放一下出圈人的编号，可以避免新建一个变量
cnt = start_p.Item;
start_p = start_p.Next;
out_sequence.Append(cnt + " -> ");
person.Remove(cnt);
cnt = 0;
person.Show();
Console.WriteLine();
}
}
//只剩最后一个人
out_sequence.Append(person.Head.Next.Item);
Console.WriteLine("Out sequence:");
Console.WriteLine(out_sequence.ToString());
}
//索引器
public virtual T this[int i]
{
get
{
if ((i < 0) || (i >= Count))
{
throw new IndexOutOfRangeException("Index is out of range " + this.GetType());
}
else
{
SingleLinkedNode <T> p = head.Next;
while (i > 0)
{
p = p.Next;
i--;
}
return(p.Item);
}
}
}
public T Dequeue()
{
T k = default(T);
if (!Empty)
{
k = front.Item;
front = front.Next;
items.Head.Next = front;
if (front == null)
{
rear = items.Head;
}
return(k);
}
else
{
throw new InvalidOperationException("Queue is Empty: " + this.GetType());
}
}
public void Insert(int index, T item)
{
if ((index < 0) || (index >= Count))
{
throw new IndexOutOfRangeException("Index is out of range " + this.GetType());
}
else
{
SingleLinkedNode <T> p = head;
SingleLinkedNode <T> q = head.Next;
SingleLinkedNode <T> new_item = new SingleLinkedNode <T>(item);
for (int i = 0; i < index; i++)
{
p = p.Next;
q = q.Next;
}
p.Next = new_item;
new_item.Next = q;
}
}
