算法面试总结

如何用栈实现队列

public class StackImplQueue {

    /**
     * 定义两个栈来实现队列
     * 栈A 负责插入新元素
     * 栈B 负责移除老元素
     */
    private Stack<Integer> stackA = new Stack<>();
    private Stack<Integer> stackB = new Stack<>();

    /**
     * 入队操作
     * @Param element
     */
    public void enQueue(int element){
        stackA.push(element);
    }

    /**
     *
     * 出队操作
     */
    public Integer deQueue(){
        if (stackB.isEmpty()){
            if (stackA.isEmpty()){
                return null;
            }
            fetchFormStackA();
        }

        return stackB.pop();
    }

    /**
     * 从stackA栈中拿到出栈元素压入栈B
     */
    private void fetchFormStackA() {
        while (!stackA.isEmpty()){
            stackB.push(stackA.pop());
        }
    }

    public static void main(String[] args) {
        StackImplQueue stackQueue = new StackImplQueue();
        stackQueue.enQueue(1);
        stackQueue.enQueue(2);
        stackQueue.enQueue(3);

        System.out.println(stackQueue.deQueue());
        System.out.println(stackQueue.deQueue());
        System.out.println(stackQueue.deQueue());

        stackQueue.enQueue(4);
        System.out.println(stackQueue.deQueue());


    }
}

数组最长子字符串

子串中没有重复元素
[1,2,3,4] 最长4；[1,2,2]最长2；[1] 最长1

// 动态规划
public static Integer getLen2(int[] nums){
            int ans = 1;
            int left = 0;
            int right = 0;
            Set<Integer> set = new HashSet<>();
            while(left<=right && right<nums.length){
                if(set.add(nums[right])){
                    right++;
                }else {
                    ans = Math.max(ans , set.size());
                    set.clear();
                    left = right;
                }
                ans = Math.max(ans , set.size());
            }
            return ans;
        }
// 双循环
        public static Integer getLen(int[] nums) {
            if (nums.length == 1) {
                return 1;
            }
            int ans = 1;
            int len = nums.length;
            for (int i = 0; i < len; i++) {
                Set<Integer> set = new HashSet<>();
                for (int j = i; j < len; j++) {
                    if (!set.add(nums[j])) {
                        ans = Math.max(set.size(), ans);
                        break;
                    }
                    if (j == len - 1) {
                        ans = Math.max(set.size(), ans);
                    }
                }
            }
            return ans;
        }

假设有4个硬币，其中有一个硬币的重量异常，尝试用一个没有砝码的天平找出异常的硬币，天平只能使用3次，只需要描述思路。

解法：四个硬币1，2，3，4 分两组 1，2 - 3，4
第一步：1，2 < 3，4
第二步：1 < 2 说明最小的是1，结束
1=2继续
第三步：3>4 说明最大的是3，结束

字符串倒转

说明“前后空格去掉”、 “中间有空格的只保留一个”

    public static void main(String[] arg){
            String[] array = str.trim().split(" +"); // 按多个空格划分，切割完后是数组，因为长度不变
            String revertedStr = "";
            for(int i=array.length-1; i>=0; i--){
                if(i!=0){
                    revertedStr = revertedStr + array[i] + " ";
                } else{
                    revertedStr = revertedStr + array[i];
                }
            }
            System.out.println(revertedStr);
    }

一个字符串数据，只有一个字符串是单个，其他都是双个，找出单个字符串

思路;栈 ，hashMap

二叉树

常用的排序算法

找出第三大数

public static Integer getNums(int[] nums){
        if(nums.length < 3){
            return null;
        }
        // 最大值
        int m = nums[0];
        // 第二大值
        int n = nums[1];
        if(m<n){
            m = nums[1];
            n = nums[0];
        }

        // 第三大值
        int s = nums[2];
        for(int i = 2; i < nums.length; i++){
            if(nums[i] > m){
                s = n;
                n = m;
                m = nums[i];
            } else if(nums[i] <= m && nums[i] > n) {
                s = n;
                n = nums[i];
            } else if(nums[i] <= n && nums[i] > s){
                s = nums[i];
            }
        }
        return s;
    }