データ構造（B） - スタックとキューの基本的な操作

序文

このことは、あまりにも基本的なものですので全体的に、また、スタックとキュースタックであるものにのような線形構造は、キューが何であるか、そこに導入されることはありません。ここだけで何か、スタック、ここで事実を基礎となるキューが二つの配列とリンクリストの実装があります実現することであると言う、加算されていません。

スタックの基本的な操作

リンクされたリストのノードの底として、スタックとスタックを実装リンクされたリストを使用して、ノードのリストをここに

次のように基本的なデータ構造は次のとおりです。

/**
 * autor:liman
 * createtime:2020/2/5
 * comment: 栈，自己的栈操作，底层采用链表的数据结构
 */
public class MyStack {

    private ListNode stackTop;
    private ListNode stackBottom;

    public MyStack(ListNode stackTop,ListNode stackBottom){
        this.stackTop = stackTop;
        this.stackBottom = stackBottom;
	}
}

関連するスタック、スタックおよびその他の操作

/**
 * 入栈操作
 * @param stack
 * @param value
 * 这个就好比在top头插入一个节点
 */
public static void pushStack(MyStack stack,int value){
    ListNode node = new ListNode(value);
    node.next = stack.stackTop;
    stack.stackTop=node;
}

/**
 * 遍历操作
 * @param stack
 * 遍历，利用stackTop进行走链的操作
 */
public static void traverse(MyStack stack){
    ListNode stackTop = stack.stackTop;
    while(stackTop!=stack.stackBottom){
        System.out.print(stackTop.value +" ");
        stackTop = stackTop.next;
    }
    System.out.println();
}

/**
 * 栈的判空操作
 * @param stack
 * @return
 * 
 */
public static boolean isEmpty(MyStack stack){
    if(stack.stackTop == stack.stackBottom){
        return true;
    }else{
        return false;
    }
}

/**
 * 出栈
 * @param stack
 * 在栈非空的情况下，相当于删除头节点。
 */
public static void popStack(MyStack stack){
    if(!isEmpty(stack)){
        ListNode stackTop = stack.stackTop;
        stack.stackTop = stackTop.next;
        System.out.println(stackTop.value);
    }
}

/**
 * 清空栈中的元素
 * @param stack
 * 这个够简单了，其余的节点会被JVM自动回收
 */
public static void clearStack(MyStack stack){
    stack.stackTop = null;
    stack.stackBottom = stack.stackTop;
}

キューの基本的な操作

スタックの底部の基本的な動作は、キューがアレイベースの方法を使用してリンクされたリストの実装です。下の円形キューに示されるように、それはそれである百度

public class MyQueue {

    public int[] arrays;
    public int front;   //指向的是第一个有效的元素
    public int rear;    //指向的是最后一个有效元素的下一个元素

    public MyQueue(int[] arrays, int front, int rear) {
        this.arrays = arrays;
        this.front = front;
        this.rear = rear;
    }
}

それは後の時点で注目すべきである、この点は右端有効の配列要素の次の要素であり、この収納スペースは無効である要素

/**
 * 判断队列是否是满的
 * (queue.rear+1)%queue.length == queue.front，则表示队列已满
 * @param queue
 * @return
 */
public static boolean isFull(MyQueue queue) {
    if ((queue.rear + 1) % queue.arrays.length == queue.front) {
        return true;
    } else {
        return false;
    }
}

/**
 * 判断队列是否是空
 * queue.rear == queue.front则表示队列为空，这是最初始的状态
 * @param queue
 * @return
 */
public static boolean isEmpty(MyQueue queue) {
    if (queue.rear == queue.front) {
        return true;
    } else {
        return false;
    }
}

/**
 * 入队操作
 * 即操作队尾，将元素放到rear所指向的空间，然后rear前移 【(rear+1)%queue.length】
 * @param queue
 * @param value
 */
public static void enQueue(MyQueue queue, int value) {
    if (!isFull(queue)) {
        queue.arrays[queue.rear] = value;
        queue.rear = (queue.rear + 1) % queue.arrays.length;
    }
}

/**
 * 遍历操作
 *
 * @param queue
 */
public static void traverse(MyQueue queue) {
    int i = queue.front;
    while (i != queue.rear) {
        System.out.println(queue.arrays[i]);
        i = (i + 1) % queue.arrays.length;
    }
}

/**
 * 出队操作
 * 操作对头指针，front。之后front前移【(front+1)%queue.length】
 */
public static void outQueue(MyQueue queue) {
    if (!isEmpty(queue)) {
        int value = queue.arrays[queue.front];
        System.out.println(value);
        queue.front = (queue.front + 1) % queue.arrays.length;
    }
}

2つのスタックは、キューを使用して実装しました

思考：第2の待ち行列スタックから、すなわち、スタックの最初の要素は、スタック、キューの前に、このような列などの要素のスタックを受け、その後、スタックに2つ目の要素をプッシュします要素をポップ。この潜在需要を達成するために、スタックのJavaのコレクションをここに

public class DoubleStack2Queue {

    public Stack<Integer> stackPush;	//用于入队列的栈
    public Stack<Integer> stackPop;		//用于出队列的栈

    public DoubleStack2Queue(Stack<Integer> stackPush, Stack<Integer> stackPop) {
        this.stackPush = stackPush;
        this.stackPop = stackPop;
    }

    /**
     * 入队列。
     */
    public void add(int value){
        stackPush.push(value);
    }

    /**
     * 出队列的操作
     * @return
     */
    public int poll(){
        if(stackPop.isEmpty() && stackPush.isEmpty()){//队列为空
            throw new RuntimeException("队列为空");
        }else if(stackPop.isEmpty()){
            while(!stackPush.isEmpty()){//一股脑的直接将入队列的栈里面的所有元素放到出队列的栈中。
                stackPop.push(stackPush.pop());
            }
        }
        return stackPop.pop();
    }

    /**
     * 只是单纯的读取栈顶的元素
     * @return
     */
    public int peek(){
        if(stackPop.isEmpty() && stackPush.isEmpty()){//队列为空
            throw new RuntimeException("队列为空");
        }else if(stackPop.isEmpty()){
            while(!stackPush.isEmpty()){
                stackPop.push(stackPush.pop());
            }
        }
        return stackPop.peek();
    }
}

概要

それはあまりにも簡単ではない、と要約したくありません。