力扣算法成长日记 ———— 01

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值target 的那 两个 整数，并返回它们的数组下标

public class SumOne {

    //第一种方式
    public int[] plusOne(int[] digits){
        for (int i = digits.length-1; i >=0; i--) {
            if(digits[i]>=0 && digits[i]<10 && digits[i] != 9){
                digits[i]++;
                return digits;
            }
            digits[i]=0;
        }
        //跳出for循环，说明数字全部是9
        int[] temp=new int[digits.length+1];
        temp[0] = 1;
        return temp;
    }

    //第二种方式：模拟加法
    public int[] plusOne1(int[] digits){
        //存储进位
        int carry = 1;
        //从后往前开始遍历
        for (int i = digits.length-1; i>= 0; i--) {
            int v = digits[i] + carry;
            //判断是否需要进位
            if(v == 10){
                digits[i] = 0;
                carry = 1;
            } else {
                digits[i] = v;
                carry = 0;
                //本题固定加1，再往前计算不会有进位了，所以这里可以break出去了
                break;
            }
        }

        if(carry == 0){
            return digits;
        }

        //说明数组中全是9，处理最高位进1的情况
        int[] temp = new int[digits.length+1];
        temp[0] = 1;
        return temp;
    }
}

两个栈实现一个队列

public class TwoStackToQueue<E> {

    private Stack<E> stack1=new Stack<>();
    private Stack<E> stack2=new Stack<>();

    //入队
    public void offer(E value){
        stack1.push(value);
    }

    //出队
    /**
     * 思路：1.入队列的时候只往stack1添加元素就行
     * 2.出队列的时候先判断stack2是否为空，stack2中的元素都是先进来的，先进先出
     * 如果stack2不为空，则直接弹出stack2的栈顶元素。如果为空，则将stack1的元素添加到stack2中，然后弹出stack2的栈顶元素
     */
    public E poll(){
        //先进行判断，如果两个栈都为空，那么代表队列中没有元素
        if(stack1.isEmpty() && stack2.isEmpty()){
            return null;
        }

        if(stack2.isEmpty()){
            while (!stack1.isEmpty()){
                stack2.push(stack1.pop());
            }
        }

        E value = stack2.pop();
        return value;
    }

    //判断队列是否为空
    public boolean empty(){
        //只有两个栈同时为空的时候队列才为空
        if(stack1.isEmpty() && stack2.isEmpty()){
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        TwoStackToQueue twoStackToQueue=new TwoStackToQueue();
        for (int i = 0; i < 6; i++) {
            int data =(int) (Math.random()*100+1);
            System.out.print(data+"  ");
            twoStackToQueue.offer(data);
        }

        System.out.println();

        System.out.println("出队");
        while (!twoStackToQueue.empty()){
            System.out.print(twoStackToQueue.poll()+"  ");
        }
    }
}

两个队列实现一个栈

/**
 * @author wcc
 * @date 2021/10/21 10:34
 * 两个队列实现一个栈
 * 1.定义两个队列queue1和queue2
 * 2.出栈的时候先判断queue1是否为空，因为queue1中的元素总是后进来的，后进先出，除了队列的最后一个元素
 * 将其他元素添加到queue2，queue1的最后一个元素出队
 * 3.出栈的时候如果再2中判断queue1为空，除了queue2的最后一个元素，将queue2中其他元素添加到queue1
 * 然后queue2中的最后一个元素出队
 */
public class TwoQueueToStack<E> {

    private Queue<E> queue1 = new LinkedList<>();
    private Queue<E> queue2 = new LinkedList<>();

    //入栈
    public void push(E e){
        queue1.add(e);
    }

    //出栈
    public E pop(){
        if(queue1.isEmpty() && queue2.isEmpty()){
            return null;
        }
        //先判断queue1是否为空
        if(!queue1.isEmpty()){ //如果不为空
            //将queue1队列中的元素放入queue2中，queue1中只留下一个元素
            for (int i = 0; i < size()-1; i++) {
                queue2.add(queue1.poll());
            }
            //之后再将queue2中的数据再次放回queue队列中
            for (int i = 0; i < size()-1; i++) {
                queue1.add(queue2.poll());
            }
            return queue1.poll();
        }
        return null;
    }

    public int size(){
        return queue1.size()+queue2.size();
    }

    public boolean empty(){
        if(queue1.size()==0){
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        TwoQueueToStack<Object> objectTwoQueueToStack = new TwoQueueToStack<>();
        for (int i = 0; i < 6; i++) {
            int data =(int) (Math.random()*100+1);
            System.out.print(data+"  ");
            objectTwoQueueToStack.push(data);
        }

        System.out.println();

        System.out.println("出栈");

        while (!objectTwoQueueToStack.empty()){
            System.out.print(objectTwoQueueToStack.pop()+"  ");
        }
    }
}