数据结构之栈与队列

目录

栈：后进先出

20. 有效的括号 - 力扣（LeetCode）

682. 棒球比赛 - 力扣（LeetCode）

队列：先进先出

26. 删除有序数组中的重复项 - 力扣（LeetCode）

27. 移除元素 - 力扣（LeetCode） 

---

栈：后进先出

Stack 接口

public interface Stack<T>{
    //入栈
    void push(T e);
    //出栈
    T pop();
    //获取栈长度
    int getSize();
    //判断数组是否为空
    boolean isEmplty();
    //查看栈顶元素
    T peep();
}

用数组结构实现栈的基本操作 

public class ArrStack<T> implements Stack<T>{
    //底层数据结构
     private MyArray1<T> data;
     //栈中实际存放元素的数量
     private int size;

    public ArrStack() {
        this.data = new MyArray1<>();
        this.size = 0;
    }

    @Override
    public void push(T e) { //时间复杂度O(1)
        data.addTail(e);
        this.size++;
    }

    @Override
    public T pop() {//时间复杂度O(1)
        T res = data.removeTailElement();
        this.size--;
        return res;
    }

    @Override
    public int getSize() {//时间复杂度O(1)
        return this.size;
    }

    @Override
    public boolean isEmplty() {//时间复杂度O(1)
        return this.size==0;
    }

    @Override
    public T peep() {//时间复杂度O(1)
        return data.getElementByIndex(this.size-1);
    }
}

 Test类：

import java.util.Random;

public class ArrStackTest {
    public static void main(String[] args) {
        ArrStack<Integer> arrStack = new ArrStack<>();
        int count = 100000;
        Random random =new Random();
        long startTime = System.nanoTime();
        for (int i = 0; i <count; i++) {
            int ans = random.nextInt(1000);
            arrStack.push(ans);
            System.out.print("入栈："+ans);
        }

        System.out.println();
        System.out.println(arrStack.peep());
        System.out.println(arrStack.getSize());
        while (!arrStack.isEmplty()){
            System.out.print("出栈："+arrStack.pop());
        }
        System.out.println();
        long endtTime = System.nanoTime();
        System.out.println("用时"+((endtTime-startTime)/1000000000.0));
    }
}

20. 有效的括号 - 力扣（LeetCode）

import java.util.Stack;

public class Solution20 extends Stack {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i)=='('||s.charAt(i)=='['||s.charAt(i)=='{'){
                stack.push(s.charAt(i));
            }else {
                if (stack.isEmpty()){ //***注意 情况一
                    return false;
                }
                if ((s.charAt(i)== ')'&&stack.pop()=='(')||(s.charAt(i)== ']'&&stack.pop()=='[')||(s.charAt(i)== '}'&&stack.pop()=='{') ) {
                    continue;
                }else {
                    return false;
                }
            }
        }
        return stack.isEmpty();//情况二
    }

    public static void main(String[] args) {
        String s = "[({})";
        Solution20 solution20 = new Solution20();
        System.out.println(solution20.isValid(s));
    }
}

682. 棒球比赛 - 力扣（LeetCode）

 注意：将equals 改为 “==” 在idea中执行正确，但在LeetCode中报错，为减少不必要的出错，建议多使用equals

class Solution {
    public int calPoints(String[] operations) {
        Stack<Integer> stack = new Stack<>();//用栈存储数字，符号就进行计算压栈
        for (int i = 0; i < operations.length; i++) {
            String str = operations[i];
                if (str.equals("C")) {
                    stack.pop();
                }else if (str.equals("D")) {
                    int in = stack.peek() * 2;
                    stack.push(in);
                }else if (str.equals("+")) {
                    int first = stack.pop();//弹出两个，进行+计算，再将两数与结果压栈
                    int second = stack.pop();
                    int in = first + second;
                    stack.push(second);
                    stack.push(first);
                    stack.push(in);
                }else {
                    stack.push(Integer.parseInt(str));
                }

        }
        int sum = 0; // 计算栈中数之和
        while (!stack.isEmpty()){
           sum+=stack.pop();
        }
        return sum;
    }
}

队列：先进先出

Queue 接口

public interface Queue<T> {
    //入队
    void enQueue(T ele);
    //出队
    T deQueue();
    //获得队长
    int getsize();
    //队是否为空
    boolean isEmply();
    //查看队尾
    T getQueueTial();
}

用数组结构实现队的基本操作

public class ArrQueue<T> implements Queue<T>{
    private MyArray1<T> data;
    private int size;

    public ArrQueue() {
        this.data= new MyArray1<>();
        this.size = 0;
    }

    @Override
    public void enQueue(T ele) {
        data.addTail(ele);
        this.size++;
    }

    @Override
    public T deQueue() {
        T res = data.removeFirstElement();
        if (!isEmply()){
            this.size--;
        }
        return res;
    }

    @Override
    public int getsize() {
        return this.size;
    }

    @Override
    public boolean isEmply() {
        return this.size==0;
    }

    @Override
    public T getQueueTial() {
        return data.getElementByIndex(this.size-1);
    }
}

 Test测试

import java.util.Random;

public class ArrQueueTest {
    public static void main(String[] args) {
        ArrQueue<Integer> arrQueue = new ArrQueue<>();
        int count = 100000;
        Random random = new Random();
        long startTime = System.nanoTime();
        for (int i = 0; i < count; i++) {
            int ans = random.nextInt(1000);
            arrQueue.enQueue(ans);
//            System.out.print("入队："+ans);
        }
        System.out.println();
        System.out.println("+++++++++++++");

       while (!arrQueue.isEmply()){
           int ans =+arrQueue.deQueue();
//           System.out.print("出队："+ans);
       }
        long endtTime = System.nanoTime();
        System.out.println("用时"+((endtTime-startTime)/1000000000.0));
    }
}

26. 删除有序数组中的重复项 - 力扣（LeetCode）

 

 

 

import java.util.Arrays;
import java.util.stream.Stream;

public class Solution26 {
    public int removeDuplicates1(int[] nums) {
        //暴力解决 两个数组
        int count = 0;
        if (nums.length == 0 ||nums == null){
            return count;
        }
        int[] arr =new int[nums.length];
        int i = 0;
        int j = 0;
        arr[j] = nums[i];
        i++;
        count = 1;
        //  1、比较 i j 值 不同的将 j 指向的值放入新的数组
        while(i< nums.length){
            if (arr[j] == nums[i]){
               i++;
            }else {
                j++;
                arr[j] = nums[i];
                i++;
                count++;
            }
        }
        for (int k = 0; k < nums.length; k++) {
            nums[k] = arr[k];
        }
        return count;
    }
    //在一个数组中，两个索引，用后面不同的数将前面重复的数覆盖
    public int removeDuplicates2(int[] nums) {
        if (nums.length == 0 ||nums == null){
            return 0;
        }
        int i = 0;
        int j = 1;
        while(j< nums.length){
            if (nums[j] == nums[i]){
                j++;
            }else {
                i++;
                nums[i] = nums[j];
                j++;
            }
        }
        return i+1;
    }
//方法三：用流去重
    public int removeDuplicates(int[] nums){
        int[] arr = Arrays.stream(nums).distinct().toArray();
        for (int i = 0; i < arr.length ; i++) { //***注意使用arr.length
            nums[i] = arr[i];
        }
        return arr.length;
    }

}

27. 移除元素 - 力扣（LeetCode） 

 

package leetcode.day01;

public class Solution27 {
    public int removeElement(int[] nums, int val) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int i = 0;
        int j = 0;
        while (i < nums.length) {
            if (nums[i] == val) {
                i++;
            } else {
                //不同时将后面数向前移动，覆盖相同的数
                nums[j] = nums[i];
                i++;
                j++;
            }
        }
        return j;
    }

    //方法二：将非val值保存在另一个数组中，但会超时
    public int removeElement1(int[] nums, int val) {
        int[] arr = new int[nums.length];
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != val) {
                count++;
                for (int j = 0; j < nums.length; j++) {
                    arr[j] = nums[i];

                }
                i--;
            }
        }
        for (int i = 0; i < count; i++) {
            nums[i] = arr[i];
        }
        return count;
    }
}