public void SetNawAt(int index, NAW naw)
{
if (index < _length)
{
if (index == 0)
{
_first.Naw = naw;
}
else if (index == _length - 1)
{
_last.Naw = naw;
}
else
{
Link current = _first;
for (int i = 0; i <= index; i++)
{
if (i == index)
{
current.Naw = naw;
}
current = current.Next;
}
}
} //invalid index
}
public void RemoveAllNaw(NAW naw)
{
Link current = _first;
Link previous = null;
Link previousLast = null;
while (current != null)
{
if (current.Naw.CompareTo(naw) == 0)
{
if (current == _first)
{
_first = current.Next;
}
else if (current == _last)
{
_last = previousLast;
}
previous.Next = current.Next;
_length--;
}
else
{
previousLast = current;
}
previous = current;
current = current.Next;
}
}
static void Main(string[] args)
{
NawQueueArray nawQueueArray = new NawQueueArray(4);
NAW naw1 = new NAW("ABC", "straat", "schijndel");
NAW naw2 = new NAW("YIJD", "dropstraat", "den bosch");
NAW naw3 = new NAW("DEF", "kerkstraat", "amsterdam");
NAW naw4 = new NAW("DEF", "dorpstraat", "amsterdam");
NAW naw5 = new NAW("ABC", "kerkstraat", "amsterdam");
nawQueueArray.Enqueue(naw1);
nawQueueArray.Enqueue(naw2);
nawQueueArray.Enqueue(naw3);
nawQueueArray.Enqueue(naw4);
nawQueueArray.Dequeue();
nawQueueArray.Enqueue(naw5);
nawQueueArray.Enqueue(naw1);
var winkel = new Winkel(3, 8, 10);
winkel.Run();
System.Console.ReadKey();
}
//
// Workshop methodes
//
public void InsertHead(NAW naw)
{
//throw new NotImplementedException();
DoubleLink _current = First;
DoubleLink _previous;
First.Naw = naw;
First.Next = _current;
First.Previous = null;
_previous = First;
_current.Previous = _previous;
if (_current.Next != null)
{
while (_current.Next != null)
{
_previous = _current;
_current = _current.Next;
_current.Previous = _previous;
}
}
else
{
Last = _current;
}
}
public void BubbleSort()
{
int swapped;
DoubleLink inner;
DoubleLink outer = new DoubleLink();
if (First == null)
{
return;
}
do
{
swapped = 0;
inner = First;
while (inner.Next != outer && inner.Next != null)
{
if (inner.Naw.CompareTo(inner.Next.Naw) > 0)
{
NAW n = inner.Naw;
inner.Naw = inner.Next.Naw;
inner.Next.Naw = n;
swapped = 1;
}
inner = inner.Next;
}
outer = inner;
}while (swapped != 0);
}
public void NawArrayUnordered_Add_Valid_ShouldAddAtTheEnd()
{
const int capacity = 10;
const int filled = 5;
WithUnordenedArray(capacity, filled, arr =>
{
var prevState = new NAW[filled];
WithoutLogging(() =>
{
for (int i = 0; i < filled; ++i)
{
prevState[i] = arr.Array[i];
}
});
WithoutCallingArrayMethods(() =>
{
arr.Add(RandomNawGenerator.New());
});
for (int i = 0; i < filled; ++i)
{
Assert.AreSame(prevState[i], arr.Array[i], "Jouw Add methode van NAWArrayUnordered doet ook iets met de elementen die al in de array zaten. Dit is niet de bedoeling");
}
});
}
public int FindBinary(NAW item)
{
int lowerBound = 0;
int upperBound = _used - 1;
int curIn;
while (lowerBound <= upperBound)
{
curIn = (lowerBound + upperBound) / 2;
if (_nawArray[curIn] == item)
{
return(curIn); //found it
}
else if (lowerBound > upperBound)
{
return(_used); // can't find it
}
else
{
if (_nawArray[curIn].CompareTo(item) == -1)
{
lowerBound = curIn + 1; // it's in upper half
}
else
{
upperBound = curIn - 1; // it's in lower half
}
}
}
return(-1);
}
public int Find(NAW item)
{
if (_used > 0)
{
// kan item in array voorkomen
if ((_nawArray[0].CompareTo(item) > 0))
{
return(-1);
}
if ((_nawArray[_used - 1].CompareTo(item) < 0))
{
return(-1);
}
else
{ // doorzoek array
for (int i = 0; i < _used; i++)
{
if (_nawArray[i].CompareTo(item) == 0)
{
return(i);
}
else if (_nawArray[i].CompareTo(item) >= 1)
{
return(-1);
}
}
}
}
return(-1);
}
public NAW Find(string naam)
{
int newHash = naam.GetHashCode(); //Something something % modulo
if (_array == null)
{
return(null);
}
int index = Math.Abs(newHash % Size);
int originalIndex = index;
NAW foundItem = null;
while (foundItem == null)
{
if (_array[index] != null && !_array[index].IsDeleted)
{
if (_array[index].Value.Naam.Equals(naam))
{
foundItem = _array[index].Value;
}
}
index++;
if (index > _array.Size - 1)
{
index = 0;
}
if (index == originalIndex)
{
break;
}
}
return(foundItem);
}
public int FindBinary(NAW item)
{
int lowerBound = 0;
int upperBound = _used - 1;
int currentInt;
while (true)
{
currentInt = (lowerBound + upperBound) / 2;
if (_nawArray[currentInt] == item)
{
return(currentInt);
}
else if (lowerBound > upperBound)
{
return(-1);
}
else
{
if (_nawArray[currentInt].CompareTo(item) > 0)
{
lowerBound = currentInt + 1;
}
else
{
upperBound = currentInt - 1;
}
}
}
}
public int FindBinary(NAW item)
{
int lowerbound = 0;
int upperbound = (_used - 1);
int curInt;
if (_used == 0)
{
return(-1);
}
while (true)
{
curInt = (upperbound + lowerbound) / 2;
if (_nawArray[curInt].CompareTo(item) == 0)
{
return(curInt);
}
else if (_nawArray[curInt].CompareTo(item) == -1)
{
lowerbound = curInt + 1;
}
else if (_nawArray[curInt].CompareTo(item) == 1)
{
upperbound = curInt - 1;
}
}
}
public virtual void Add(NAW item)
{
if (_used == _size)
{
throw new NawArrayOrderedOutOfBoundsException();
}
else if (_used == 0)
{
_nawArray[0] = item;
_used++;
}
else
{
int i;
for (i = 0; i < _used; i++)
{
if (_nawArray[i].CompareTo(item) == 1 || _nawArray[i].CompareTo(item) == 0)
{
break;
}
}
for (int j = _used; j > i; j--)
{
_nawArray[j] = _nawArray[j - 1];
}
_nawArray[i] = item;
_used++;
}
}
public static LogItem SetItem(int index, NAW oldNAW, NAW newNAW) => new LogItem
{
OldNaw1 = oldNAW,
NewNaw1 = newNAW,
Index1 = index,
ArrayAction = ArrayAction.SET
};
public virtual void Add(NAW item)
{
if (_used < _size)
{
int _insertIndex;
for (_insertIndex = 0; _insertIndex < _used; _insertIndex++)
{
if (item.CompareTo(_nawArray[_insertIndex]) == -1)
{
for (int j = _used; j > _insertIndex; j--)
{
_nawArray[j] = _nawArray[j - 1];
}
_nawArray[_insertIndex] = item;
_used++;
return;
}
}
_nawArray[_used] = item;
_used++;
}
else
{
throw new NawArrayOrderedOutOfBoundsException();
}
}
/// <summary>
/// Tests the complexity of binary and linear search and outputs the results
/// to standard output.
/// </summary>
public static void TestSearchPerformance()
{
Logger.Instance.Enabled = false;
var sizes = new int[] { 100, 1000, 10000 };
//Func<int, Action, double> time = (repetitions, fun) =>
//{
// var watch = System.Diagnostics.Stopwatch.StartNew();
// for (var i = 0; i < repetitions; ++i)
// fun();
// watch.Stop();
// return watch.ElapsedMilliseconds;
//};
var tries = 100;
var celestialTeapot = new NAW("77777777777", "77777777777", "77777777777");
Console.WriteLine("Size\tLinear (ms)\tBinary (ms)");
for (var sizeIx = 0; sizeIx < sizes.Length; ++sizeIx)
{
var size = sizes[sizeIx];
var array = FilledArrayOfSize(size);
double lin = Time(tries, () => array.Find(celestialTeapot)) / 1000;
double bin = Time(tries, () => array.FindBinary(celestialTeapot)) / 1000;
Console.WriteLine($"{sizes[sizeIx]}\t{lin}\t\t{bin}");
}
}
public virtual NAW Delete(string key)
{
if (key == null)
{
return(null);
}
LogFileLink temp = Head;
LogFileLink previous = null;
while (temp != null)
{
if (temp.Key.Equals(key))
{
if (temp == Head)
{
Head = temp.Next;
}
else
{
previous.Next = temp.Next;
}
NAW target = temp.Value;
temp.Next = null;
return(target);
}
previous = temp;
temp = temp.Next;
}
return(null);
}
public void AddBinary(NAW item)
{
int lowerBound = 0;
int upperBound = _used - 1;
int currentInt;
while (true)
{
currentInt = (lowerBound + upperBound) / 2;
if (_nawArray[currentInt].CompareTo(item) > 0 || _nawArray[currentInt + 1].CompareTo(item) < 0)
{
for (int k = _used; k > currentInt; k--)
{
_nawArray[k] = _nawArray[k - 1];
}
_nawArray[currentInt] = item;
break;
}
else
{
if (_nawArray[currentInt].CompareTo(item) < 0)
{
lowerBound = currentInt + 1;
}
else
{
upperBound = currentInt - 1;
}
}
}
}
public void NawHashTable_Find_ShouldFindFirstOccurences()
{
// Arrange
NawHashTable hashtable = new NawHashTable(10);
hashtable.Add(naw0);
hashtable.Add(naw1);
hashtable.Add(naw2);
hashtable.Add(naw3);
hashtable.Add(naw4);
hashtable.Add(naw5);
hashtable.Add(naw6);
hashtable.Add(naw7);
hashtable.Add(naw8);
hashtable.Add(naw9);
Logger.Instance.ClearLog();
// Act
NAW nawFound4 = hashtable.Find(naw4.Naam);
NAW nawFound5 = hashtable.Find(naw5.Naam);
NAW nawFound6 = hashtable.Find(naw6.Naam);
NAW nawFound7 = hashtable.Find(naw7.Naam);
// Assert
Assert.IsTrue(nawFound4 != null && nawFound5 != null && nawFound6 != null && nawFound7 != null, "Een of meerdere elementen zijn onterecht niet gevonden.");
Assert.IsTrue(nawFound4.CompareTo(naw0) == 0, "Voor {0} is niet de eerste gevonden.", naw0.Naam);
Assert.IsTrue(nawFound5.CompareTo(naw1) == 0, "Voor {0} is niet de eerste gevonden.", naw0.Naam);
Assert.IsTrue(nawFound6.CompareTo(naw2) == 0, "Voor {0} is niet de eerste gevonden.", naw0.Naam);
Assert.IsTrue(nawFound7.CompareTo(naw3) == 0, "Voor {0} is niet de eerste gevonden.", naw0.Naam);
}
public int FindBinary(NAW item)
{
int lowerBound = 0;
int upperBound = _used - 1;
int curIn;
if (upperBound != -1)
{
while (true)
{
curIn = (lowerBound + upperBound) / 2;
if (_nawArray[curIn] == item)
{
return(curIn);
}
else
{
if (_nawArray[curIn].CompareTo(item) == -1)
{
lowerBound = curIn + 1;
}
else
{
upperBound = curIn - 1;
}
}
}
}
else
{
return(-1);
}
}
public void AddBinary(NAW item)
{
int lowerBound = 0;
int upperBound = _used - 1;
int curIn;
if (upperBound != -1)
{
while (true)
{
curIn = (lowerBound + upperBound) / 2;
if (lowerBound == upperBound)
{
for (int i = curIn; i <= _used; i++)
{
NAW temp;
NAW curr = _nawArray[i];
NAW next = _nawArray[i + 1];
temp = next;
next = curr;
curr = temp;
}
}
else if (_nawArray[curIn].CompareTo(item) == -1)
{
lowerBound = curIn + 1;
}
else
{
upperBound = curIn - 1;
}
}
}
}
public NAWViewModel()
{
_naw = new NAW {
Name = "Unknown", Address = "Unknown", City = "Unknown", Telephone = -1
};
SaveCommand = new RelayCommand(Save);
}
public void NawArrayUnordered_InsertionSort_EightAndFourSwapped_ShouldNotSetWhenNotSwapped()
{
// Arrange
NAW[] testSet;
var expectedLength = 10;
var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet);
var newNaw = RandomNawGenerator.New();
testSet[0].Woonplaats = "0";
testSet[1].Woonplaats = "1";
testSet[2].Woonplaats = "2";
testSet[3].Woonplaats = "3";
testSet[4].Woonplaats = "8";
testSet[5].Woonplaats = "5";
testSet[6].Woonplaats = "6";
testSet[7].Woonplaats = "7";
testSet[8].Woonplaats = "4";
testSet[9].Woonplaats = "9";
// Act
Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;
array.InsertionSort();
// Assert
Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");
Assert.IsTrue(array.CheckIsGesorteerd(), "De array is niet gesorteerd na de InsertionSort.");
int lowerBound = 4, upperBound = 8;
NAW toMoveUp = testSet[lowerBound];
var toMoveUpSetters = (from li in Logger.Instance.LogItems
where li.NewNaw1 == toMoveUp && li.ArrayAction == ArrayAction.SET
orderby li.Index1
select li).ToArray();
// This one bubbles up slowly.
for (int i = lowerBound + 1; i <= upperBound; i++)
{
Assert.IsTrue(toMoveUpSetters[i - lowerBound - 1].Index1 == i, "Er zouden 4 items verplaatst moeten zijn om ruimte te maken in het geordende deel.");
}
NAW toBeInsertedDown = testSet[upperBound];
var toBeInsertedDownSetters = (from li in Logger.Instance.LogItems
where li.NewNaw1 == toBeInsertedDown && li.ArrayAction == ArrayAction.SET
orderby li.Index1
select li).ToArray();
// This one moves down in an insertion way.
Assert.AreEqual(1, toBeInsertedDownSetters.Count(), "Meerdere items zijn geïnsert in de sortering, dit had er 1 moeten zijn.");
Assert.AreEqual(lowerBound, toBeInsertedDownSetters.First().Index1, "Item met woonplaats 4 zou op de 4e index geïnsert moeten zijn.");
// All setters must be in between the bounds.
Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.SET).All(li => li.Index1 >= lowerBound && li.Index1 <= upperBound)
, "Je hebt items gezet waarbij de oude index gelijk was aan de nieuwe, dit is niet nodig.");
}
public void InsertionSortNawArray_InsertionSort_EightAndFourSwapped_ShouldNotSetWhenNotSwapped()
{
// Arrange
NAW[] testSet;
var expectedLength = 10;
var array = ArrayExtensions.InitializeTestSubject(new NawArrayUnordered(expectedLength), expectedLength, out testSet);
var newNaw = RandomNawGenerator.New();
testSet[0].Woonplaats = "0";
testSet[1].Woonplaats = "1";
testSet[2].Woonplaats = "2";
testSet[3].Woonplaats = "3";
testSet[4].Woonplaats = "8";
testSet[5].Woonplaats = "5";
testSet[6].Woonplaats = "6";
testSet[7].Woonplaats = "7";
testSet[8].Woonplaats = "4";
testSet[9].Woonplaats = "9";
// Act
Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled = false;
array.InsertionSort();
// Assert
Assert.IsFalse(Alg1_Practicum_Utils.Globals.Alg1NawArrayMethodCalled, "\n\nEr wordt een methode van Alg1NawArray gebruikt!\n\n");
Assert.IsTrue(array.CheckIsGesorteerd());
int lowerBound = 4, upperBound = 8;
NAW toMoveUp = testSet[lowerBound];
var toMoveUpSetters = (from li in Logger.Instance.LogItems
where li.NewNaw1 == toMoveUp && li.ArrayAction == ArrayAction.SET
orderby li.Index1
select li).ToArray();
// This one bubbles up slowly.
for (int i = lowerBound + 1; i <= upperBound; i++)
{
Assert.IsTrue(toMoveUpSetters[i - lowerBound - 1].Index1 == i);
}
NAW toBeInsertedDown = testSet[upperBound];
var toBeInsertedDownSetters = (from li in Logger.Instance.LogItems
where li.NewNaw1 == toBeInsertedDown && li.ArrayAction == ArrayAction.SET
orderby li.Index1
select li).ToArray();
// This one moves down in an insertion way.
Assert.AreEqual(1, toBeInsertedDownSetters.Count());
Assert.AreEqual(lowerBound, toBeInsertedDownSetters.First().Index1);
// All setters must be in between the bounds.
Assert.IsTrue(Logger.Instance.LogItems.Where(li => li.ArrayAction == ArrayAction.SET).All(li => li.Index1 >= lowerBound && li.Index1 <= upperBound));
}
public override bool Remove(NAW naw)
{
if (base.Remove(naw))
{
AddOperation(Operation.REMOVE, naw);
return(true);
}
return(false);
}
public override bool Remove(NAW item)
{
if (!DoRemove(item))
{
return(false);
}
AddOperation(Operation.Remove, item);
return(true);
}
static void Main(string[] args)
{
// voorbeeld uitprobeercode
var nieuwArray = new NawArrayUnordered(20);
nieuwArray.Add(new NAW("Persoon1", "Adres1", "Woonplaats1"));
var persoon = new NAW("Persoon 1", "Adres 5", "Woonplaats 1");
int index = nieuwArray.FindNaam(persoon.Naam);
}
private SortedDictionary <int, NawQueueLinkedList> _priorityQueue = new SortedDictionary <int, NawQueueLinkedList>(); // <= vervang hier Object met een geschikte combinatie van een .net klasse en jouw eigen NawQueueLinkedList Klasse
public void Enqueue(int priority, NAW naw)
{
if (!_priorityQueue.ContainsKey(priority))
{
_priorityQueue.Add(priority, new NawQueueLinkedList());
}
_count++;
_priorityQueue[priority].Enqueue(naw);
}
public void Insert(string key, NAW value)
{
if (key.Equals(null))
{
throw new ArgumentNullException();
}
logFiles[KeyToIndex(key)].Insert(key, value);
count++;
}
public virtual void Insert(string key, NAW value)
{
if (key == null)
{
throw new ArgumentNullException();
}
LogFileLink temp = new LogFileLink(key, value, Head);
Head = temp;
}
private bool DoRemove(NAW naw)
{
var index = Find(naw);
if (index < 0)
{
return(false);
}
RemoveAtIndex(index);
return(true);
}
