public bool isPalindromStackRelease()
{
bool res = true;
if (countOfElements > 2)
{
Stack <T> stack = new Stack <T>();
listElement <T> current = firstElement;
while (current != null)
{
stack.Push(current.element);
current = current.nextElement;
}
current = firstElement;
for (int i = 0; i < countOfElements / 2; i++)
{
if (current.element.CompareTo(stack.Pop()) != 0)
{
res = false;
break;
}
current = current.nextElement;
}
}
return(res);
}
public void add(listElement <T> element)
{
int counter = 1;
if (countOfElements == 0)
{
//newEl.nextElement = null;
element.prevElement = null;
firstElement = element;
}
else
{
if (lastElement == null)
{
return;
}
element.prevElement = lastElement;
lastElement.nextElement = element;
//newEl.nextElement = null;
listElement <T> current = element;
listElement <T> prevEl = current;
while (current != null)
{
prevEl = current;
current = current.nextElement;
if (current == null)
{
lastElement = prevEl;
break;
}
counter++;
}
}
countOfElements = countOfElements + counter;
}
public void delete(listElement <T> element)
{
if (countOfElements > 0 && element != null)
{
if (element == firstElement)
{
if (element.nextElement != null)
{
element.nextElement.prevElement = null;
}
firstElement = element.nextElement;
}
else if (element == lastElement)
{
if (element.prevElement != null)
{
element.prevElement.nextElement = null;
}
lastElement = element.prevElement;
}
else
{
if (element.nextElement != null)
{
element.nextElement.prevElement = element.prevElement;
}
if (element.prevElement != null)
{
element.prevElement.nextElement = element.nextElement;
}
}
countOfElements--;
}
}
public listElement <T> findAndGetCircledElement2PointerRealise()
{
listElement <T> res = null;
if (countOfElements > 1)
{
listElement <T> fast = firstElement;
listElement <T> slow = firstElement;
while (fast != null || fast.nextElement != null)
{
slow = slow.nextElement;
fast = fast.nextElement.nextElement;
if (slow == fast)
{
break;
}
}
if (fast == null || fast.nextElement == null)
{
return(res);
}
slow = firstElement;
while (slow != fast)
{
slow = slow.nextElement;
fast = fast.nextElement;
}
res = slow;
}
return(res);
}
public bool isPalindrom()
{
bool res = true;
if (countOfElements > 2)
{
listElement <T>[] mas = new listElement <T> [countOfElements];
listElement <T> current = firstElement;
int i = 0;
while (current != null)
{
mas[i] = current;
i++;
current = current.nextElement;
}
//int middle = countOfElements / 2;
for (i = 0; i < countOfElements / 2; i++)
{
if (mas[i].element.CompareTo(mas[countOfElements - i - 1].element) != 0)
{
res = false;
break;
}
}
}
return(res);
}
public void createCircle(listElement <T> circleElement)
{
if (circleElement != null && circleElement.nextElement != null)
{
lastElement.nextElement = circleElement;
lastElement = null;
}
}
public T getElement(int indexOfElement)
{
if (indexOfElement < mas.Length)
{
listElement resElement = mas[indexOfElement];
return(resElement.element);
}
return(default(T));
}
public void delete(T element)
{
if (countOfElements > 0)
{
listElement <T> current = firstElement;
bool isExist = false;
while (current != null)
{
if (current.element.Equals(element))
{
isExist = true;
break;
}
if (current.nextElement != null)
{
current = current.nextElement;
}
else
{
break;
}
}
if (isExist)
{
if (current == lastElement)
{
if (current.prevElement != null)
{
current.prevElement.nextElement = null;
}
lastElement = current.prevElement;
}
else if (current == firstElement)
{
current.nextElement.prevElement = null;
firstElement = current.nextElement;
}
else
{
current.nextElement.prevElement = current.prevElement;
current.prevElement.nextElement = current.nextElement;
}
if (isExist)
{
countOfElements--;
}
}
}
}
private listElement <T> recurseivePalindromCheck(listElement <T> next, int count)
{
listElement <T> res;
if (count >= countOfElements / 2)
{
if (countOfElements % 2 > 0)
{
if (next.element.CompareTo(next.nextElement.nextElement.element) != 0)
{
return(null);
}
else
{
return(next.nextElement.nextElement.nextElement);
}
}
else
if (next.element.CompareTo(next.nextElement.element) != 0)
{
return(null);
}
else
{
return(next.nextElement.nextElement);
}
}
res = recurseivePalindromCheck(next.nextElement, ++count);
if (res != null)
{
if (next.element.CompareTo(res.element) != 0)
{
return(null);
}
else if (res.nextElement != null)
{
return(res.nextElement);
}
else
{
return(firstElement);
}
}
return(null);
//else if (count != 1)
// return null;
//else
// return firstElement;
}
public linkedList()
{
mas = new listElement[10];
countOfElements = 0;
listElement element = new listElement();
element.nextElement = 0;
element.prevElement = 0;
element.isAlive = false;
mas[0] = element;
lastInserted = 0;
firstElement = -1;
nextIndForInsertion = 0;
deletedElement = -1;
}
public listElement <T> findElFromEnd_recursiveRealise(int indexFromEnd)
{
if (countOfElements > indexFromEnd)
{
if (indexFromEnd == countOfElements - 1)
{
return(firstElement);
}
else
{
listElement <T> result = findElFromEnd_recursiveRealise(indexFromEnd + 1);
return(result.nextElement);
}
}
return(null);
}
static public linkedList2 <int> add(linkedList2 <int> a, linkedList2 <int> b)
{
linkedList2 <int> res = new linkedList2 <int>();
res.add(0);
listElement <int> currentA = a.firstElement;
listElement <int> currentB = b.firstElement;
listElement <int> currentRes = res.firstElement;
while (currentA != null || currentB != null)
{
if (currentB != null && currentA != null)
{
currentRes.element += currentA.element + currentB.element;
currentA = currentA.nextElement;
currentB = currentB.nextElement;
if (currentRes.element >= 10)
{
res.add(1);
int rest = currentRes.element % 10;
currentRes.element = rest;
}
else
{
res.add(0);
}
currentRes = currentRes.nextElement;
continue;
}
else if (currentA != null)
{
currentRes.element += currentA.element;
currentA = currentA.nextElement;
}
else if (currentB != null)
{
currentRes.element += currentB.element;
currentB = currentB.nextElement;
}
if (currentA != null || currentB != null)
{
res.add(0);
}
currentRes = currentRes.nextElement;
}
return(res);
}
public void add(T newElement)
{
if (countOfElements >= mas.Length)
{
listElement[] newMas = new listElement[mas.Length * 2];
for (int i = 0; i < mas.Length; i++)
{
newMas[i] = mas[i];
}
mas = newMas;
}
int indPlace = -1;
if (deletedElement > -1)
{
indPlace = deletedElement;
if (mas[deletedElement].nextElement > -1)
{
deletedElement = mas[deletedElement].nextElement;
}
else
{
deletedElement = -1;
}
}
else
{
indPlace = nextIndForInsertion;
nextIndForInsertion++;
}
listElement newElem = new listElement();
newElem.element = newElement;
newElem.nextElement = -1;
newElem.prevElement = lastInserted;
newElem.isAlive = true;
mas[lastInserted].nextElement = indPlace;
mas[indPlace] = newElem;
lastInserted = indPlace;
countOfElements++;
if (firstElement == -1)
{
firstElement = indPlace;
}
}
public listElement <T> findElForOneLinkedListFromEnd(int indexFromEnd)
{
if (countOfElements > 0 && countOfElements > indexFromEnd)
{
listElement <T> current = firstElement;
int currentCount = 0;
while (current != null)
{
if (currentCount == countOfElements - indexFromEnd - 1)
{
return(current);
}
currentCount++;
current = current.nextElement;
}
}
return(null);
}
public bool isPalindromRecursiveRelease()
{
if (countOfElements > 2)
{
listElement <T> res = recurseivePalindromCheck(firstElement, 1);
if (res == firstElement)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(true);
}
}
public void deleteDoublesHashTb()
{
if (countOfElements > 1)
{
Hashtable hashTb = new Hashtable();
listElement <T> current = firstElement;
while (current != null)
{
if (hashTb.Contains(current.element))
{
delete(current);
}
else
{
hashTb.Add(current.element, current);
}
current = current.nextElement;
}
}
}
public static listElement <T> findIntersection(linkedList2 <T> a, linkedList2 <T> b)
{
listElement <T> res = null;
if (a.findElForOneLinkedListFromEnd_2pointerRealise(0) == b.findElForOneLinkedListFromEnd_2pointerRealise(0))
{
int difference = 0;
listElement <T> currentA = a.findElForOneLinkedListFromEnd_2pointerRealise(a.countOfElements - 1);
listElement <T> currentB = b.findElForOneLinkedListFromEnd_2pointerRealise(b.countOfElements - 1);
if (a.countOfElements >= b.countOfElements)
{
difference = a.countOfElements - b.countOfElements;
while (difference > 0)
{
currentA = currentA.nextElement;
difference--;
}
}
else
{
difference = b.countOfElements - a.countOfElements;
while (difference > 0)
{
currentB = currentB.nextElement;
difference--;
}
}
while (currentA != null && currentB != null)
{
if (currentA == currentB)
{
res = currentA;
break;
}
currentA = currentA.nextElement;
currentB = currentB.nextElement;
}
}
return(res);
}
public void deleteDoubles()
{
if (countOfElements < 2)
{
return;
}
listElement <T> current = firstElement;
while (current != lastElement && current != null)
{
listElement <T> compareEl = current;
while (compareEl != null)
{
if (compareEl.nextElement != null && current.element.Equals(compareEl.nextElement.element))
{
delete(compareEl.nextElement);
}
compareEl = compareEl.nextElement;
}
current = current.nextElement;
}
}
public void deleteMiddleEl()
{
if (countOfElements > 0)
{
int ends = countOfElements % 2;
int indexOfMiddle = 0;
if (ends > 0)
{
indexOfMiddle = countOfElements / 2;
}
else
{
indexOfMiddle = (countOfElements / 2) - 1;
}
listElement <T> current = firstElement;
for (int i = 0; i < indexOfMiddle; i++)
{
current = current.nextElement;
}
delete(current);
}
}
public void devideListByEl(T devider)
{
if (countOfElements > 1)
{
listElement <T> current = firstElement.nextElement;
listElement <T> prev = firstElement;
while (current != null)
{
if (current.element.CompareTo(devider) < 0)
{
prev.nextElement = current.nextElement;
current.nextElement = firstElement;
firstElement = current;
current = prev.nextElement;
}
else
{
prev = current;
current = current.nextElement;
}
}
}
}
public listElement <T> findAndGetCircledElementHashTableRealise()
{
listElement <T> res = null;
if (countOfElements > 1)
{
Hashtable ht = new Hashtable();
listElement <T> current = firstElement;
int counter = countOfElements;
while (counter >= 0 && current != null)
{
if (ht.Contains(current))
{
res = current;
break;
}
ht.Add(current, current.element);
current = current.nextElement;
counter--;
}
}
return(res);
}
public listElement <T> findElForOneLinkedListFromEnd_2pointerRealise(int indexfromEnd)
{
if (countOfElements > indexfromEnd)
{
//int ffstPointer = 0;
//int slowdPointer = 0;
int counter = countOfElements;
listElement <T> fastPointerEl = firstElement;
for (int i = 1; i <= indexfromEnd; i++)
{
fastPointerEl = fastPointerEl.nextElement;
counter--;
}
listElement <T> slowPointerEl = firstElement;
while (counter > 1)
{
fastPointerEl = fastPointerEl.nextElement;
slowPointerEl = slowPointerEl.nextElement;
counter--;
}
return(slowPointerEl);
}
return(null);
}
public void add(T element)
{
listElement <T> newEl = new listElement <T>();
newEl.element = element;
if (countOfElements == 0)
{
newEl.nextElement = null;
newEl.prevElement = null;
firstElement = newEl;
}
else
{
if (lastElement == null)
{
return;
}
newEl.prevElement = lastElement;
newEl.nextElement = null;
lastElement.nextElement = newEl;
}
lastElement = newEl;
countOfElements++;
}
