面试高频算法题

最新推荐文章于 2024-04-18 10:35:28 发布
最新推荐文章于 2024-04-18 10:35:28 发布
阅读量174 收藏
点赞数
分类专栏： Leetcode 文章标签： 秋招 算法题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/erzhushashade/article/details/112145204
版权

文章目录

前言

恍恍惚惚的过了秋招，但是没有拿到理想的offer，这篇便是记边复习遍记录面试中比较高频的算法题，为接下来的春招做准备，冲鸭<(￣︶￣)↗[GO!]

树

树的最基本遍历，用递归的方式是必须要掌握的，面试的时候基本是会让你用迭代的方式写出来，所以都得掌握

后序遍历

递归：

 class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        // 递归处理
        List<Integer> res=new ArrayList<>();
        postorderTraversalHelper(root,res); 
        return res;
       
    }
    public void postorderTraversalHelper(TreeNode node,List<Integer> res){
        if(node!=null){
            postorderTraversalHelper(node.left,res);
            postorderTraversalHelper(node.right,res);
            res.add(node.val);
        }
    }
}

迭代:

 class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        // 迭代处理
        // 方向来做
        // 后序遍历是左-》右-》中，那么反过来中-》右-》左，按照后面的顺序，把最后得到的结果反向过来就行
        List<Integer>res= new ArrayList<>();
        //  节点用栈来存储
        Stack<TreeNode> stack=new Stack<>();
        while(!stack.isEmpty() || root!=null){
            // 从中节点开始遍历完
            while(root!=null){
                res.add(root.val);
                stack.push(root);
                root=root.right;
            }
            root=stack.pop();
            root=root.left;
        }
        Collections.reverse(res);
        return res;
    }
}

前序遍历

递归：


 class Solution{
     List<Integer> res=new ArrayList<>();
     public List<Integer> preorderTraversal(TreeNode root){
        //  前序遍历是中-》左-》右
        // 递归的方式完成
        if(root!=null){
            res.add(root.val);
            preorderTraversal(root.left);
            preorderTraversal(root.right);
        }
        return res;
     }
 }

迭代：

class Solution{
    public List<Integer> preorderTraversal(TreeNode root){
        List<Integer> res=new ArrayList<>();
        // 用stack来保存结点
        Stack<TreeNode> stack=new Stack<>();
        while(!stack.isEmpty() || root!=null){
            while(root!=null){
                res.add(root.val);
                stack.push(root);
                root=root.left;
            }
            root=stack.pop();
            root=root.right;
        }
        return res;
    }
}

中序遍历

 class Solution{
     List<Integer> res=new ArrayList<>();
     public List<Integer> inorderTraversal(TreeNode root){
        //  递归就是左-》中-》右
        if(root!=null){
            inorderTraversal(root.left);
            res.add(root.val);
            inorderTraversal(root.right);
        }
        return res;
     }
 }

迭代：

class Solution{
    public List<Integer> inorderTraversal(TreeNode root){
        List<Integer> res=new ArrayList<>();
        Stack<TreeNode> stack=new Stack<>();
        while(!stack.isEmpty() || root!=null){
            while(root!=null){
                stack.push(root);
                root=root.left;
            }
            root=stack.pop();
            res.add(root.val);
            root=root.right;
        }
        return res;
    }
 }

二叉树的层次遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res=new ArrayList<>();
        if(root == null){
            return res;
        }
        // 用两个队列分别记录不同层含有的结点，然后依次遍历
        Queue<TreeNode> A=new LinkedList<>();
        Queue<TreeNode> B= new LinkedList<>();
        A.offer(root);
        while(!A.isEmpty()){
            List<Integer> temp=new ArrayList<>();
            while(!A.isEmpty()){
                TreeNode node=A.poll();
                temp.add(node.val);
                if(node.left != null){
                    B.offer(node.left);
                }
                if(node.right !=null){
                    B.offer(node.right);
                }
            }
            res.add(temp);
            Queue<TreeNode> trans =A;
            A=B;
            B=trans;
        }
        return res;
    }
}

构建二叉树

/**
 * 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 {
   Map<Integer,Integer> map=new HashMap<>();
    int [] preorder;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        // 前序：中-》左-》右
        // 中序：左-》中-》右
        // 递归中，需要再每一层确定左右子树的范围
        // 查找的时候，用 map 会更快
        int length=inorder.length;
        this.preorder = preorder;
        for(int i=0;i<length;i++){
            map.put(inorder[i],i);// 记录在中序遍历中每个数字的位置，用 map 查找更快
        }
        return buildTreeHelper(0,0,length-1);

    }
    public TreeNode buildTreeHelper(int p_root,int i_left,int i_right){
        if(i_left>i_right){
            return null;
        }
        // 第一个便是根节点
        TreeNode root=new TreeNode(preorder[p_root]);
        // 找到左子树的范围
        // 定位根节点在中序遍历的位置
        int position=map.get(preorder[p_root]);
        root.left=buildTreeHelper(p_root+1,i_left,position-1);
        root.right=buildTreeHelper(position-i_left+p_root+1,position+1,i_right);
        return root;

    }
}

二叉搜索树中的插入操作

递归:

/**
 * 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 TreeNode insertIntoBST(TreeNode root,int val){
        //  使用递归
        // 为空比较特殊
        if(root==null){
            TreeNode node=new TreeNode(val);
            return node;
        }else if(root.val<val){
            root.right=insertIntoBST(root.right,val);
        }else {
            root.left=insertIntoBST(root.left,val);
        }
        return root;
     }
 }

迭代:

 
 class Solution{
     public TreeNode insertIntoBST(TreeNode root,int val){
        //  使用迭代
        // 为空比较特殊
        if(root ==null){
            return new TreeNode(val);
        }
        TreeNode temp=root;
        while(true){
            if(temp.val>val){
                if(temp.left==null){
                    temp.left=new TreeNode(val);
                    break;
                }
                temp=temp.left;
            }else{
                if(temp.right==null){
                    temp.right=new TreeNode(val);
                    break;
                }
                temp=temp.right;
            }
        }
        return root;
     }
 }

排序算法

1.冒泡排序

import java.util.*;

public class Main{
    public static void main(String [] args){
    //    冒泡排序
        int [] test =new int[]{3,5,6,23,67,1,35,67,90,5,6};
        int length=test.length;
        for(int i=0;i<length;++i){
            for(int j=0;j<length-i-1;j++){
                if(test[j]>test[j+1]){
                    int temp=test[j];
                    test[j]=test[j+1];
                    test[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(test));
    }
}

2.快速排序


import java.util.Arrays;

public class Main{
    public static void main(String [] args){
    //    快速排序
        int [] test =new int[]{3,5,6,23,67,1,35,67,90,5,6};
        quicksort(test,0,test.length-1);
        System.out.println(Arrays.toString(test));

    }

    public static void quicksort(int [] num,int  left,int right){
        if(left<right){
            int temp= num[left];
            int l=left;
            int r=right;
            while(l<r){
                while(l<r && num[r]>temp){
                    r--;
                }
                if (l<r){
                    num[l]=num[r];
                    l++;
                }
                while(l<r && num[l]<temp){
                    l++;
                }
                if (l<r){
                    num[r]=num[l];
                    r--;
                }
            }
            num[l]=temp;
            quicksort(num,left,l-1);
            quicksort(num,l+1,right);
        }
    }
}

3.堆排序

import java.util.*;

public class Main{
    public static void main(String [] args){
    //    堆排序
        int [] test =new int[]{3,5,6,23,67,1,35,67,90,5,6};
        int length=test.length;
        for(int i=length/2-1;i>=0;--i){
            // 从最大的一个叶子节点的父节点开始
            heapsort(test,length,i);
        }
        for(int i=0;i<length;++i){
            int temp=test[0];
            test[0]=test[length-1-i];
            test[length-1-i]=temp;
            heapsort(test,length-1-i,0);
        }
        System.out.println(Arrays.toString(test));
    }
    public static void heapsort(int [] nums,int length,int position){
        // 先把要重新定位的数字保存起来
        int temp=nums[position];
        for(int k=2*position+1;k<length;k=2*k+1){
            if(k+1<length && nums[k+1]>nums[k]){
                k=k+1;
            }
            if(nums[k]>temp){
                nums[position]=nums[k];
                position=k;
            }else{
                break;
            }
        }
        nums[position]=temp;
    }
}

查找

二分查找（基本）


import java.util.*;

public class Main {
    public static void main(String [] args){
        int [] test=new int[] {2,3,4,5,6,7,9,10,15};
        // 二分查找
        System.out.print(search(test,11));


    }
    public static  boolean search(int [] nums ,int target){
        int length=nums.length;
        int left=0;
        int right=length-1;
        while(left<=right){
            int mid=left + (right-left)/2;
            if(nums[mid]== target){
                return true;
            }else if(nums[mid] >target){
                right=mid-1;
            }else{
                left=mid+1;
            }
        }
        return false;
    }

}



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

Java单例模式

public class Singleton {
    private volatile static Singleton singleton;
    private Singleton() {}

    public static Singleton getSingleton() {
        if(singleton == null){
            synchronized(Singleton.class){
                if (singleton ==null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

翻转链表

 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre =null; //前一个
        ListNode cur =head; //当前
        ListNode  next = null; //  指向下一个
        while (cur!=null) {
            next=cur.next;//保存下一个
            cur.next =pre; //翻转
            pre = cur;// 位置转移
            cur =next ;//位置转移
        }
        return pre;
    }
}

环形链表

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        // 没有结点和只有一个结点的时候为空
        if(head == null || head.next==null){
            return false;
        }
        // 快慢指针来检测
        ListNode quick=head.next;
        ListNode slow =head;
        while(quick != null && quick.next !=null){
            if(quick ==slow ){
                return true;
            }
            quick =quick.next.next;
            slow= slow.next;
        }
        return false;
        
    }
}

环形链表 II

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode quick=head,slow=head;
        while(quick!=null && quick.next!=null){
            quick=quick.next.next;
            slow=slow.next;
            // 第一次相遇
            if(quick==slow){
                quick=head;
                // 第二次相遇
                while(quick !=slow){
                    slow=slow.next;
                    quick=quick.next;
                }
                return slow;
            }

        }
        return null;
    }
}

LRU缓存机制

class LRUCache {
    class Node{
        int key;
        int value;
        Node next;
        Node pre;
        public Node(int key,int value){
            this.value=value;
            this.key=key;
        }
    }
    int capacity;
    Map<Integer,Node> map=new HashMap<>();
    Node head,tail;
    public LRUCache(int capacity) {
        // 初始化
        this.capacity=capacity;
        head=new Node(-1,-1);
        tail=new Node(-1,-1);
        head.next=tail;
        tail.pre=head;
    }
    
    public int get(int key) {
        int res=-1;
        Node node;
        if(map.containsKey(key)){
            node =map.get(key);
            res=node.value;
        // 移动到队首
            deleteNode(node);
            putFirst(node);
        }
        return res;
    }
    
    public void put(int key, int value) {
          // 生成一个新的结点
            Node newNode=new Node(key,value);
        // 如果有相同的值，则覆盖
        if(map.containsKey(key)){
            Node node=deleteNode(map.get(key));
            map.remove(key);
        }else if(map.size()==capacity){
            // 删除链表中最后一个节点
            Node node=deleteNode(tail.pre);
            map.remove(node.key);      
        }
        map.put(key,newNode);
       // 放到队列头部
        putFirst(newNode);

    }
    public void putFirst(Node node){
        node.next=head.next;
        node.pre=head;
        head.next=node;
        node.next.pre=node;
    }
    public Node deleteNode(Node node){
        node.next.pre=node.pre;
        node.pre.next=node.next;
        return node;
    }
}
erzhuerzhu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
常见算法面试题
liujiaping的专栏
01-13 533
常见算法面试题 1.字符串交换位置 时间复杂度O(n) 空间复杂度O(1) 输入 "abcde" 输出 "edcba" def jiaohuan(str1): s1 = list(str1) tmp = 0 for i in range(0, int(len(s1) / 2)): tmp = s1[i] s1[i] = s1[len(s1) - i - 1] s1[len(s1) - i - 1] = tmp
面试题算法题
寂静大海
10-05 1576
1. 给你5个球，每个球被抽到的可能性为30、50、20、40、10，设计一个随机算法，该算法的输出结果为本次执行的结果。    输出A，B，C，D，E即可。   让范围大的球放在最上面判断，这样可能一次或两次就判断出来的概率就更高，从理论和客观角度都应该可以减少判断的次
【分类整理】面试最常考的 100 道 LeetCode 算法题
负雪明烛
12-27 1万+
100道面试常考的力扣算法题，经过众多面试者投票选出来的，快来领取！
查找不含有重复字符的最长子串的长度
weixin_44783458的博客
12-07 468
给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。 public static int lengthOfLongestSubstring(String s) { int rs = 0; int[] last = new int[128]; for (int i = 0; i < 128; i++) { last[i] = -1; } int start = 0; for
7 道高频面试算法题，你都会了吗？「矩阵 + 位运算 + LRU」
圆号本号
10-21 766
矩阵 螺旋矩阵 给定一个包含 m x n 个要素的矩阵，（m 行, n 列），按照螺旋顺序，返回该矩阵中的所有要素。 public List<Integer> spiralOrder(int[][] matrix) { ArrayList<Integer> rst = new ArrayList<Integer>(); if(matrix...
高频算法面试题
Xiao__Bei的博客
11-29 107
一、接雨水（paypal） https://leetcode-cn.com/problems/trapping-rain-water/ 二、43 字符串相乘（腾讯） 1.题目 给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。 https://leetcode-cn.com/problems/multiply-strings/ 2.思路 https://blog.csdn.net/wind_liang/article/detail
29道面试基础算法题，试试看会不会
Android茶话会
05-25 7413
本文主要整理了一些面试常见的算法题，涵盖 数组、字符串、哈希表、链表、二叉树。
面试高频算法习题精讲.rar
12-29
"面试高频算法习题精讲"这个压缩包文件显然是为了帮助应聘者集中精力学习那些在面试中经常出现的算法题目。下面，我们将详细探讨一些重要的算法类别及其在实际面试中的应用。 1. 排序算法：快速排序、归并排序、堆...
面试高频算法题总结
11-03
面试高频算法题总结 面试高频算法题总结 面试高频算法题总结
面试高频算法题总结，个人博客
05-29
面试时，面试官经常通过提出算法问题来评估候选人的逻辑思维、问题解决和编程能力。本篇文章将对一些常见的面试算法题目进行总结，重点讨论Python语言下的实现方式。 一、排序算法 1. 冒泡排序：基础排序算法，...
大厂算法面试题库中高频出现的30道典型题
04-09
大厂算法面试题库中,高频出现的30道典型题
大厂算法面试题库中高频出现的30道典型题.pdf
04-29
大厂算法面试题，高频出现的30题，面试绝对有用。如果你刷leetcode题目很多，为了面试不如看看高频题，这30到够用了，经常会被笔试到，资料很好。
leetcode-Code:面试高频算法题总结，个人博客
06-29
在IT行业中，LeetCode是一个非常受欢迎的在线平台，它提供了大量的编程题目，涵盖了各种算法和数据结构，旨在帮助程序员提升技能并准备面试。这个“leetcode-Code”项目显然是一个人整理的LeetCode算法题目的个人...
微软面试高频算法题解析与代码实现（C++）
最新发布
小桥流水 的专栏
04-18 807
微软面试高频算法题解析与代码实现（C++）
Java笔试面试-算法常用面试题
热门推荐
HenryLei的博客
11-19 11万+
1.说一下什么是二分法？使用二分法时需要注意什么？如何用代码实现？   二分法查找（Binary Search）也称折半查找，是指当每次查询时，将数据分为前后两部分，再用中值和待搜索的值进行比较，如果搜索的值大于中值，则使用同样的方式（二分法）向后搜索，反之则向前搜索，直到搜索结束为止。  二分法使用的时候需要注意：二分法只适用于有序的数据，也就是说，数据必须是从小到大，或是从大到小排序的。 pu...
面试高频算法题目
qq_35515283的博客
01-06 192
二叉树： NC45实现二叉树先序，中序和后序遍历 public class Solution { /** * * @param root TreeNode类 the root of binary tree * @return int整型二维数组 */ public int[][] threeOrders (TreeNode root) { //三个集合，分别存储三种遍历结果 List<Integer>.
高频面试算法题汇总
wwxy1995的博客
09-22 640
面试心态: 1. 如果遇到做过，非常熟悉的算法题，和面试官沟通清楚题意，讲清楚思路，然后开始写代码，做到bug free. 2. 如果遇到见过，但不是那么容易的算法题，比如Leetcode 4题， 将中文数字转换为数字，那么不要急，多列举一些case，和面试官多交流，沟通。尽可能说清楚思路，然后把代码写出来。 3. 如果遇到从来没见过的题目，不要慌，冷静下来，慢慢想，一个小时的时间，先沟通清楚题目，想清楚思路，然后和面试管说思路，如果实在不会，问面试管又没有提示，然后我们自己把代码写出来。 1.
2023年大厂前端面试高频算法题：合并有序链表
在2023年的前端求职面试中，算法题作为高频考点，对于理解和解决这类问题至关重要。本篇内容主要关注于合并两个有序链表的问题，这是一个经典的编程题目，常用于考察面试者的数据结构和递归/迭代思维。 题⽬描述： ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值