C# списки

[Esc16]

Нужна помощь с C#
Класс MyLinkedList2 - упорядоченное множество чисел - задается в виде двусвязного списка.

Реализовать методы:
• MyLinkedList2(int [] arr): создание списка на основе целочисленного массива,
• int [] decode(): вывод значений списка в текстовый файл,
• void insert(int k): вставка элемента k в список,
• void delete(int k): удаление элемента, равного k, из списка,
• MyLinkedList2 merge(MyLinkedList2 ll1): возврат упорядоченного списка, полученного слиянием данного списка и списка ll1.
• int maxNum(): найти максимальное число одинаковых элементов списка;
• MyLinkedList2 [] divide(): разбить список на два: в первый список попадают все числа кратные трем, во второй – все остальные. Возвратить массив из двух ссылок, содержащие начала списка.
• MyLinkedList2 newList(): построить новый упорядоченный список по правилу (каждый элемент нового списка является произведением j и (n-j) элемента исходного списка)
Было сделано замечание:
"во-первых, убирай вот это
arr1.CopyTo(arr, 0);
arr2.CopyTo(arr, arr1.Count());
Array.Sort(arr);
без коллекций надо сделать эту задачу.

далее. Insert должен вставлять элемент в упорядоченное множество. Не вижу, где это учитывается.

использование decode() в divide() и других методах - лишняя память, надо переделать без нее надо.
и вообще, массивы использовать в этом методе - не нужно, лишняя трата памяти. Все на списках построить."
Собственно сам код

[Esc16]

 class MyLinkedList2
    {
        public MyLinkedListElement ListBegin = null;
        public MyLinkedListElement ListEnd = null;
        private int elementsCount;

        public MyLinkedList2(int[] arr)
        {
            foreach (int arrElement in arr)
            {
                MyLinkedListElement listElement = new MyLinkedListElement();
                listElement.Value = arrElement;
                if (ListBegin == null && ListEnd == null)
                {
                    ListBegin = listElement;
                    ListEnd = listElement;
                }
                else
                {
                    ListEnd.nextElement = listElement;
                    listElement.prevElement = ListEnd;
                    ListEnd = listElement;
                }
                elementsCount++;
            }
        }

        public int[] decode()
        {
            MyLinkedListElement currentElement = ListBegin;
            int[] returnArray = new int[elementsCount];
            int i = 0;
            while (currentElement != null && i < elementsCount)
            {
                returnArray[i] = currentElement.Value;
                currentElement = currentElement.nextElement;
                i++;
            }
            return returnArray;
        }
        public void insert(int k)
        {
            if (ListBegin == null && ListEnd == null)
            {
                ListBegin = new MyLinkedListElement();
                ListBegin.Value = k;
                ListEnd = ListBegin;
            }
            else
            {
                MyLinkedListElement newElement = new MyLinkedListElement();
                newElement.Value = k;
                ListEnd.nextElement = newElement;
                newElement.prevElement = ListEnd;
                ListEnd = newElement;
            }
            elementsCount++;
        }

        public void delete(int k)
        {
            MyLinkedListElement currentElement = ListBegin;
            while (currentElement != null)
            {
                if (currentElement.Value == k)
                    if (currentElement == ListBegin && currentElement == ListEnd)
                    {
                        ListBegin = null;
                        ListEnd = null;
                        elementsCount--;
                        return;
                    }
                    else if (currentElement == ListBegin)
                    {
                        ListBegin = ListBegin.nextElement;
                        ListBegin.prevElement.nextElement = null;
                        ListBegin.prevElement = null;
                        elementsCount--;
                        return;
                    }
                    else
                    {
                        currentElement.prevElement.nextElement = currentElement.nextElement;
                        currentElement.nextElement.prevElement = currentElement.prevElement;
                        elementsCount--;
                        return;
                    }
                currentElement = currentElement.nextElement;
            }
        }

        public MyLinkedList2 merge(MyLinkedList2 linkedList2)
        {
            if (this.ListBegin == null || linkedList2.ListBegin == null)
                return null;

            int[] arr1 = this.decode();
            int[] arr2 = linkedList2.decode();

            int[] arr = new int[arr1.Count() + arr2.Count()];
            arr1.CopyTo(arr, 0);
            arr2.CopyTo(arr, arr1.Count());
            Array.Sort(arr);

            return new MyLinkedList2(arr);
        }

        private int? removeMinElement(MyLinkedList2 linkedList2)
        {
            if (ListBegin == null & ListEnd == null)
                return null;

            MyLinkedListElement currentElement = ListBegin;
            int minValue = ListBegin.Value;
            while (currentElement != null)
            {
                if (minValue > currentElement.Value)
                    minValue = currentElement.Value;
                currentElement = currentElement.nextElement;
            }
            delete(minValue);
            return minValue;
        }

[Esc16]

 
        public int maxNum()
        {
            MyLinkedListElement currentElement = ListBegin;
            int i = 0;
            int max = int.MinValue;
            while (currentElement != null && i < elementsCount)
            {
                MyLinkedListElement tempCurrentElement = ListBegin;
                int j = 0;
                int value = currentElement.Value;
                int num = 0;
                while (tempCurrentElement != null && j < elementsCount)
                {
                    if (tempCurrentElement.Value == value)
                        num++;
                    tempCurrentElement = tempCurrentElement.nextElement;
                    j++;
                }
                if (num > max)
                    max = num;
                currentElement = currentElement.nextElement;
                i++;
            }
            return max;
        }

        public MyLinkedList2[] divide()
        {
            int[] decodingArray = decode();
            int divisible3Num = 0;
            for (int i = 0; i < decodingArray.Length; i++)
                if (decodingArray[i] % 3 == 0)
                    divisible3Num++;
            int[] divisible3 = new int[divisible3Num];
            int j = 0;
            for (int i = 0; i < decodingArray.Length; i++)
                if (decodingArray[i] % 3 == 0)
                {
                    divisible3[j] = decodingArray[i];
                    j++;
                }
            int[] other = new int[decodingArray.Length - divisible3Num];
            j = 0;
            for (int i = 0; i < decodingArray.Length; i++)
                if (decodingArray[i] % 3 != 0)
                {
                    other[j] = decodingArray[i];
                    j++;
                }
            MyLinkedList2[] returnLists = new MyLinkedList2[2];
            returnLists[0] = new MyLinkedList2(divisible3);
            returnLists[1] = new MyLinkedList2(other);
            return returnLists;
        }

        public MyLinkedList2 newList()
        {
            int[] arr = decode();
            int[] newArr = new int[arr.Length];
            int n = arr.Length - 1;
            for (int i = 0; i < n; i++)
                newArr[i] = arr[i] * arr[n - i];
            MyLinkedList2 list = new MyLinkedList2(newArr);
            return list;
        }

    }

    class MyLinkedListElement
    {
        public MyLinkedListElement prevElement = null;
        public MyLinkedListElement nextElement = null;
        public int Value;
    }
}