Given an array arr[] of integers, find out the difference between any two elements such that larger element appears after the smaller number in arr[].

Examples: If array is [2, 3, 10, 6, 4, 8, 1] then returned value should be 8 (Diff between 10 and 2). If array is [ 7, 9, 5, 6, 3, 2 ] then returned value should be 2 (Diff between 7 and 9)

Obvious solution is using two for loops and checking the difference between every element to every other element which is O(n^2). You will need an additional variable to keep the max difference.

It is important to understand this question such that, you can only go from left to right, so we are not talking about absolute value difference. Therefore, sorting doesnt help.

A better solution is to keep two variables, one to keep the minimum element so far and another to keep the maximum difference so far. This allows a single iteratation over the array and you will have the answer.

Below is the code for it.

        public static void FindMaxDifference()
        {
            var arr = new int[] { 7, 9, 5, 6, 3, 20 };
            int min = arr[0];
            int maxSoFar = arr[1] - arr[0];
            for (int i = 0; i < arr.Length; i++)
            {
                if (arr[i] < min)
                {
                    min = arr[i];
                }
                if (arr[i] - min > maxSoFar)
                {
                    maxSoFar = arr[i] - min;
                }
            }
            Console.WriteLine(maxSoFar);
        }

Print the elements of an array in the decreasing frequency if 2 numbers have same frequency then print the one which came 1st
E.g. 2 5 2 8 5 6 8 8 output: 8 8 8 2 2 5 5 6.
There are several approaches to this problem, such as sorting and counting the number of occurrence, sorting can be done in nlogn using quick sort, merge sort. etc. Also , you can use bucket sort for this kind of questions as well.

Below is a method that uses dictionary/hashtable, first, we need to iterate through the input and find the occurrences of all the elements. Then we need to sort the dictionary by value in descending order, which i used linq in the code below.

You can also use a binary search tree, you will need to modify the Node class, and add the count property to it, so if there is a duplicate, you will need to increment the count. Then you can do a inorder traversal to find the sorted sequence in ascending order then you need to reverse that.

        public static void SortByFrequency(int [] arr)
        {
            Dictionary numbersToOccurence = new Dictionary();

            foreach (var  item in arr)
            {
                int res = 0;

                if(numbersToOccurence.TryGetValue(item,out res))
                {
                    numbersToOccurence[item] = ++res;
                }else
                {
                    numbersToOccurence.Add(item, 1);
                }
            }

            var sorted = (from item in numbersToOccurence orderby item.Value descending select item).ToDictionary(kvpair => kvpair.Key, kvpair=>kvpair.Value);

            foreach (var i in sorted)
            {
                Console.WriteLine("Key : {0}, {1}",i.Key, i.Value);
            }

        }

Queue and Stack can be implemented using a linked list very easily. Below is a simple implementation.

public class StackWithLinkedList
    {
        private LinkedList _holder = new LinkedList();

        public StackWithLinkedList()
        {

        }

        public void Push(T data)
        {
            _holder.AddFirst(data);
        }

        public T Pop()
        {
            var item = _holder.First;

            _holder.Remove(_holder.First);

            return item.Value;
        }

        public T Peek()
        {
            var item = _holder.First;

            return item.Value;
        }

        public IEnumerable Traversal()
        {
            foreach (var elememt in _holder)
            {
                yield return elememt;
            }
        }

        public int Count
        {
            get { return _holder.Count; }
        }

    }

    public class QueueWithLinkedList
    {
        private LinkedList _container = new LinkedList();

        public QueueWithLinkedList()
        {

        }

        public void Enqueue(T data)
        {
            _container.AddFirst(data);
        }

        public T Dequeue()
        {
            var item = _container.Last;

            _container.Remove(_container.Last);

            return item.Value;
        }

        public T Peek()
        {
            var item = _container.Last;

            return item.Value;
        }

        public int Count
        {
            get { return _container.Count; }
        }

        public IEnumerable Iterator
        {
            get
            {
                foreach (var element in _container)
                {
                    yield return element;
                }
            }
        }
    }

Given a sequence as following, provide and algorithms and code to move all the zeros to the end of the sequence. This should be in O(n) and using no extra storage.
input :{1, 0, 2, 0, 3, 0, 0, 4, 5, 6, 7, 0, 0, 0};
output :{1, 2, 3, 4, 5, 6, 7, 0, 0, 0,0,0,0,0};

I have used two pointers, second pointer to find the zero and wait until the first pointer reaches a non zero element and then swap them. then change the position of second pointer.

        public static void MoveZerosToEnd(int [] arr)
        {
            int secondPointer = 0;

            for(int i=0;i< arr.Length;i++)
            {

                if(arr[i] == 0 && arr[secondPointer] != 0)
                {
                    secondPointer = i;
                }

                if(arr[i] > 0 && arr[secondPointer] == 0)
                {
                    var temp = arr[i];
                    arr[secondPointer] = temp;
                    arr[i] = 0;

                    while(arr[secondPointer]!=0)
                    {
                        secondPointer++;
                    }
                }
            }

        }