Stacked Queues, An Advance in Data Structures

Introduction

There are various types of structures to store date that can play important roles. But why do we have many structures to form more effective storage? With the same thought I play with some date structures and choose the queue and stack to renovate this advanced capability in data structures. Of course I am curious to have a tour with this. So let us proceed.

The Stacked Queue

This structure contains the basic logic of a queue and a stack. Well stacks play a major role here with the operations of push and pop with the additional operation of a queue, in other words, enqueue and dequeue. Here the stack has enqueue and dequeue methods.

Stacked Queue Operation

Operation	Description
Push	Insert an item into the stack with queue
Pop	Pop all items in the current Stack item
Enqueue	Insert an item into the current stack queue item
Dequeue	Get an item from the current stack queue item

Algorithms

Pop Operation

• Create a new queue
• If Space.Count is less than one then
• Assign a NewQueue as the last queue
• Remove the last item
• Set the current item
• Else
• Through an empty message

Push Operation

• Create a new queue
  
• Enter a value in the new queue
  
• Add a new queue in the stack

Enqueue Operation

• Call the current queue enqueue
  

Dequeue Operation

• Call the current queue dequeue
• If the last queue value then
• Remove the current queue from the stack

C# code

namespace QueuedStackApplication
{
    public class QueueStack
    {
        List<Queue> Space = new List<Queue>();

        Queue CurrentQueue = new Queue();

        // Push operation on Stack
        public void Push(int value)
        {
            CurrentQueue = new Queue();
            CurrentQueue.EnQueue(value);
            Space.Add(CurrentQueue);
        }

        // Pop operation on stack
        public List<int> Pop()
        {
            Queue q = new Queue();
            if (Space.Count > 1)
            {
                q = Space[Space.Count - 1];
                Space.RemoveAt(Space.Count - 1);
                CurrentQueue = Space[Space.Count - 1];
            }
            else
            {
                MessageDisplay("Stack Empty");
                return null;
            }
            return q.Space;
        }

        //Enqueue operation on stack

        public void EnQueue(int value)
        {
            CurrentQueue.EnQueue(value);
        }

        // DeQueue operation on stack
        public int DeQueue()
        {
            var value = CurrentQueue.DeQueue();
            if (value == -1)
            {
                Pop();
                MessageDisplay("Queue empty for this Stack Item");
            }
            else
                MessageDisplay(string.Empty);

            return value;
        }

        public string MessageDetails = string.Empty;
        public void MessageDisplay(String message)
        {
            MessageDetails = message;
        }

        public void DisplayItem(Panel mainPanel)
        {
            mainPanel.Controls.Clear();

            int top = 10;
            int left = 10;

            Random r = new Random();
            foreach (var queue in Space)
            {
                left = 10;
                foreach (var item in (queue as Queue).Space)
                {
                    Button panel = new Button();
                    panel.Width = 50;
                    panel.Height = 50;
                    panel.Top = top;
                    panel.Left = left;
                    panel.Font = new System.Drawing.Font("Microsoft Sans Serif",    12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
                    panel.Text = item.ToString();
                    panel.BackColor = (item % 2 == 0) ? Color.LightPink : Color.LightSkyBlue;
                    panel.Click += panel_Click;
                    mainPanel.Controls.Add(panel);
                    left = left + panel.Width + 10;
                }
                top = top + 60;
            }
        }

        void panel_Click(object sender, EventArgs e)
        {
            MessageBox.Show(" Hi, I am " + (sender as Button).Text);
        }
    }

    public class Queue
    {
        public List<int> Space = new List<int>();

        // Enqueue Operation for Queue item
        public void EnQueue(int value)
        {
            Space.Add(value);
        }

        // Dequeue Operation for Queue item
        public int DeQueue()
        {
            if (Space.Count > 0)
            {
                var value = Space[0];

                for (int i = 0; i < Space.Count - 1; i++)
                {
                    Space[i] = Space[i + 1];
                }

                Space.RemoveAt(Space.Count - 1);
                return value;
            }
            else
            {

                return -1;
            }
        }
    }
}

Operations Example

Push an item onto the stack, for example “11”; it will be stacked as the very first element in the stack.



Now insert the next item onto the stack. For example 12 is pushed onto the stack.



Now insert an item with the same element. For example when inserting an item “13” it will create a queue and provide you the support of the Queue operations.



Now push another element onto the stack, for example an item 14 is pushed onto the stack as a new stack element.



Now “15” is a new stack element.



And “16” is pushed onto the stack.



Now try to insert “17”, “18”, “19”, “20” with “16” and it forms a new queue and is stored in the same stack element.



Let us now see what happens when doing a Dequeue operation with this stack. It is removing the first element inserted with the current stack element.



Again doing the dequeue the first element is removed.



Let us check what happened when doing the Pop operation of the stack. Yes it will pop all there items present in the current queue element.



After doing the pop operation of the Stack two times, “15” and “14” are popped out.



It will show an empty message when doing the dequeue three times when a stack queue element contains two items.



Advantages

• Provide an additional meaningful operation like Enqueue and Dequeue for a stack.
• Provided a structure more advanced than the existing classic structure to access the data in a more efficient manner.
• A single structure can behave like a stack or a queue.

Conclusion

Hence this Stacked queue provides the combined capabilites of both structures. That would help us to access the data in a fine way for proper memory allocation of the data.