算法大全(2)栈和队列

  声明,本文所有9道算法题目,覆盖了基本上所有常见的栈/队列问题,全都用C#实现,并测试通过,代码下载:StackAndQueue.zip

目录:

1.设计含min函数的栈,要求min、push和pop的时间复杂度都是o(1)。

2.设计含min函数的栈的另解

3.用两个栈实现队列

4.用两个队列实现栈 

5.栈的push、pop序列是否一致

6.递归反转一个栈,要求不得重新申请一个同样的栈,空间复杂度o(1)

7.给栈排个序

8..如何用一个数组实现两个栈

9..如何用一个数组实现三个栈

 

1.设计含min函数的栈,要求min、push和pop的时间复杂度都是o(1)。

  算法思想:需要设计一个辅助栈,用来存储当前栈中元素的最小值。网上有人说存储当前栈中元素的最小值的所在位置,虽然能节省空间,这其实是不对的,因为我在调用Min函数的时候,只能得到位置,还要对存储元素的栈不断的pop,才能得到最小值——时间复杂度o(1)。

  所以,还是在辅助栈中存储元素吧。

  此外,还要额外注意Push操作,第一个元素不用比较,自动成为最小值入栈。其它元素每次都要和栈顶元素比较,小的那个放到栈顶。 

public class NewStack
{
    private Stack dataStack;
    private Stack mindataStack;

    public NewStack()
    {
        dataStack = new Stack();
        mindataStack = new Stack();
    }

    public void Push(int element)
    {
        dataStack.Push(element);

        if (mindataStack.Count == 0)
            mindataStack.Push(element);
        else if (element <= (int)mindataStack.Peek())
            mindataStack.Push(element);
        else //(element > mindataStack.Peek)
            mindataStack.Push(mindataStack.Peek());
    }
    
    public int Pop()
    {
        if (dataStack.Count == 0)
            throw new Exception("The stack is empty");
        
        mindataStack.Pop();
        return (int)dataStack.Pop();
    }

    public int Min()
    {
        if (dataStack.Count == 0)
            throw new Exception("The stack is empty");
        
        return (int)mindataStack.Peek();
    }
}

  

2.设计含min函数的栈的另解

  话说,和青菜脸呆久了,就沾染了上海小市民意识,再加上原本我就很抠门儿,于是对于上一题目,我把一个栈当成两个用,就是说,每次push,先入站当前元素,然后入栈当前栈中最小元素;pop则每次弹出2个元素。

  算法代码如下所示(这里最小元素位于当前元素之上,为了下次比较方便):

public class NewStack
{
    private Stack stack;

    public NewStack()
    {
        stack = new Stack();
    }

    public void Push(int element)
    {
        if (stack.Count == 0)
        {
            stack.Push(element);
            stack.Push(element);
        }
        else if (element <= (int)stack.Peek())
        {
            stack.Push(element);
            stack.Push(element);
        }
        else //(element > stack.Peek)
        {
            object min = stack.Peek();
            stack.Push(element);
            stack.Push(min);            
        }
    }

    public int Pop()
    {
        if (stack.Count == 0)
            throw new Exception("The stack is empty");

        stack.Pop();
        return (int)stack.Pop();
    }

    public int Min()
    {
        if (stack.Count == 0)
            throw new Exception("The stack is empty");

        return (int)stack.Peek();
    }
}  

  之所以说我这个算法比较叩门,是因为我只使用了一个栈,空间复杂度o(N),节省了一半的空间(算法1的空间复杂度o(2N))。

 

 

3.用两个栈实现队列

  实现队列,就要实现它的3个方法:Enqueue(入队)、Dequeue(出队)和Peek(队头)。

1)stack1存的是每次进来的元素,所以Enqueue就是把进来的元素push到stack1中。

2)而对于Dequeue,一开始stack2是空的,所以我们把stack1中的元素全都pop到stack2中,这样stack2的栈顶就是队头。只要stack2不为空,那么每次出队,就相当于stack2的pop。

3)接下来,每入队一个元素,仍然push到stack1中。每出队一个元素,如果stack2不为空,就从stack2中pop一个元素;如果stack2为空,就重复上面的操作——把stack1中的元素全都pop到stack2中。

4)Peek操作,类似于Dequeue,只是不需要出队,所以我们调用stack2的Peek操作。当然,如果stack2为空,就把stack1中的元素全都pop到stack2中。

5)注意边界的处理,如果stack2和stack1都为空,才等于队列为空,此时不能进行Peek和Dequeue操作。

  按照上述分析,算法实现如下:

public class NewQueue
{
    private Stack stack1;
    private Stack stack2;

    public NewQueue()
    {
        stack1 = new Stack();
        stack2 = new Stack();
    }

    public void Enqueue(int element)
    {
        stack1.Push(element);
    }

    public int Dequeue()
    {
        if (stack2.Count == 0)
        {
            if (stack1.Count == 0)
                throw new Exception("The queue is empty");
            else
                while (stack1.Count > 0)
                    stack2.Push(stack1.Pop());
        }

        return (int)stack2.Pop();
    }

    public int Peek()
    {
        if (stack2.Count == 0)
        {
            if (stack1.Count == 0)
                throw new Exception("The queue is empty");
            else
                while (stack1.Count > 0)
                    stack2.Push(stack1.Pop());
        }

        return (int)stack2.Peek();
    }
} 

 

4.用两个队列实现栈

  这个嘛,就要queue1和queue2轮流存储数据了。这个“轮流”发生在Pop和Peek的时候,假设此时我们把所有数据存在queue1中(此时queue2为空),我们把queue1的n-1个元素放到queue2中,queue中最后一个元素就是我们想要pop的元素,此时queue2存有n-1个元素(queue1为空)。

  至于Peek,则是每次转移n个数据,再转移最后一个元素的时候,将其计下并返回。

  那么Push的操作,则需要判断当前queue1和queue2哪个为空,将新元素放到不为空的队列中。

public class NewStack
{
    private Queue queue1;
    private Queue queue2;

    public NewStack()
    {
        queue1 = new Queue();
        queue2 = new Queue();
    }

    public void Push(int element)
    {
        if (queue1.Count == 0)
            queue2.Enqueue(element);
        else
            queue1.Enqueue(element);
    }

    public int Pop()
    {
        if (queue1.Count == 0 && queue2.Count == 0)
            throw new Exception("The stack is empty");

        if (queue1.Count > 0)
        {
            while (queue1.Count > 1)
            {
                queue2.Enqueue(queue1.Dequeue());
            }

            //还剩一个
            return (int)queue1.Dequeue();
        }
        else  //queue2.Count > 0
        {
            while (queue2.Count > 1)
            {
                queue1.Enqueue(queue2.Dequeue());
            }

            //还剩一个
            return (int)queue2.Dequeue();
        }
    }

    public int Peek()
    {
        if (queue1.Count == 0 && queue2.Count == 0)
            throw new Exception("The stack is empty");

        int result = 0;

        if (queue1.Count > 0)
        {
            while (queue1.Count > 1)
            {
                queue2.Enqueue(queue1.Dequeue());
            }

            //还剩一个
            result = (int)queue1.Dequeue();
            queue2.Enqueue(result);

        }
        else  //queue2.Count > 0
        {
            while (queue2.Count > 1)
            {
                queue1.Enqueue(queue2.Dequeue());
            }

            //还剩一个
            result = (int)queue2.Dequeue();
            queue1.Enqueue(result);
        }

        return result;
    }
} 

 

5.栈的push、pop序列是否一致

  输入两个整数序列。其中一个序列表示栈的push顺序,判断另一个序列有没有可能是对应的pop顺序。为了简单起见,我们假设push序列的任意两个整数都是不相等的。

  比如输入的push序列是1、2、3、4、5,那么4、5、3、2、1就有可能是一个pop系列。因为可以有如下的push和pop序列:push 1,push 2,push 3,push 4,pop,push 5,pop,pop,pop,pop,这样得到的pop序列就是4、5、3、2、1。但序列4、3、5、1、2就不可能是push序列1、2、3、4、5的pop序列。

 

  网上的若干算法都太复杂了,现提出包氏算法如下:

  先for循环把arr1中的元素入栈,并在每次遍历时,检索arr2中可以pop的元素。如果循环结束,而stack中还有元素,就说明arr2序列不是pop序列。

static bool JudgeSequenceIsPossible(int[] arr1, int[] arr2)
{
    Stack stack = new Stack();

    for (int i = 0, j = 0; i < arr1.Length; i++)
    {
        stack.Push(arr1[i]);

        while (stack.Count > 0 && (int)stack.Peek() == arr2[j])
        {
            stack.Pop();
            j++;
        }
    }

    return stack.Count == 0;
}

 

 

6.递归反转一个栈,要求不得重新申请一个同样的栈,空间复杂度o(1)

  算法思想:汉诺塔的思想,非常复杂,玩过九连环的人都想得通的

static void ReverseStack(ref Stack stack)
{
    if (stack.Count == 0)
        return;

    object top = stack.Pop();

    ReverseStack(ref stack);

    if (stack.Count == 0)
    {
        stack.Push(top);
        return;
    }

    object top2 = stack.Pop();
    ReverseStack(ref stack);

    stack.Push(top);
    ReverseStack(ref stack);
    stack.Push(top2);        
}
 

7.给栈排个序

  本题目是上一题目的延伸

static void Sort(ref Stack stack)
{
    if (stack.Count == 0)
        return;

    object top = stack.Pop();

    Sort(ref stack);

    if (stack.Count == 0)
    {
        stack.Push(top);
        return;
    }

    object top2 = stack.Pop();
    if ((int)top > (int)top2)
    {
        stack.Push(top);
        Sort(ref stack);
        stack.Push(top2);
    }
    else
    {
        stack.Push(top2);
        Sort(ref stack);
        stack.Push(top);
    }
}

 

 

8..如何用一个数组实现两个栈

  继续我所提倡的抠门儿思想,也不枉我和青菜脸相交一场。

  网上流传着两种方法:

  方法1  采用交叉索引的方法

一号栈所占数组索引为0, 2, 4, 6, 8……(K*2)  
二号栈所占数组索引为1,3,5,7,9 ……(K*2 + 1) 

  算法实现如下:

public class NewStack
{
    object[] arr;
    int top1;
    int top2;

    public NewStack(int capticy)
    {
        arr = new object[capticy];

        top1 = -1;
        top2 = -2;
    }

    public void Push(int type, object element)
    {
        if (type == 1)
        {
            if (top1 + 2 >= arr.Length)
                throw new Exception("The stack is full");
            else
            {
                top1 += 2;
                arr[top1] = element;
            }
        }

        else //type==2
        {
            if (top2 + 2 >= arr.Length)
                throw new Exception("The stack is full");
            else
            {
                top2 += 2;
                arr[top2] = element;
            }
        }
    }

    public object Pop(int type)
    {
        object obj = null;

        if (type == 1)
        {
            if (top1 == -1)
                throw new Exception("The stack is empty");
            else
            {
                obj = arr[top1];
                arr[top1] = null;
                top1 -= 2;
            }
        }

        else //type == 2
        {
            if (top2 == -2)
                throw new Exception("The stack is empty");
            else
            {
                obj = arr[top2];
                arr[top2] = null;
                top2 -= 2;
            }
        }

        return obj;
    }

    public object Peek(int type)
    {
        if (type == 1)
        {
            if (top1 == -1)
                throw new Exception("The stack is empty");

            return arr[top1];
        }

        else //type == 2
        {
            if (top2 == -2)
                throw new Exception("The stack is empty");

            return arr[top2];
        }
    }
}

  

  方法2:

第一个栈A:从最左向右增长
第二个栈B:从最右向左增长 

  代码实现如下:

public class NewStack
{
    object[] arr;
    int top1;
    int top2;

    public NewStack(int capticy)
    {
        arr = new object[capticy];

        top1 = 0;
        top2 = capticy;
    }

    public void Push(int type, object element)
    {
        if (top1 == top2)
            throw new Exception("The stack is full");

        if (type == 1)
        {
            arr[top1] = element;
            top1++;
        }
        else //type==2
        {
            top2--;
            arr[top2] = element;
        }            
    }

    public object Pop(int type)
    {
        object obj = null;

        if (type == 1)
        {
            if (top1 == 0)
                throw new Exception("The stack is empty");
            else
            { 
                top1--;
                obj = arr[top1];
                arr[top1] = null;
            }
        }

        else //type == 2
        {
            if (top2 == arr.Length)
                throw new Exception("The stack is empty");
            else
            {
                obj = arr[top2];
                arr[top2] = null;
                top2++;
            }
        }

        return obj;
    }

    public object Peek(int type)
    {
        if (type == 1)
        {
            if (top1 == 0)
                throw new Exception("The stack is empty");

            return arr[top1 - 1];
        }

        else //type == 2
        {
            if (top2 == arr.Length)
                throw new Exception("The stack is empty");

            return arr[top2];
        }
    }
}

  综合比较上述两种算法,我们发现,算法1实现的两个栈,每个都只有n/2个空间大小;而算法2实现的两个栈,如果其中一个很小,另一个则可以很大,它们的和为常数n。

 

9..如何用一个数组实现三个栈

  最后,让我们把抠门儿进行到底,相信看完本文,你已经从物质和精神上都升级为一个抠门儿主义者。

  如果还使用交叉索引的办法,每个栈都只有N/3个空间。

  让我们只好使用上个题目的第2个方法,不过这只能容纳2个栈,我们还需要一个位置存放第3个栈,不如考虑数组中间的位置——第3个栈的增长规律可以如下:

第1个入栈C的元素进mid处
第2个入栈C的元素进mid+1处
第3个入栈C的元素进mid-1处
第4个入栈C的元素进mid+2处

  这个方法的好处是, 每个栈都有接近N/3个空间。

public class NewStack
{
    object[] arr;
    int top1;
    int top2;

    int top3_left;
    int top3_right;
    bool isLeft;

    public NewStack(int capticy)
    {
        arr = new object[capticy];

        top1 = 0;
        top2 = capticy;

        isLeft = true;
        top3_left = capticy / 2;
        top3_right = top3_left + 1;
    }

    public void Push(int type, object element)
    {
        if (type == 1)
        {
            if (top1 == top3_left + 1)
                throw new Exception("The stack is full");

            arr[top1] = element;
            top1++;
        }
        else if (type == 2)
        {
            if (top2 == top3_right)
                throw new Exception("The stack is full");

            top2--;
            arr[top2] = element;
        }
        else //type==3
        {
            if (isLeft)
            {
                if (top1 == top3_left + 1)
                    throw new Exception("The stack is full");

                arr[top3_left] = element;
                top3_left--;
            }
            else
            {
                if (top2 == top3_right)
                    throw new Exception("The stack is full");

                arr[top3_right] = element;
                top3_right++;
            }

            isLeft = !isLeft;
        }
    }

    public object Pop(int type)
    {
        object obj = null;

        if (type == 1)
        {
            if (top1 == 0)
                throw new Exception("The stack is empty");
            else
            {
                top1--;
                obj = arr[top1];
                arr[top1] = null;
            }
        }
        else if (type == 2)
        {
            if (top2 == arr.Length)
                throw new Exception("The stack is empty");
            else
            {
                obj = arr[top2];
                arr[top2] = null;
                top2++;
            }
        }
        else //type==3
        {
            if (top3_right == top3_left + 1)
                throw new Exception("The stack is empty");

            if (isLeft)
            {
                top3_left++;
                obj = arr[top3_left];
                arr[top3_left] = null;
            }
            else
            {
                top3_right--;
                obj = arr[top3_right];
                arr[top3_right] = null;
            }

            isLeft = !isLeft;
        }

        return obj;
    }

    public object Peek(int type)
    {
        if (type == 1)
        {
            if (top1 == 0)
                throw new Exception("The stack is empty");

            return arr[top1 - 1];
        }

        else if (type == 2)
        {
            if (top2 == arr.Length)
                throw new Exception("The stack is empty");

            return arr[top2];
        }
        else //type==3
        {
            if (top3_right == top3_left + 1)
                throw new Exception("The stack is empty");

            if (isLeft)
                return arr[top3_left + 1];
            else
                return arr[top3_right - 1];
        }
    }
}

 

    原文作者:包建强
    原文地址: https://www.cnblogs.com/Jax/archive/2009/12/21/1628552.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注