用栈实现队列操作;递归逆序一个栈;栈的排序

算法1:
题目:编写一个类,用两个栈实现队列,支持队列的基本操作(add、poll、peek)
{代码}
/**
 * 编写一个类,用两个栈实现队列,支持队列的基本操作(add、poll、peek)
 * 两点必须做到:(1)如果stackPush要往stackPop中压入数据,必须一次性全部压完;
 *              (2)如果stackPop不为空,stackPush绝对不能像stackPop中压入数据
 */

import java.util.Stack;

public class TwoStacksQueue {
    public Stack<Integer> stackPush;//压入栈,只往这个栈压入数据
    public Stack<Integer> stackPop;//弹出栈,只从这个栈弹出数据
    public TwoStacksQueue(){
        stackPush = new Stack<>();
        stackPop = new Stack<>();
    }
    //将数据压入压入栈中
    public void add(int pushInt){
        stackPush.push(pushInt);
    }

    /**
     * 可以实现压入数据,返回先进入的元素并删除
     * @return stackPop.pop()
     */
    public int poll(){
        //当2个栈都为空时
        if(stackPop.empty() && stackPush.empty()){
            throw new RuntimeException("Queue is empty!");
        }else if(stackPop.empty()){//如果stackPop栈为空,stackPush不为空,将所有的stackPush中的数据全部压入stackPop
            while(!stackPush.empty()){
                stackPop.push(stackPush.pop());
            }
        }
        return stackPop.pop();
    }
    /**
     * 可以实现压入数据,只是返回了先进入的元素
     * @return stackPop.peek()
     */
    public int peek(){
        if(stackPop.empty() && stackPush.empty()){
            throw new RuntimeException("Queue is empty");
        }else if(stackPop.empty()){
            while(!stackPop.empty()){
                stackPop.push(stackPush.pop());
            }
        }
        return stackPop.peek();
    }

    //输入数据
    public void input(int[] ints){
        for (int i = 0; i < ints.length; i++) {
            add(ints[i]);
        }
        System.out.println("入队列的顺序:"+stackPush);

    }

    public static void main(String[] args){
        TwoStacksQueue twoStacksQueue = new TwoStacksQueue();
        int[] ints = {4,5,7,2,5,2,9,0,8};
        twoStacksQueue.input(ints);
        for (int i:ints) {
            System.out.println(twoStacksQueue.poll()+"第"+i+"个出队列!");
        }
    }
}
//栈的特点先进后出;队列的特点是先进先出。

//empty() 是stack中的一个方法:测试堆栈是否为空。 当且仅当堆栈中不含任何项时返回 true;否则返回 false。
//isEmpty() 是stack继承于Vector<E>的一个方法:测试此向量是否不包含组件。当且仅当此向量没有组件(也就是说其大小为零)时返回 true;否则返回 false。
//如果变量未初始化或显式地设置为   Empty,则函数   IsEmpty   返回   True;否则函数返回   False。如果   expression   包含一个以上的变量,总返回   False。



算法2:
题目:仅用递归函数和栈操作逆序一个栈
{代码}

import java.util.Stack;

/**
 * 仅用递归函数和栈操作逆序一个栈
 */
public class ReverseStack {
    /**
     *将栈底元素返回并移除
     * @param stack
     * @return栈底元素,1,2,3
     */
    public int getAndRemoveLastElement(Stack<Integer> stack){
        int result = stack.pop();
        if(stack.isEmpty()){
            return result;
        }else{
            int last = getAndRemoveLastElement(stack);
            stack.push(result);
            return last;
        }
    }

    /**
     *将getAndRemoveLastElement得到的值,重新压入栈中
     * @param stack
     */
    public void reverse(Stack<Integer> stack){
        if(stack.isEmpty()){
            return;
        }
        int i = getAndRemoveLastElement(stack);
        reverse(stack);
        stack.push(i);
    }

    /**
     *将数据压入栈中
     * @param ints
     * @param stackData
     * @return stackData(数据栈)
     */
    public Stack<Integer> input(int[] ints,Stack<Integer> stackData){
        for (int i=0;i<ints.length;i++) {
           stackData.push(ints[i]);
        }
        return stackData;
    }

    public static void main(String[] args){
        Stack<Integer> stackData = new Stack<>();
        ReverseStack reverseStack = new ReverseStack();
        int[] ints = {3,2,1};
        stackData =  reverseStack.input(ints,stackData);
        System.out.println("逆序之前:"+stackData);
        reverseStack.reverse(stackData);
        System.out.println("逆序之后:"+stackData);
    }
}


算法3:
题目:用一个栈实现另一个栈的排序
{代码}

import java.util.Stack;

/**
 * 用一个栈实现另一个栈的排序
 */
public class SortStack {
    /**
     *
     * @param stack 需要排序的栈
     */
    public static void sortStackByStack(Stack<Integer> stack){
        Stack<Integer> help = new Stack<>();
        while (!stack.isEmpty()){
            int cur = stack.pop();//得到栈顶值并删除该栈顶值
            while (!help.isEmpty() && help.peek() > cur){
                stack.push(help.pop());
            }
            help.push(cur);
        }
        while (!help.isEmpty()){
            stack.push(help.pop());
        }
    }

    public static Stack<Integer> input(int[] ints,Stack<Integer> stack){
        for (int i = 0;i<ints.length;i++) {
            stack.push(ints[i]);
        }
        return stack;
    }
    public static void main(String[] args){
        int[] ints = {1,2,3,4,5,6,7,8,9};
        Stack<Integer> stackData = new Stack<>();
        stackData = input(ints,stackData);
        System.out.println("原数据栈:"+stackData);
        sortStackByStack(stackData);
        System.out.println("排序后:"+stackData);
    }
}

发布了35 篇原创文章 · 获赞 40 · 访问量 9万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 技术黑板 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览