20170921汇智和悦世界笔试题

最新推荐文章于 2022-10-12 16:37:25 发布

张超帅

最新推荐文章于 2022-10-12 16:37:25 发布

阅读量396

点赞数

分类专栏：笔试面试

本文链接：https://blog.csdn.net/weixin_38070406/article/details/78047112

版权

笔试面试专栏收录该内容

13 篇文章 0 订阅

订阅专栏

计算1000之内的所有质数

package lanqiao;

public class Test12 {

    public static void main(String[] args) {
        Test12 test=new Test12();
        test.findNum(1000);
    }

    public int isPrime(int a){
        int i;
        for( i=2;i<a;i++){
            if(a%i==0){
                return 0;
            }
        }
        return 1;
    }

    public void findNum(int num){
        int i,n;
        System.out.print("列举1-1000之间的素数");
        for(i=1;i<1000;i++){
            if(isPrime(i)==1){
                System.out.print("  "+i+"  ");
            }

        }
    }

}

兔子产子算法

int Fibonacci(int n){
    int t1,int t2;
    if(n==1   || t==2) return 1;
    else
        t1=Fibonacci(n-1);
        t2=Fibonacci(n-2);
        return t1+t2;
}

对于斐波那契数列用递归会有很严重的效率问题，想办法避免重复计算，比如我们可以把已经得到数列中间项保存起来，如果下次需要计算的时候我们先查找一下，如果前面已经计算过就不用再重复计算了。

    public long Fibonacci(int n){
        long result=0;
        long preOne=0;
        long preTwo=1;
        //迭代方法，用两个变量记录fn-1和fn-2:    递归，不考虑，有大量的重复计算，会导致内存溢出
        if(n==0){
            return preOne;
        }
        if(n==1){
            return preTwo;
        }
        for(int i=2;i<=n;i++){
            result=preOne+preTwo;
            preOne=preTwo;
            preTwo=result;
        }
        return result;
    }

是否是平衡二叉树

public boolean isBalanced(BinaryTreeNode root){
    int depth=0;
    return Balanced(root,depth);
} 

pubic boolean  Balanced(BinaryTreeNode root,int depth){
    if(root==null){
        depth=0;
        return true;
    }
    int left=0,right=0;
    if(Balanced(root.leftNode,left) && Balanced(root.rightNode,right)){
        int diff=left-right;
        if(diff<=1 && diff>=-1){
            depth=1+(left>right?left:right);
            return true;
        }
    }
    return false;
}

求n个数的第三小的数
相当于是剑指offer中最小的 k个数

package offer;

import java.util.Arrays;

public class Problem30 {

    public static void main(String[] args) {
        Problem30 test=new Problem30();
        int[] array={4,5,1,6,2,7,3,8};
        test.getLeastNumbers(array,2);
    }

    private void getLeastNumbers(int[] array, int k) {
        if(array==null || k<0 || k>array.length){
            return ;
        }
        int[] kArray=Arrays.copyOfRange(array, 0, k);
        for(int i=k;i<array.length;i++){
            if(array[i]<kArray[0]){
                kArray[0]=array[i];
                maxHeap(kArray,0);
            }
        }
        for(int i:kArray)
            System.out.print(i);
    }

    private void maxHeap(int[] kArray, int i) {
        int left=2*i;
        int right=left+1;
        int largest=0;
        if(right<kArray.length && kArray[left]>kArray[i])
            largest=left;
        else
            largest=i;
        if(right<kArray.length && kArray[right]>kArray[largest])
            largest=right;
        if(largest!=i){
            int temp=kArray[i];
            kArray[i]=kArray[largest];
            kArray[largest]=temp;
            maxHeap(kArray,largest);
        }
    }

    private void buildMaxHeap(int[] kArray){
        for(int i=kArray.length/2;i>0;i--)
            maxHeap(kArray,i);
    }

}

继承与组合的关系：

//InheritTest.java 使用继承方式实现目标  
class Animal{  
    private void beat(){  
        System.out.println("心脏跳动...");  
    }  
    public void breath(){  
        beat();  
        System.out.println("吸一口气，呼一口气，呼吸中...");  
    }  
}  
//继承Animal，直接复用父类的breath()方法  
class Bird extends Animal{  
    //创建子类独有的方法fly()  
    public void fly(){  
        System.out.println("我是鸟，我在天空中自由的飞翔...");  
    }  
}  
//继承Animal，直接复用父类的breath()方法  
class Wolf extends Animal{  
    //创建子类独有的方法run()  
    public void run(){  
        System.out.println("我是狼，我在草原上快速奔跑...");  
    }  
}  
public class InheritTest{  
    public static void main(String[] args){  
        //创建继承自Animal的Bird对象新实例b  
        Bird b=new Bird();  
        //新对象实例b可以breath()  
        b.breath();  
        //新对象实例b可以fly()  
        b.fly();  
        Wolf w=new Wolf();  
        w.breath();  
        w.run();  
/* 
---------- 运行Java程序 ---------- 
心脏跳动... 
吸一口气，呼一口气，呼吸中... 
我是鸟，我在天空中自由的飞翔... 
心脏跳动... 
吸一口气，呼一口气，呼吸中... 
我是狼，我在草原上快速奔跑... 

输出完毕 (耗时 0 秒) - 正常终止 
*/  
    }  
}  

//CompositeTest.java  使用组合方式实现目标  
class Animal{  
    private void beat(){  
        System.out.println("心脏跳动...");  
    }  
    public void breath(){  
        beat();  
        System.out.println("吸一口气，呼一口气，呼吸中...");  
    }  
}  
class Bird{  
    //定义一个Animal成员变量，以供组合之用  
    private Animal a;  
    //使用构造函数初始化成员变量  
    public Bird(Animal a){  
        this.a=a;  
    }  
    //通过调用成员变量的固有方法（a.breath()）使新类具有相同的功能（breath()）  
    public void breath(){  
        a.breath();  
    }  
    //为新类增加新的方法  
    public void fly(){  
        System.out.println("我是鸟，我在天空中自由的飞翔...");  
    }  
}  
class Wolf{  
    private Animal a;  
    public Wolf(Animal a){  
        this.a=a;  
    }  
    public void breath(){  
        a.breath();  
    }  
    public void run(){  
        System.out.println("我是狼，我在草原上快速奔跑...");       
    }  
}  
public class CompositeTest{  
    public static void main(String[] args){  
        //显式创建被组合的对象实例a1  
        Animal a1=new Animal();  
        //以a1为基础组合出新对象实例b  
        Bird b=new Bird(a1);  
        //新对象实例b可以breath()  
        b.breath();  
        //新对象实例b可以fly()  
        b.fly();  
        Animal a2=new Animal();  
        Wolf w=new Wolf(a2);  
        w.breath();  
        w.run();  
/* 
---------- 运行Java程序 ---------- 
心脏跳动... 
吸一口气，呼一口气，呼吸中... 
我是鸟，我在天空中自由的飞翔... 
心脏跳动... 
吸一口气，呼一口气，呼吸中... 
我是狼，我在草原上快速奔跑... 

输出完毕 (耗时 0 秒) - 正常终止 
*/  
    }  
}

继承和组合的优缺点
这里写图片描述

总结：

根据我们前面讲的内容我们可以发现继承的缺点远远多于优点，尽管继承在学习OOP的过程中得到了大量的强调，但并不意味着应该尽可能地到处使用它。相反，使用它时要特别慎重。只有在清楚知道继承在所有方法中最有效的前提下，才可考虑它。继承最大的优点就是扩展简单，但大多数缺点都很致命，但是因为这个扩展简单的优点太明显了。

ArrayList扩容的原理
ArrayList的扩容会产生一个新的数组，将原来数组的值复制到新的数组中。会消耗一定的资源。所以我们初始化ArrayList时，最好可以估算一个初始的大小。ArrayList默认扩充为原来的1.5倍。