校招面试之算法与编程

2024年2月17日 191次阅读

以下内容转载自某老师整理笔记。有需要的可以看一下

1.0 写一个Singleton出来
Singleton翻译为“单例”，Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

public class Singleton { 
private Singleton(){} 
　　    //在自己内部定义自己一个实例，是不是很奇怪？ 
　　    //注意这是private 只供内部调用 
　　    private static Singleton instance = new Singleton(); 
　　    //这里提供了一个供外部访问本class的静态方法，可以直接访问　　 
　　    public static Singleton getInstance() { 
　　　　    return instance; 　　 
　　    } 
   }

第二种形式: 

public class Singleton { 
　　private static Singleton instance = null; 
　　public static synchronized Singleton getInstance() { 
　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　 
　　//使用时生成实例，提高了效率！ 
　　if (instance==null) 
　　　　instance＝new Singleton(); 
       return instance; 　　
    } 
}

其他形式:
定义一个类，它的构造函数为private的，所有方法为static的。
一般认为第一种形式要更加安全些

【总结：】一般面试中，单例模式最常见的也就是上述第一种跟第二种。值得一提的是，第一种写法也叫作“饿汉模式”、第二种写法也叫作“饱汉模式”。如何理解饱汉、饿汉？其实是从它创建的时机来说的，第一种写法，instance = new Singleton(); 直接就创建了，可以理解为非常“饿”，需要立刻创建。第二种写法是，等你需要用到的时候，判断是否为空，为空的时候才去创建。这可以理解为“饱汉”

2.0 递归算法题1
一个整数，大于0，不用循环和本地变量，按照n，2n，4n，8n的顺序递增，当值大于5000时，把值按照指定顺序输出来。

例：n=1237
则输出为：
1237，
2474，
4948，
4948，
2474，
1237，

public static void multiply(int n)
    {
        if(n>5000) return;
        System.out.println(n);
        multiply(n*2);
        System.out.println(n);      
    }

3.0 递归算法题2
第1个人10，第2个比第1个人大2岁，依次地退，第8个人多大？


public class A1 {

    public static void main(String [] args)
    {
        System.out.println(computeAge(8));
    }

    public static int computeAge(int n)
    {
        if(n==1) return 10;
        return computeAge(n-1) + 2;
    }
}

4.0 用JAVA实现一个快速排序

public class QuickSort {
    /** * 快速排序 * @param strDate * @param left * @param right */
    public void quickSort(String[] strDate,int left,int right){
        String middle,tempDate;
        int i,j;
        i=left;
        j=right;
        middle=strDate[(i+j)/2];
        do{
            while(strDate[i].compareTo(middle)<0&& i<right)
                i++; //找出左边比中间值大的数
            while(strDate[j].compareTo(middle)>0&& j>left)
                j--; //找出右边比中间值小的数
            if(i<=j){ //将左边大的数和右边小的数进行替换 
                tempDate=strDate[i];
                strDate[i]=strDate[j];
                strDate[j]=tempDate;
                i++;
                j--;
            }
        }while(i<=j); //当两者交错时停止
        if(i<right){
            quickSort(strDate,i,right);//从
        }
        if(j>left){
            quickSort(strDate,left,j);
        }
    }
    /** * @param args */
    public static void main(String[] args){
        String[] strVoid=new String[]{"11","66","22","0","55","22","0","32"};
        QuickSort sort=new QuickSort();
        sort.quickSort(strVoid,0,strVoid.length-1);
        for(int i=0;i<strVoid.length;i++){
            System.out.println(strVoid[i]+" ");
        }
    }
}

5.0 有数组a[n]，用java代码将数组元素顺序颠倒

import java.util.Arrays;
import java.util.Collections;

public class ReverseTest {
    public static void main(String [] args)
    {
        //产生若干0到1000的随机数，作为数组的初始值
        int data[] = new int[]{
            (int)(Math.random() * 1000),
            (int)(Math.random() * 1000),    
            (int)(Math.random() * 1000),
            (int)(Math.random() * 1000),    
            (int)(Math.random() * 1000),    
            (int)(Math.random() * 1000),
            (int)(Math.random() * 100),         
        };
        System.out.println(Math.random());
        System.out.print("交换前的数据：");
        System.out.println(
                Arrays.toString(data));
        reverse(data);
        System.out.print("交换后的数据：");        
        System.out.println(Arrays.toString(data));
    }

    //方法执行完后，参数data中的数据顺序即被颠倒
    //实现思路是第1个和第n个交换，第2个和第n-1个交换，依次类推...
    public static void reverse(int[] data)
    {

        int len = data.length;
        for(int i=0;i<len/2;i++)
        {
            int temp = data[i];
            data[i] = data[len-1-i];
            data[len-1-i] = temp;
        }
    }
}

7.0 金额转换，阿拉伯数字的金额转换成中国传统的形式如：（￥1011）－>（一千零一拾一元整）输出。

public class RenMingBi {

    /** * @param args add by zxx ,Nov 29, 2008 */
    private static final char[] data = new char[]{
            '零','壹','贰','叁','肆','伍','陆','柒','捌','玖'
        }; 
    private static final char[] units = new char[]{
        '元','拾','佰','仟','万','拾','佰','仟','亿'
    };
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(
                convert(135689123));
    }

    public static String convert(int money)
    {
        StringBuffer sbf = new StringBuffer();
        int unit = 0;
        while(money!=0)
        {
            sbf.insert(0,units[unit++]);
            int number = money%10;
            sbf.insert(0, data[number]);
            money /= 10;
        }

        return sbf.toString();
    }
}
点赞