There are several algorithms to remove duplicates from a given sequence of elements.

For sorted sequences, this can be done very easily as follows. Have two pointers, one to point to the current node and one to point to the next node, if current node and next node are equal, you can remove the next node. If you are doing this for a linked list, you need to update your next pointer of the current node to the next node of the node to be deleted. By doing this, you can traverse the sequence until the end, and problem solved. This solution doesnt require extra space, and it s in place. running time is O(n).

If the sequence is unsorted, and you are allowed to use extra space, you can use a hash table, while you are iterating through the sequence, you check the dictionary if the dictionary contains the current element, skip that element, if it doesn’t add the element to the dictionary and keep the element. do this for all the elements. and at the end you ll have the unique elements. This solution requires extra space for hashtable. and the solution is O(n).

Another approach, if extra space is not allowed, would be sort the sequence and do the first paragraph. Running time is O(n). no extra space.

If the maximum element of the array is smaller than the array size, you can use count sort. as follows:

 for(i = 0; i < size; i++)
  {
    if(arr[abs(arr[i])] >= 0)
      arr[abs(arr[i])] = -arr[abs(arr[i])];
    else
      printf(" %d ", abs(arr[i]));
  }

This work in O(n) and doesnt require extra space.

Another solution would be to use bucket sort, that sorts in O(n). then do the first paragraph.

Reversing a linked list is common problem. OK there are several way of reversing a linked list. You will need 3 pointers. currentPointer, previousPointer, and nextPointer.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace FiratAtagun.DataStrucutres.LinkedList
{
    public class Node : IEquatable, IEquatable>, IComparable where T: IComparable
    {
        public T Value { set; get; }
        public Node Next { set; get; }

        public Node()
        {

        }

        public Node(T value)
        {
            Value = value;
        }

        #region IEquatable Members

        public bool Equals(T other)
        {
            return Value.Equals(other);
        }

        #endregion

        #region IComparable Members

        public int CompareTo(T other)
        {
            return Value.CompareTo(other);
        }

        #endregion

        #region IEquatable> Members

        public bool Equals(Node other)
        {
            return Value.Equals(other.Value);
        }

        #endregion
    }

    public enum OperationOptions
    {
        Default,
        Iterative,
        Recursive
    }

    public class MySinglyLinkedList : IEnumerable> where T: IComparable
    {

        public Node Head { set; get; }

        public MySinglyLinkedList()
        {

        }

        public MySinglyLinkedList(IEnumerable collection)
        {
            foreach (var element in collection)
            {
                Insert(element);
            }
        }

        public Node Reverse()
        {
            Node currentPointer = Head;
            Node nextPointer = null;
            Node previousPointer = null;

            while(currentPointer != null)
            {
                nextPointer = currentPointer.Next;
                currentPointer.Next = previousPointer;
                previousPointer = currentPointer;
                currentPointer = nextPointer;
            }

            return previousPointer;
        }

        public void Insert(T data, OperationOptions operationOptions = OperationOptions.Iterative)
        {

            if(Head == null)
            {
                Head = new Node(data);
                return;
            }

            if(operationOptions == OperationOptions.Default || operationOptions == OperationOptions.Iterative)
            {
                InsertIterative(data);
                return;
            }

            InsertRecursive(data);
        }

        public void InsertIterative(T data)
        {
            InsertIterative(new Node(data));
        }

        public void InsertIterative(Node node)
        {

            var currentNode = Head;

            while(currentNode.Next != null)
            {
                currentNode = currentNode.Next;
            }

            currentNode.Next = node;
        }

        public void InsertRecursive(T data)
        {
            var currentNode = Head;
            InsertRecursive(new Node(data), currentNode);
        }

        public void InsertRecursive(Node node, Node insertAfterThis)
        {

            if(insertAfterThis.Next == null)
            {
                insertAfterThis.Next = node;
                return;
            }

            InsertRecursive(node, insertAfterThis.Next);

        }

        #region IEnumerable> Members

        public IEnumerator> GetEnumerator()
        {
            var currentNode = Head;

            while (currentNode != null)
            {
                yield return currentNode;
                currentNode = currentNode.Next;
            }
        }

        #endregion

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion

    }
}

Given a Singly Linked List, starting from the second node delete all alternate nodes of it. For example, if the given linked list is 1->2->3->4->5 then your function should convert it to 1->3->5, and if the given linked list is 1->2->3->4 then convert it to 1->3.

You will need two pointers, one to point to the prior node and second to point to the next node. You will need to point to the next node of the secondary node.

            MySinglyLinkedList linked = new MySinglyLinkedList();

            linked.Insert(1);
            linked.Insert(2);
            linked.Insert(3);
            linked.Insert(4);
            linked.Insert(5);
            var current = linked.Head;
            var next = current.Next;

            while(current.Next != null)
            {
                if(next.Next == null)
                {
                    current.Next = next.Next;
                    break;
                }

                current.Next = next.Next;
                current = next.Next;
                next = current.Next;
            }

Given a string eg “aaabbccaaadd” replace the same string as “3a2b2c3a2d”. Will you logic work given the compressed string and back to the original string?

public static string DeCompress(string word)
        {
            //3a2b2c3a2d
            var warray = word.ToCharArray();

            int count = 0;
            StringBuilder number = new StringBuilder();
            StringBuilder result = new StringBuilder();
            for (int i = 0; i < warray.Length; i++ )
            {

                if(char.IsDigit(warray[i]))
                {
                    number.Append(warray[i].ToString());
                }else
                {
                    int amount = int.Parse(number.ToString());

                    for(int j = 0; j< amount; j++)
                    {
                        result.Append(warray[i].ToString());
                    }

                    number.Clear();
                }
            }

                return result.ToString();
        }

        public static string Compress(string word)
        {
            var warray = word.ToCharArray();

            StringBuilder sb = new StringBuilder();

            char current = warray[0];
            char previous;
            int count = 0;
            foreach (var ch in warray)
            {
                if (current == ch)
                {
                    count++;
                }
                else
                {
                    previous = current;
                    sb.Append(count + "" + previous.ToString());
                    count = 0;
                    current = ch;
                    count++;
                }
            }
            sb.Append(count + "" + current.ToString());

            return sb.ToString();
        }

You have an array Size n, and array size m.

Merging two sorted arrays can be done in several ways, one of which can be implemented using binary insert in place. Then you will have to shift the element as you insert. It takes about O(nlogm) or O(mlogn) depends on m

Another solution is to use an extra array. and merge them which takes O(m+n), the code is as follows:

        public static void Merge()
        {
            var arrayB = new int[] { 1, 3, 5, 7, 10 };
            var arrayA = new int[] { 0, 1, 2, 6, 8, 12, 13, 14, 15 };

            var finalArray = new int[arrayA.Length + arrayB.Length];

            int index = 0;

            int indexA = 0;
            int indexB = 0;

            while(indexA < arrayA.Length)
            {
                while (indexB < arrayB.Length)
                {
                    int elementA = arrayA[indexA];
                    int elementB = arrayB[indexB];

                    if(elementA <= elementB)
                    {
                        finalArray[index] = elementA;
                        index++;
                        indexA++;
                        break;
                    }

                    if(elementB < elementA)
                    {
                        finalArray[index] = elementB;
                        index++;
                        indexB++;
                        continue;
                    }

                }

                if(indexB == arrayB.Length)
                {
                    for(int i= indexA ; i< arrayA.Length;i++)
                    {
                        finalArray[index] = arrayA[i];
                        index++;
                    }
                    break;
                }

            }

            foreach (var i in finalArray)
            {
                Console.WriteLine(i);
            }

        }