【面试编程题】-10剑指offer之面试中的各项能力

最新推荐文章于 2019-08-09 12:01:52 发布

记忆力不好

最新推荐文章于 2019-08-09 12:01:52 发布

阅读量1.3k

点赞数 1

分类专栏：剑指offer 文章标签：面试编程剑指offer

本文链接：https://blog.csdn.net/chenchaofuck1/article/details/52129794

版权

剑指offer 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

下面的例题来自于剑指offer的第6章的内容，主要考察面试者在面试过程当中的沟通、学习等方面的能力

1.数字在排序数组中出现的次数

题目描述
统计一个数字在排序数组中出现的次数。

思路：
在排序数组当中查找用二分法，分别查找到数的起始位置和结束位置。时间复杂度是（logn）。

public class Solution {
    public int GetNumberOfK(int [] array , int k) {
       if(array.length==0)
           return 0;
       int first=getIndex(array,k,0);
       int end=getIndex(array,k,1);
       if(first!=-1 && end!=-1) 
            return end-first+1;
        return 0;
    }
    public int getIndex(int[] array,int k,int flag){
       int s=0;
       int e=array.length-1;
       if(e<0)
           return 0;
       while(s<=e){
           int m=(s+e)/2;
           if(array[m]==k){
               if(flag==0){
                    if((m-1>=0 && array[m-1]!=k) || m==0)
                        return m;
                    else 
                        e=m-1;
               }else{
                    if((m+1<array.length && array[m+1]!=k) || m==array.length-1)
                        return m;
                    else 
                        s=m+1; 
               }    
           }
           else if(array[m]<k){
               s=m+1;
           }
           else{
               e=m-1;
           }
       } 
       return -1;
    }
}

2.二叉树的深度

题目描述
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

思路：
二叉树都用递归思路

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
};*/
public class Solution {
    public int TreeDepth(TreeNode pRoot)
    {
        if(pRoot==null)
            return 0;
        int left=TreeDepth(pRoot.left);
        int right=TreeDepth(pRoot.right);
        return Math.max(left,right)+1;
    }
}

3.平衡二叉树

题目描述

输入一棵二叉树，判断该二叉树是否是平衡二叉树。
思路：
如果这道题利用上一题的求深度，如果两个子节点的深度不一样，肯定不是平衡树；如果一样，继续递归两个子节点；这种方式会造成，大量重复计算深度。利用动态规划的思想，从子节点开始先上遍历。

public class Solution {
     public boolean IsBalanced_Solution(TreeNode root) {
        if(root==null)
            return true;
        MyInt count=new MyInt(0);
        if(IsBalanced_Solution(root,count)){        
            return true;
        }
          return false;


    }
    public boolean IsBalanced_Solution(TreeNode root,MyInt count){
         if(root==null){
            //count=0; 
            return true;
         }    
         MyInt leftCount=new MyInt(0);
         MyInt rightCount=new MyInt(0);
        if(IsBalanced_Solution(root.left,leftCount) && IsBalanced_Solution(root.right,rightCount)){
            count.count=Math.max(leftCount.count,rightCount.count)+1;
            return Math.abs(leftCount.count-rightCount.count)<=1;
        }else{
            return false;
        }
    }
    class MyInt{
        int count;
        MyInt(int count){
            this.count=count;
        }
    }

}

4.数组中只出现一次的数字

题目描述

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

思路：
利用“一个整型数组里除了1个数字之外，其他的数字都出现了两次”题的思路。如果把不同的那两个数分到不同的数组当中。对两个数组分别异或运算就能找出两个不同的数。
主要考虑怎么把两个划分到不同的数组当中。因为两个不同所以二进制上至少有一位是不同，通过异或数组里所有的数，找出这一位来。通过这一位和所有的数进行与运算就能划分成两个数组。

//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        int x=0;
        for(int i=0;i<array.length;i++){
            x^=array[i];
        }
        if(x==0)
         return;   
        int y=1;
        while((x&y)!=y){
            y<<=1;
        }
        for(int i=0;i<array.length;i++){
            if((array[i]&y)==y){
                num1[0]^=array[i];
            }else{
                num2[0]^=array[i];
            }
        }
    }
}

5.和为S的连续正数序列

题目描述

小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

输出描述:
输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序。

思路：
因为序列至少两个数，所以不能超过n/2。用两个指针代表序列的头和尾，序列初始从1开始增加（1,2,3…），直到序列和大于，当序列和超过S时，头开始向后移动，直到小于S。在移动的过程当中等于S，就记录一次。

import java.util.ArrayList;
public class Solution {
    public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
        ArrayList<ArrayList<Integer>> allList=new ArrayList<>();
        ArrayList<Integer> list;
        if(sum==1)
            return allList; 
        int i=1,j=1;
        int curSum=0;
        while(j<=sum/2+1){
            curSum+=j;          
            while(curSum>sum){                
                curSum-=i++;                
            }
            if(curSum==sum){
                list=new ArrayList<>();
                int t=i;
                while(t<=j){
                    list.add(t++);
                }
                allList.add(list);
            }
            j++;
        }
        return allList;
    }
}

6、和为S的两个数字

题目描述

输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

输出描述:
对应每个测试案例，输出两个数，小的先输出。

思路：
求两数和的问题，对有序的数组利用双指针分别指向头和尾，逐步向中间靠近。第一个找到的数对，乘积也是最小的。

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
        ArrayList<Integer> list=new ArrayList<>();
        int i=0;
        int j=array.length-1;
        while(i<j){
            int s=array[i]+array[j];
            if(s==sum){
                list.add(array[i]);
                list.add(array[j]);
                return list;
            }
            else if(s<sum){
                i++;
            }
            else{
                j--;
            }

        }
        return list;
    }
}

7.左旋转字符串

题目描述

汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

public class Solution {
    public String LeftRotateString(String str,int n) {
        String result="";
        int len=str.length();
        if(len==0)
            return result;
        n=n%len;       
        result+=str.substring(n,len)+str.substring(0,n);
        return result;

    }
}

8.翻转单词顺序列

题目描述

牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

public class Solution {
    public String ReverseSentence(String str) {
        String[] s=str.split(" ");
        StringBuilder sb=new StringBuilder();
        if(s.length==0)
            return str;
        for(int i=s.length-1;i>=0;i--){
            if(i==0)
                sb.append(s[i]);
            else
                sb.append(s[i]+" ");
        }
        return sb.toString();
    }
}

9.扑克牌顺子

题目描述

LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…..LL不高兴了,他想了想,决定大\小王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何。为了方便起见,你可以认为大小王是0。

思路：
对数组排序，统计0的数和空隙的数，如果0的数大于空隙的数，就能可以成顺子。（注意有对子就不可能是顺子了）

import java.util.Arrays;
public class Solution {
    public boolean isContinuous(int [] numbers) {
        if(numbers==null || numbers.length==0)
            return false;
        Arrays.sort(numbers);
        int countOfZero=0;
        int countOfGap=0;
        for(int i=0;i<numbers.length-1;i++){
            if(numbers[i]==0)
                countOfZero++;
            else if(numbers[i]==numbers[i+1])
                return false;
            else 
                countOfGap+=numbers[i+1]-numbers[i]-1;
        }
        if(countOfGap<=countOfZero)
            return true;
        return false;
    }
}

10.求1+2+3+…+n

题目描述

求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

思路：
不能用循环和条件判断，则迭代和递归都不行。
下面利用逻辑运算符的短路实现实现递归。

public class Solution {
    public int Sum_Solution(int n) {
        int sum=n;
        boolean flag= n==0 || (sum+=Sum_Solution(n-1))==0;
        return sum;                
     }
}

11.不用加减乘除做加法

题目描述

写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

思路：
不能使用四则运算，就只能考虑位运算。
主要分析运算的过程：先各位相加（使用异或^模拟），查看是否有进位（与&运算模拟，结果非0表示有进行）。

public class Solution {
    public int Add(int num1,int num2) {
        int sum=0;
        int carry=0;
        do{
             sum=num1^num2;
             carry=(num1 & num2)<<1;
             num1=sum;
             num2=carry;
        }while(carry!=0);
        return sum;
    }
}

12.孩子们的游戏(圆圈中最后剩下的数)

题目描述
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数….这样下去….直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_^)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)

思路：
约瑟夫环问题，可以利用链表结构模拟游戏过程，找出最后的数。

import java.util.LinkedList;
public class Solution {
    public int LastRemaining_Solution(int n, int m) {
        LinkedList<Integer> list=new LinkedList<>();
        if(n==0 || m==0)
            return -1;
        int i;
        for(i=0;i<n;i++){
            list.add(i);
        }
        i=0;
        int count=n;
        while(count>1){
            int index=(i+m-1)%count;
            list.remove(index);
            i=(i+m-1)%count;
            count--;
        }
        return list.get(0);
    }
}

也可以使用数学规律：

public class Solution {
    public int LastRemaining_Solution(int n, int m) {
     if(n < 1 || m < 1)
         return -1;
     if(n == 1){
         return 0;
     }
     return (LastRemaining_Solution(n-1, m)+m)%n;
    }
}

13.n个骰子的点数

题目描述：

把n个骰子仍在地上，所有骰子朝上一面的点数之和为s，输入n，打印出s的所有可能的值出现的概率。

思路：

有k-1个骰子时，再增加一个骰子，这个骰子的点数只可能为1、2、3、4、5或6。那k个骰子得到点数和为n的情况有：
(k-1,n-1)：第k个骰子投了点数1
(k-1,n-2)：第k个骰子投了点数2
(k-1,n-3)：第k个骰子投了点数3
….
(k-1,n-6)：第k个骰子投了点数6
在k-1个骰子的基础上，再增加一个骰子出现点数和为n的结果只有这6种情况！
所以：f(k,n)=f(k-1,n-1)+f(k-1,n-2)+f(k-1,n-3)+f(k-1,n-4)+f(k-1,n-5)+f(k-1,n-6)
初始化：有1个骰子，f(1,1)=f(1,2)=f(1,3)=f(1,4)=f(1,5)=f(1,6)=1。

    public void PrintProbability(int n){
        if(n<1)
            return;
        int[][] pro=new int[n+1][n*6+1];
        for(int i=1;i<=6;i++){
            pro[1][i]=1;
        }
        for(int k=2;k<=n;k++){
            for(int j=k;j<=k*6;j++){
                int sum=0;
                for(int m=1;m<=6 && m<j;m++)
                    sum+=pro[k-1][j-m];
                pro[k][j]=sum;
            }       
        }
        double total=Math.pow(6, n);
        for(int i=n;i<=n*6;i++){
            System.out.println(i+":"+pro[n][i]/total);
        }

    }

记忆力不好

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【面试编程题】-10剑指offer之面试中的各项能力

下面的例题来自于剑指offer的第6章的内容，主要考察面试者在面试过程当中的沟通、学习等方面的能力1.数字在排序数组中出现的次数题目描述统计一个数字在排序数组中出现的次数。思路：在排序数组当中查找用二分法，分别查找到数的起始位置和结束位置。时间复杂度是（logn）。public class Solution { public int GetNumberOfK(int []
复制链接

扫一扫