面试笔记@常见操作及经典题型模板

最新推荐文章于 2024-05-02 09:31:29 发布

晚安丶

最新推荐文章于 2024-05-02 09:31:29 发布

阅读量230

点赞数

分类专栏：面试文章标签：面试

本文链接：https://blog.csdn.net/william_munch/article/details/115384560

版权

面试专栏收录该内容

13 篇文章 1 订阅

订阅专栏

这篇博客介绍了Java中将字符串转换为char数组的方法，以及如何添加前导零。还展示了如何创建二维动态数组和进行排序。此外，详细讲解了求最大公约数和最小公倍数的算法。进一步，博主分享了解决拓扑排序、BFS水域大小计算和冗余连接查找的经典问题的代码实现。最后，通过八皇后问题的回溯算法演示了回溯法的应用。

摘要由CSDN通过智能技术生成

常见操作

String转char数组

char[] t1 = word1.toCharArray();

前导零

String formatted = String.format("%03d", num);

创建二维动态数组

List<List<Integer>> a=new ArrayList<>();

排序

public class PersonComparator implements Comparator<Person>
{
    public int compare(Person o1, Person o2)
    {
        return o1.getAge()-o2.getAge();
    }
}


Arrays.sort(people,new PersonComparator());//people是数组
Collections.sort(people,new PersonComparator());//people是list

最大公约数

最小公倍数

//  最大公约数
int gcd(int a, int b) {
    return b != 0 ? gcd(b, a % b) : a;
}

// 最小公倍数
int lcm(int a,int b) {    
    return a/gcd(a,b)*b;  
}

经典题型

拓扑

力扣 207. 课程表

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        int[] indegrees = new int[numCourses];
        List<List<Integer>> adjacency = new ArrayList<>();
        Queue<Integer> queue = new LinkedList<>();
        for(int i = 0; i < numCourses; i++)
            adjacency.add(new ArrayList<>());
        // Get the indegree and adjacency of every course.
        for(int[] cp : prerequisites) {
            indegrees[cp[0]]++;
            adjacency.get(cp[1]).add(cp[0]);
        }
        // Get all the courses with the indegree of 0.
        for(int i = 0; i < numCourses; i++)
            if(indegrees[i] == 0) queue.add(i);
        // BFS TopSort.
        int visit=0;
        while(!queue.isEmpty()) {
            int pre = queue.poll();
            visit++;
            for(int cur : adjacency.get(pre))
                if(--indegrees[cur] == 0) queue.add(cur);
        }
        return numCourses == visit;
    }
}

BFS

力扣面试题 16.19. 水域大小

class Solution {
    private static final int[][] DIRS = new int[][] {{0, -1}, {-1, -1}, {-1, 0}, {-1, 1},{0, 1}, {1, 1}, {1, 0}, {1, -1}};
    public int[] pondSizes(int[][] land) {
        int m=land.length;
        int n=land[0].length;
        List<Integer> res=new ArrayList<>();
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
                if(land[i][j]==0)
                    res.add(dfs( land, i, j, m, n));
            
        int []ress=new int[res.size()];
        for(int i=0;i<ress.length;i++)
            ress[i]=res.get(i);
        Arrays.sort(ress);
        return ress;
    }
    int dfs(int[][] land,int i,int j,int m,int n)
    {
        int num=0;
        if(i<0||i>=m||j<0||j>=n)
            return 0;
        else if(land[i][j]==0)
        {
            land[i][j]=-1;//flag
            num++;
            for(int k=0;k<8;k++)
                num+=dfs(land, i+DIRS[k][0], j+DIRS[k][1], m, n);
        }
        return num;
    }
}

并查集

力扣 684. 冗余连接

class Solution {
    public int[] findRedundantConnection(int[][] edges) {
        int n=edges.length;
        UnionFind uf=new UnionFind(n);
        for(int i=0;i<n;i++)
        {
            if(uf.union(edges[i][0]-1,edges[i][1]-1)<0)
                return edges[i];
        }
        return null;
    }
    private class UnionFind {
        private int[] parent;
        public UnionFind(int n) {
            this.parent = new int[n];
            for (int i = 0; i < n; i++) {
                parent[i] = i;
            }
        }
        public int root(int x) {
            while (x != parent[x]) {
                parent[x] = parent[parent[x]];
                x = parent[x];
            }
            return x;
        }
        public boolean isConnected(int x, int y) {
            return root(x) == root(y);
        }
        public int union(int p, int q) {
            if (isConnected(p, q)) 
                return -1;
            parent[root(p)] = root(q);
            return 1;
        }
    }
}

回溯

八皇后

class Solution {
    public List<List<String>> solveNQueens(int n) {
        //生成N*N的棋盘
        char[][] arr = new char[n][n];
        //填充棋盘，每个格子默认是“。”表示没有放置皇后
        for(int i=0;i<n;++i) {
            Arrays.fill(arr[i],'.');
        }
        List<List<String>> res = new ArrayList<List<String>>();
        dfs(arr,0,n,res);
        return res;
    }
    //检查当前的行和列是否可以放置皇后
    private boolean check(char[][] arr,int x,int y,int n) {
        //检查竖着的一列是否有皇后
        for(int i=0;i<x;++i) {
            if(arr[i][y]=='Q') {
                return false;
            }
        }
        //检查左上到右下的斜边是否有皇后
        int i=x-1, j=y-1;
        while(i>=0 && j>=0) {
            if(arr[i][j]=='Q') {
                return false;
            }
            --i;
            --j;
        }
        //检查左下到右上的斜边是否有皇后
        i = x-1;
        j = y+1;
        while(i>=0 && j<n) {
            if(arr[i][j]=='Q') {
                return false;
            }
            --i;
            ++j;
        }
        return true;
    }

    private void dfs(char[][] arr,int x,int n,List<List<String>> res) {
        //x是从0开始计算的，当x==n时所有行的皇后都放置完毕，此时记录结果
        if(x==n) {
            List<String> ans = new ArrayList<String>();
            for(int i=0;i<n;++i) {
                StringBuilder tmp = new StringBuilder();
                for(int j=0;j<n;++j) {
                    if(arr[i][j]=='.') {
                        tmp.append(".");
                    } else {
                        tmp.append("Q");
                    }
                }
                ans.add(tmp.toString());
            }
            res.add(ans);
            return;
        }
        //遍历每一列
        for(int y=0;y<n;++y) {
            //检查[x,y]这一坐标是否可以放置皇后
            //如果满足条件，就放置皇后，并继续检查下一行
            if(check(arr,x,y,n)) {
                arr[x][y] = 'Q';
                dfs(arr,x+1,n,res);
                arr[x][y] = '.';
            }
        }
    }
}

未完待续 ……