程序员面试金典编程学习

最新推荐文章于 2023-06-10 20:11:52 发布
最新推荐文章于 2023-06-10 20:11:52 发布
阅读量207 收藏
点赞数
分类专栏： Coding 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38826019/article/details/90257230
版权

1.

import java.util.*;
 
public class Different {
    public boolean checkDifferent(String iniString) {
        // write code here
        char st = iniString.charAt(0);
        for(int i=1;i<iniString.length();i++){
            if(st == iniString.charAt(i)){
                return false;
            }
        }
        return true;
    }
}

2.

import java.util.*;
 
public class Reverse {
    public String reverseString(String iniString) {
        int len=iniString.length();
        if(len<=1||iniString==null)
            return iniString;
        StringBuffer sb=new StringBuffer();
        for(int i=len-1;i>=0;i--){
            sb.append(iniString.charAt(i));
        }
        return sb.toString();
        // write code here
    }
}

3.

import java.util.*;
 
public class Same {
    public boolean checkSam(String stringA, String stringB) {
        // write code here
        int lenA=stringA.length();
        int lenB=stringB.length();
        if(lenA!=lenB){
            return false;
        }else{
            int[] A=new int[256];
            int[] B=new int[256];
            for(int i=0;i<stringA.length();i++){
                A[stringA.charAt(i)]++;
            }
            for(int i=0;i<stringA.length();i++){
                B[stringB.charAt(i)]++;
            }
            for(int i=0;i<256;i++){
                if(A[i]!=B[i]){
                    return false;
                }
            }
             
        }
        return true;
    }
}

4.

import java.util.*;
 
public class Replacement {
    public String replaceSpace(String iniString, int length) {
        // write code here
        StringBuilder sb=new StringBuilder();
        String strReplace="%20";
        for(int i=0;i<length;i++){
            char tmp=iniString.charAt(i);
            if(tmp==' '){
                sb.append(strReplace);
            }else{
                sb.append(tmp);
            }
        }
        return sb.toString();
    }
}

5.

import java.util.*;
 
public class Zipper {
    public String zipString(String iniString) {
         
        int low = 0 , high = 0 ;
                 
        int len = iniString.length();
         
        StringBuilder sb = new StringBuilder();
          
        char c = ' ';
          
        int count = 0;
         
        while(low < len){
            high = low;
            c = iniString.charAt(low);
            while((high < len)&&(iniString.charAt(high) == c)){
                high ++;
            }
            count = high - low ;
            sb.append(c);
            sb.append(count);
            low = high;
        }
         
 
         
        return (sb.toString().length() < len)?sb.toString():iniString;
    }
}

6.

import java.util.*;
 
public class Transform {
    public int[][] transformImage(int[][] mat, int n) {
        // write code here
        int[][] a=new int[n][n];
       
        //第一步转置
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            a[j][i]=mat[i][j];
        }
    }
        //第二步换列
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            mat[i][j]=a[i][n-1-j];
        }
    }
    return mat;
    }
}

7.

import java.util.*;
 
public class Clearer {
    public int[][] clearZero(int[][] mat, int n) {
        // write code here
        if (mat == null)    return mat;
 
        boolean[] rows = new boolean[mat.length];
        boolean[] cols = new boolean[mat[0].length];
 
        for (int i = 0; i < mat.length; i++) {
            for (int j = 0; j < mat[0].length; j++) {
                if (mat[i][j] == 0) {
                    rows[i] = true;
                    cols[j] = true;
                }
            }
        }
 
        for (int i = 0; i < mat.length; i++) {
            for (int j = 0; j < mat[0].length; j++) {
                if (rows[i] || cols[j]) {
                    mat[i][j] = 0;
                }
            }
        }
 
        return mat;
    }
}

8.

import java.util.*;
 
public class ReverseEqual {
   public boolean checkReverseEqual(String s1, String s2) {
        // write code here
        byte[] s1arr = s1.getBytes();
        byte[] s2arr = s2.getBytes();
        Arrays.sort(s1arr);
        Arrays.sort(s2arr);
        if (Arrays.equals(s1arr,s2arr)){            
                return true;
        }
        return false;
    }
    
    
}

9.

/*
public class ListNode {
    int val;
    ListNode next = null;
 
    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindKthToTail(ListNode list,int k) {
if (list == null)   return list;
 
        ListNode node = list;
        int count = 0;
        while (node != null) {
            count++;
            node = node.next;
        }
        if (count < k)  return null;
 
        ListNode p = list;
        for (int i = 0; i < count - k; i++) {
            p = p.next;
        }
         
        return p;
    }
}

10.

import java.util.*;
 
/*
public class ListNode {
    int val;
    ListNode next = null;
 
    ListNode(int val) {
        this.val = val;
    }
}*/
public class Remove {
    public boolean removeNode(ListNode pNode) {
        // write code here
        ListNode newNode = pNode;
        pNode = pNode.next;
        if(newNode.next==null) return false;
        else return true;
    }
}

11.

import java.util.*;
 
/*
public class ListNode {
    int val;
    ListNode next = null;
 
    ListNode(int val) {
        this.val = val;
    }
}*/
public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        // write code here
        if(pHead == null || pHead.next == null)
        {
            return pHead;
        }
        ListNode cur = pHead;
        ListNode Shead = new ListNode(-1);
        ListNode Bhead = new ListNode(-1);
        ListNode Stmp = Shead;
        ListNode Btmp = Bhead;
        while(cur != null){
            if(cur.val < x){
                Stmp.next = new ListNode(cur.val);
                Stmp = Stmp.next;
            }else{
                Btmp.next = new ListNode(cur.val);
                Btmp = Btmp.next;
            }
            cur = cur.next;
        }
        cur = Shead;
        while(cur.next != null && cur.next.val != -1){
            cur = cur.next;
        }
        cur.next = Bhead.next;
        return Shead.next;
         
         
         
    }
}

12.

import java.util.*;
/*
public class ListNode {
    int val;
    ListNode next = null;
 
    ListNode(int val) {
        this.val = val;
    }
}*/
public class Plus {
    public ListNode plusAB(ListNode a, ListNode b) {
        // write code here
         ListNode start = null;
         ListNode current = null;
         if(a == null && b == null) return start;
         int plus = 0;
         while(a!=null || b!= null){
             int tmp = plus;
             if(a!=null)
                 tmp += a.val;
             if(b!=null)
                 tmp+=b.val;
             if(start == null){
                 current = new ListNode(tmp%10);
                 start = current;
                 plus = tmp/10;
                  
             }else {
                current.next=new ListNode(tmp%10);
                current  = current.next;
                plus = tmp/10;
            }
             if(a==null&& b!=null)
                 b=b.next;
             else if(a!=null && b== null)
                 a=a.next;
             else {
                 a=a.next;
                 b=b.next;
            }
              
         }
        if(plus == 1)
             current.next = new ListNode(plus);
         
         return start;
    }
}

13.

import java.util.*;
 
/*
public class ListNode {
    int val;
    ListNode next = null;
 
    ListNode(int val) {
        this.val = val;
    }
}*/
public class Palindrome {
    public boolean isPalindrome(ListNode pHead) {
        ListNode pLength=pHead;
        ListNode p=pHead;
        int length=1;
        //求链表长度
        while(pLength.next!=null){
            length++;
            pLength=pLength.next;
        }
        Stack<Integer> sp=new Stack<Integer>();
        int nodeIndex=0;
        while(nodeIndex<=length/2-1)
        {
            sp.push(p.val);
            p=p.next;
            nodeIndex++;
        }
        int temp;
        //若长度为奇数
        if(length%2!=0)
            p=p.next;
        while(!sp.isEmpty())
        {
            temp=sp.pop();
            if(temp!=p.val)
                return false;
            p=p.next;
        }
        return true;
    }
}

14.

import java.util.*;
 
public class SetOfStacks {
    public ArrayList<ArrayList<Integer>> setOfStacks(int[][] ope, int size) {
        ArrayList<ArrayList<Integer>> SetOfStacks=new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> inner=new ArrayList<Integer>();
        SetOfStacks.add(inner);
        for(int i=0;i<ope.length;i++)
        {
            inner=SetOfStacks.get(SetOfStacks.size()-1);
            if(ope[i][0]==1)
            {
                if(inner.size()<size)
                    inner.add(ope[i][1]);
                else
                {
                    inner=new ArrayList<Integer>();
                    inner.add(ope[i][1]);
                    SetOfStacks.add(inner);
                }
            }
            if(ope[i][0]==2)
            {
                //若stack已经为空
                if(SetOfStacks.get(0).size()==0)
                    continue;
                if(inner.size()==0)
                {
                    SetOfStacks.remove(SetOfStacks.size()-1);
                    inner=SetOfStacks.get(SetOfStacks.size()-1);
                }
                inner.remove(inner.size()-1);
            }
        }
        return SetOfStacks;
    }
}

15.

import java.util.Stack;
 
public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
     
    public void push(int node) {
        stack1.push(node);
    }
     
    public int pop() {
        while(!stack1.isEmpty()){
            stack2.push(stack1.pop());
        }
        int first=stack2.pop();
        while(!stack2.isEmpty()){
            stack1.push(stack2.pop());
        }
        return first;
    }
}

16.

import java.util.*;
 
public class TwoStacks {
    public ArrayList<Integer> twoStacksSort(int[] numbers) {
        Stack<Integer> stack1=new Stack<Integer>();
        Stack<Integer> stack2=new Stack<Integer>();
         
        ArrayList<Integer>  list=new ArrayList<Integer>();
        for(int  i=0;i<numbers.length;i++)
            stack1.push(numbers[i]);
        while(!stack1.isEmpty())
        {
            //暂时取出stack1最顶端的 好让stack2中比他大的暂时进入stack1
            int temp=stack1.pop();
            while(!stack2.isEmpty() && stack2.peek()>temp)
            {
                stack1.push(stack2.pop());
            }
            stack2.push(temp);
        }
        while(!stack2.isEmpty())
        {
            list.add(stack2.pop());
        }
        return list;
    }
}

17.

import java.util.*;
 
public class CatDogAsylum {
    public ArrayList<Integer> asylum(int[][] ope) {
        Queue<Integer> dog=new LinkedList<Integer>();
        Queue<Integer> cat=new LinkedList<Integer>();
        Queue<Integer> all=new LinkedList<Integer>();
        ArrayList<Integer> animal=new ArrayList<Integer>();
        for(int i=0;i<ope.length;i++)
        {
            if(ope[i][0]==1)
            {
                all.add(ope[i][1]);
                if(ope[i][1]>0)
                    dog.add(ope[i][1]);
                else if(ope[i][1]<0)
                    cat.add(ope[i][1]);
            }
            else if(ope[i][0]==2)
            {
                if(ope[i][1]==0)
                {
                    if(!all.isEmpty())
                    {
                        //看最先被领养的是猫还是狗 同步删除猫或狗中的stack
                        int temp=all.poll();
                        animal.add(temp);
                        if(temp>0)
                            dog.poll();
                        else
                            cat.poll();
                    }
                }
                else if(ope[i][1]>0)
                {
                    if(!dog.isEmpty())
                    {
                        //看最先被领养的是猫还是狗 同步删除混合stack中的值
                        int temp=dog.poll();
                        animal.add(temp);
                        all.remove(temp);
                    }
                }
                else
                {
                    if(!cat.isEmpty())
                    {
                        //看最先被领养的是猫还是狗 同步删除混合stack中的值
                        int temp=cat.poll();
                        animal.add(temp);
                        all.remove(temp);
                    }
                }
            }
        }
        return animal;
    }
}

18.

import java.util.*;
 
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class Balance {
  public boolean isBalance(TreeNode root) {
        // write code here
        if(root==null)
            return true;
        if(Math.abs(deepth(root.left)-deepth(root.right))>1)
            return false;
        else
            return isBalance(root.left)&isBalance(root.right);
    }
    public int deepth(TreeNode root){
        if(root==null)
            return 0;
        return Math.max(deepth(root.left),deepth(root.right))+1;
    }
}

19.

import java.util.*;
 
 
public class Path
{public boolean checkPath(UndirectedGraphNode a, UndirectedGraphNode b) {
    if (null == a || null == b)
        return false;
    HashSet<UndirectedGraphNode> map = new HashSet<UndirectedGraphNode>();
    boolean res = checkPathCore(a, b,map);
    map.clear();
    return  res||checkPathCore(b, a,map);
}
  
public boolean checkPathCore(UndirectedGraphNode a, UndirectedGraphNode b,HashSet<UndirectedGraphNode> map) {
    if (a == b)
        return true;
    map.add(a);// 标记a已被访问
    for (int i = 0; i < a.neighbors.size(); i++) {
        if(!map.contains(a.neighbors.get(i))&&checkPathCore(a.neighbors.get(i), b,map))
            return true;// 发现满足条件的路径立即返回，避免不必要的循环，导致超时。
    }
    return false;
}
     
}

20.

import java.util.*;
 
public class MinimalBST {
    public int buildMinimalBST(int[] vals) {
        int len = vals.length;
        if(len ==0){
            return 0;
        }else if(len ==1){
            return 1;
        }
        int a[] =new int[len/2];
        for(int i=0;i<len/2;i++){
            a[i]=vals[i];
        }
        return buildMinimalBST(a)+1;
    }
}

星夜孤帆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
程序员面试金典 源码
07-07
程序员面试金典 源码 包含JAVA、C、c++等语言实现
程序员面试金典(1):确定字符互异(python)
KG
08-20 413
程序员面试金典(1):确定字符互异(python)题目描述请实现一个算法，确定一个字符串的所有字符是否全都不同。
程序员的SQL金典(完整版).pdf
01-09
传智播客内部资料，杨中科老师的力作，初，中，高级程序员必备SQL笔记。完整版的
程序员的SQL金典(思路非常清晰的数据库书籍)
11-26
该书是杨中科老师亲自编写的，试读版，但是内容还是非常丰富的。非常优秀的SQL学习书籍。
【算法专题】《程序员面试金典 - 学习计划 - 力扣（LeetCode）》学习大纲 & 学习笔记（持续更新中......)
最新发布
Shipley_Leo的博客
06-10 1045
【算法专题】程序员面试金典 - 学习计划 - 力扣（LeetCode）
程序员面试金典 17.4
RayoNicks的博客
07-14 233
Missing Number：从[1, n]中找出缺失的一个数。 这道题应该是微软的面试题，我在《编程之美》中看过，该题的另外一个限制就是只能访问二进制位，但是力扣上没有限制，所以就变成了简单题——利用求和公式算出的结果和数组和的差值就是缺失的数。 class Solution { public: int missingNumber(vector<int>& nums) { int sum = accumulate(nums.begin(), nums.end()
程序员面试金典
ZCC的专栏
11-08 784
偶然发现牛客网程序员面试金典在线编程题和学习算法经验:
《程序员面试金典》.pdf
田维常
11-18 1650
关注“Java后端技术全栈”回复“面试”获取全套面试资料面试成功与否，取决于面试者的底蕴（气场+技能）、心态和认知及沟通技巧。其实我们只需要搞清楚一个逻辑：“面试官为什么会这样问？他希望...
《程序员的SQL金典》(rupeng.com原版）
08-18
《程序员的SQL金典》是rupeng.com的创始人杨中科老师的著作是一本很好的书，对于大家的学习非常的实用。
程序员面试金典 第六版英文
02-03
《程序员面试金典 第六版英文》是编程领域内广受欢迎的一本书，旨在帮助程序员准备技术面试，特别是针对硅谷及其他地方的顶级科技公司。这本书由Gayle Laakmann McDowell编写，她是Google、Microsoft和Apple等公司的...
程序员面试金典5
08-20
《程序员面试金典5》是一本深受欢迎的面试准备指南，尤其对于想要在Java和C++领域求职的程序员来说，更是必备的参考资料。这本书涵盖了广泛的编程语言基础、数据结构、算法以及软件工程等方面的知识，旨在帮助读者...
程序员面试金典-第五版
04-14
本书是原谷歌资深面试官的经验之作，层层紧扣程序员面试的每一个环节，全面而详尽地介绍了程序员应当如何应对面试，才能在面试中脱颖而出。第1～7 章主要涉及面试流程解析、面试官的幕后决策及可能提出的问题、面试...
程序员面试金典 第五版
02-03
《程序员面试金典 第五版》是一本深受程序员和求职者欢迎的书籍，它全面覆盖了面试准备过程中可能遇到的各种技术和非技术问题。这本书旨在帮助程序员提升自身的技能，顺利通过面试，迈向职业生涯的新阶段。 首先，...
牛客之程序员面试金典_ 编程题（一）
JSJWR的博客
03-16 486
1.确定字符串互异 请实现一个算法，确定一个字符串的所有字符是否全都不同。这里我们要求不允许使用额外的存储结构。 给定一个string iniString，请返回一个bool值,True代表所有字符全都不同，False代表存在相同的字符。保证字符串中的字符为ASCII字符。字符串的长度小于等于3000。 测试样例： “aeiou” 返回：True “BarackObama” 返回：F...
程序员面试金典 5.8
RayoNicks的博客
04-09 160
Draw Line：黑白显示器的屏幕现存可以看做一个一维数组，屏幕上的的每一个像素用1个比特位表示，所以单字节就存储了8个像素，int存储了32个像素。假设屏幕的宽度w是32的倍数，屏幕的高度可以根据数组的长度length和w计算得到。写一个函数，实现一条从(x1, y)到(x2, y)的水平线的绘制。 可以通过一个循环，将从x1到x2的比特位全部置位，但是更高效率的方法是将[x1, x2]中所有...
程序员面试金典--笔记(精华篇)
onephone的专栏
02-01 2992
原文链接:http://codeshold.me/2017/01/cracking_interview.html 《程序员面试金典》 1-7章的总结 相关读物《金领简历：敲开苹果、微软、谷歌的大门》（Cayle Laakmann McDowell 盖尔 拉克曼 麦克道尔）careercup.com
程序员面试攻略：JAVA编程与面试技巧
"程序员面试技巧与经验分享" 程序员面试是一个决定性的环节，它不仅考察候选人的技术实力，还涉及沟通能力和职业素养。以下是对标题和描述中提到的知识点的详细阐述...记住，每一次面试都是一次学习和提升自我的过程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值