高阶面试-其他算法

慢慢慢时光2024-08-08 9:25

最近面美团，结果栽到了算法上，好不甘心，需要把各个大厂近半年的全部刷N遍，保证在O(1)的时间内作出来，希望接下来的一两周不再害怕常规的算法题

文章目录

2980. 检查按位或是否存在尾随零

java 复制代码 
class Solution {
    public boolean hasTrailingZeros(int[] nums) {
        Set<String> binarySet = new HashSet<>();
        for(int num: nums){
            String curr = Integer.toBinaryString(num);
            for(String binary: binarySet){
                if(Integer.toBinaryString(num | Integer.parseInt(binary,2)).endsWith("0")){
                    return true;
                }
            }
            binarySet.add(curr);
        }
        return false;
    }
}

35. 搜索插入位置

java 复制代码 
class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length -1;
        while(left <= right){
            int mid = left+ (right-left)/2;
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] > target){
                right = mid -1;
            }else {
                left = mid +1;
            }
        }
        return left;
    }
}

48. 旋转图像

java 复制代码 
class Solution {
    public void rotate(int[][] matrix) {
        int n = matrix.length;

        // 对角线
        for(int i=0; i<n; i++){
            for(int j=i;j <n; j++){
                int temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }
        // 对每一行反转
        for(int i=0; i<n; i++){
            for(int j=0;j<n/2;j++){
                int temp = matrix[i][j];
                // 0,1,2,3
                matrix[i][j] = matrix[i][n-j-1];
                matrix[i][n-j-1] = temp;
            }
        }
    }
}

42. 接雨水

java 复制代码 
class Solution {
    public int trap(int[] height) {
        //双指针
        int left = 0;
        int right = height.length-1;
        int leftMax = 0;
        int rightMax = 0;
        int res = 0;

        while(left < right){
            leftMax = Math.max(height[left],leftMax);
            rightMax = Math.max(height[right],rightMax);

            // 走下坡路才需要
            if(height[left] < height[right]){
                res += leftMax-height[left];
                left++;
            }else{
                res += rightMax-height[right];
                right--;
            }
        }
        return res;
    }
}

70. 爬楼梯

java 复制代码 
class Solution {
    public int climbStairs(int n) {
        // check
        if(n <= 1){
            return 1;
        }

        int[] dp = new int[n+1];
        dp[1] = 1;
        dp[0] = 1;
        for(int i=2;i<=n;i++){
            dp[i] = dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
}

82. 删除排序链表中的重复元素 II

java 复制代码 
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        // check
        if(head == null){
            return head;
        }

        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode prev = dummy;
        ListNode curr = head;
        while(curr != null){
            while(curr.next != null && curr.val == curr.next.val){
                curr = curr.next;
            }
            if(prev.next == curr){
                prev = prev.next;
            }else{
                // 重复
                prev.next = curr.next;
            }
            curr = curr.next;
        }
        return dummy.next;
    }
}

206. 反转链表

java 复制代码 
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        // check
        if(head == null || head.next == null){
            return head;
        }
        
        ListNode prev = null;
        ListNode curr = head;
        while(curr != null){
            // 1->2
            ListNode tempNext = curr.next;
            curr.next = prev;
            prev = curr;
            curr = tempNext;
        }
        return prev;
    }
}

958. 二叉树的完全性检验

java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isCompleteTree(TreeNode root) {
        // check
        if(root == null){
            return true;
        }

        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        boolean isEnd = false;
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            if(isEnd && node!= null){
                return false;
            }
            if(node == null){
                isEnd = true;
                continue;
            }
            queue.offer(node.left);
            queue.offer(node.right);
        }
        return true;
    }
}

LCR 152. 验证二叉搜索树的后序遍历序列

java 复制代码 
class Solution {
    public boolean verifyTreeOrder(int[] postorder) {
        // 左右中
        return recur(postorder,0,postorder.length-1);
    }

    public boolean recur(int[] postorder, int start, int end){
        // terminal
        if(start >= end){
            return true;
        }
        int root = postorder[end];
        int mid = start;
        // left right的分界点
        while(mid < end && postorder[mid] < root){
            mid++;
        }
        // 检查 right 是否都 > root
        for(int i=mid; i<end;i++){
            if(postorder[i] < root){
                return false;
            }
        }
        return recur(postorder,start,mid-1) && recur(postorder,mid,end-1);
    }
}

LCR 016. 无重复字符的最长子串

java 复制代码 
class Solution {
    public int lengthOfLongestSubstring(String s) {
        //滑动窗口
        // hash 字符:索引
        HashMap<Character,Integer> map = new HashMap<>();
        int maxLength = 0;
        int left = 0;

        for(int right = 0;right<s.length();right++){
            char currentChar = s.charAt(right);
            //如果已存在，更新left
            if(map.containsKey(currentChar)){
                left = Math.max(map.get(currentChar)+1,left);
            }
            // 更新hash表和最大长度
            map.put(currentChar,right);
            maxLength = Math.max(maxLength,right-left+1);
        }
        return maxLength;
    }
}

LCR 026. 重排链表

java 复制代码 
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public void reorderList(ListNode head) {
        if(head == null || head.next == null){
            return;
        }

        Stack<ListNode> stack = new Stack<>();
        ListNode curr = head;
        while(curr != null){
            stack.push(curr);
            curr = curr.next;
        }

        int n = stack.size();
        curr = head;
        for(int i=0;i<n/2;i++){
            ListNode temp = curr.next;
            ListNode top = stack.pop();
            curr.next = top;
            top.next = temp;
            curr = curr.next.next
        }
        curr.next = null;
    }
}

LCR 024. 反转链表

java 复制代码 
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        // check
        if(head == null || head.next == null){
            return head;
        }
        ListNode prev = null;
        ListNode curr = head;
        while(curr != null){
            // 1->2->3
            ListNode tempNext = curr.next;
            curr.next = prev;
            prev = curr;
            curr = tempNext;
        }
        // 最终 prev 
        return prev;
    }
}

3. 无重复字符的最长子串

java 复制代码 
class Solution {
    public int lengthOfLongestSubstring(String s) {
        // check
        if(s==null || s.length()==0){
            return 0;
        }

        // 滑动窗口
        HashSet<Character> set = new HashSet<>();
        int maxLength = 0;
        int left = 0;
        int right =0;
        while(right < s.length()){
            while(set.contains(s.charAt(right))){
                set.remove(s.charAt(left));
                left++;
            }
            set.add(s.charAt(right));
            maxLength = Math.max(maxLength,right-left+1);
            right++;
        }
        return maxLength;
    }
}

5. 最长回文子串

中心扩展法的思想

回文字符串有一个对称的中心。我们可以从每个字符以及每两个字符之间作为中心开始，向两边扩展，看看能扩展多长的回文。

举个例子

假设我们有一个字符串"babad"。

我们从第一个字符'b'开始：

  1. 以第一个'b'作为中心，我们得到的回文是"b"。
  2. 以第一个'b'和第二个'a'之间作为中心，我们得到的回文长度是0（因为'b'和'a'不相同）。

然后我们以第二个字符'a'开始：

  1. 以第二个'a'作为中心，向两边扩展，得到的回文是"aba"。
  2. 以第二个'a'和第三个'b'之间作为中心，我们得到的回文长度是0（因为'a'和'b'不相同）。

我们继续这样做，直到遍历完所有字符。

代码

java 复制代码 
class Solution {
    public int lengthOfLongestSubstring(String s) {
        // check
        if(s==null || s.length()==0){
            return 0;
        }

        // 滑动窗口
        HashSet<Character> set = new HashSet<>();
        int maxLength = 0;
        int left = 0;
        int right =0;
        while(right < s.length()){
            while(set.contains(s.charAt(right))){
                set.remove(s.charAt(left));
                left++;
            }
            set.add(s.charAt(right));
            maxLength = Math.max(maxLength,right-left+1);
            right++;
        }
        return maxLength;
    }
}
相关推荐
Lenyiin19 分钟前
01.02、判定是否互为字符重排
算法·leetcode
鸽鸽程序猿34 分钟前
【算法】【优选算法】宽搜（BFS）中队列的使用
算法·宽度优先·队列
Jackey_Song_Odd34 分钟前
C语言 单向链表反转问题
c语言·数据结构·算法·链表
Watermelo61738 分钟前
详解js柯里化原理及用法，探究柯里化在Redux Selector 的场景模拟、构建复杂的数据流管道、优化深度嵌套函数中的精妙应用
开发语言·前端·javascript·算法·数据挖掘·数据分析·ecmascript
乐之者v43 分钟前
leetCode43.字符串相乘
java·数据结构·算法
A懿轩A2 小时前
C/C++ 数据结构与算法【数组】 数组详细解析【日常学习，考研必备】带图+详细代码
c语言·数据结构·c++·学习·考研·算法·数组
古希腊掌管学习的神2 小时前
[搜广推]王树森推荐系统——矩阵补充&最近邻查找
python·算法·机器学习·矩阵
云边有个稻草人2 小时前
【优选算法】—复写零（双指针算法）
笔记·算法·双指针算法
半盏茶香2 小时前
在21世纪的我用C语言探寻世界本质 ——编译和链接（编译环境和运行环境）
c语言·开发语言·c++·算法
忘梓.3 小时前
解锁动态规划的奥秘：从零到精通的创新思维解析（3）
算法·动态规划
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程