几道常用最新最基本的java笔试题(1)

1、求一个数的阶乘：

/**
 * 递归算法
 * @param number 某个数
 * @return 某个数的阶乘
 */
public static long recursion(int number){
  //非法时
  if(number < 0) return -1;
  //1,0的阶乘等于1
  if(number < 2) return 1;
    return number*recursion(number-1);
}
/**
 * 非递归算法
 * @param number 某个数
 * @return 某个数的阶乘
 */
public static long noRecursion(int number){
  //number的阶乘值，默认为1
  long result = 1 ;
  //非法时
  if(number < 0) return -1;
  //1,0的阶乘等于1
  if(number < 2) return 1;
  for(int i = 1; i<=number; i++){
    result *= i;
  }
  return result;
}

2、两数交换：

   /**
     * 两个数交换：方法一(不用第三方变量)   【注：此方法在不保证在其他语言中有效】
     * @param x
     * @param y
     */
    public static void toSwap1(int x, int y) {
        y = x - 0 * (x = y);
        System.out.println("x =" + x);
        System.out.println("y =" + y);
    }

    /**
     * 两个数交换：方法二(不用第三方变量)
     * @param x
     * @param y
     */
    public static void toSwap2(int x, int y) {
        x ^= y;
        y ^= x;
        x ^= y;
        System.out.println("x =" + x);
        System.out.println("y =" + y);
    }

    /**
     * 两个数交换：方法三(使用第三方变量)
     * @param x
     * @param y
     */
    public static void toSwap3(int x, int y) {
        int temp;
        temp = x;
        x = y;
        y = temp;
        System.out.println("x =" + x);
        System.out.println("y =" + y);
    }

3、排序：

   /**
     * 冒泡排序
     * @param numbers int型数组
     */
    public static void bubbleSort(int[] numbers) {
        //交换数时用的临时变量
        int temp;
        //数组长度
        int size = numbers.length;
        for (int i = 0; i < size - 1; i++) {
            for (int j = i + 1; j < size; j++) {
                // 交换两数的位置
                if (numbers[i] > numbers[j]) {
                    temp = numbers[i];
                    numbers[i] = numbers[j];
                    numbers[j] = temp;
                }
            }
        }

        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }

    /**
     * 快速排序
     * @param numbers int型数组
     * @param start 
     * @param end 
     */
    public static void quickSort(int[] numbers, int start, int end) {
        if (start < end) {
            // 选定的基准值(第一个数值作为基准值)
            int base = numbers[start];
            // 交换数时用的临时变量
            int temp;
            int i = start, j = end;
            do {
                while ((numbers[i] < base) && (i < end)) {
                    i++;
                }
                while ((numbers[j] > base) && (j > start)) {
                    j--;
                }
                if (i <= j) {
                    temp = numbers[i];
                    numbers[i] = numbers[j];
                    numbers[j] = temp;
                    i++;
                    j--;
                }
            } while (i <= j);
            if (start < j) {
                quickSort(numbers, start, j);
            }
            if (end > i) {
                quickSort(numbers, i, end);
            }
        }

        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }

    /**
     * 选择排序
     * @param numbers int型数组
     */
    public static void selectSort(int[] numbers) {
        // 交换数时用的临时变量
        int temp;
        //数组长度
        int size = numbers.length;
        for (int i = 0; i < size; i++) {
            int k = i;
            for (int j = size - 1; j > i; j--) {
                if (numbers[j] < numbers[k]) {
                    k = j;
                }
            }
            temp = numbers[i];
            numbers[i] = numbers[k];
            numbers[k] = temp;
        }
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }

    /**
     * 插入排序
     * @param numbers int型数组
     */
    public static void insertSort(int[] numbers) {
        // 交换数时用的临时变量
        int temp;
        //数组长度
        int size = numbers.length;
        int j;
        for (int i = 1; i < size; i++) {
            temp = numbers[i];
            for (j = i; j > 0 && temp < numbers[j - 1]; j--) {
                numbers[j] = numbers[j - 1];
            }
            numbers[j] = temp;
        }
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }

    /**
     * 归并排序
     * @param numbers
     * @param left
     * @param right
     */
    public static void mergeSort(int[] numbers, int left, int right) {
        // 每组元素个数
        int t = 1;
        int size = right - left + 1;
        while (t < size) {
            int s = t;// 本次循环每组元素个数
            t = 2 * s;
            int i = left;
            while (i + (t - 1) < size) {
                merge(numbers, i, i + (s - 1), i + (t - 1));
                i += t;
            }
            if (i + (s - 1) < right) merge(numbers, i, i + (s - 1), right);
        }
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }

    /**
     * 归并算法实现
     * @param data
     * @param p
     * @param q
     * @param r
     */
    private static void merge(int[] data, int p, int q, int r) {
        int[] B = new int[data.length];
        int s = p;
        int t = q + 1;
        int k = p;
        while (s <= q && t <= r) {
            if (data[s] <= data[t]) {
                B[k] = data[s];
                s++;
            } else {
                B[k] = data[t];
                t++;
            }
            k++;
        }
        if (s == q + 1)  B[k++] = data[t++];
        else  B[k++] = data[s++];
        for (int i = p; i <= r; i++)  data[i] = B[i];
        
        for (int i = 0; i < data.length; i++) {
            System.out.println(data[i]);
        }
    }

4、数据翻转：

   /**
     * 非递归
     * @param str 需要转换的字符串
     * @return 翻转好的字符串
     */
    public static String turn(String str) {
        char[] ch = str.toCharArray();
        char temp;
        for (int i = 0; i < (ch.length+1)/2; i++) {
            temp = ch[i];
            ch[i] = ch[ch.length-i-1];
            ch[ch.length-i-1] = temp;
        }
        return new String(ch);
    }

    /**
     * @param str 需要反转的字符串
      * @return 反转好字符串
      */
    public static String reverse(String str){
        //如果小于2位，则返回本身
        if(str.length() < 2){
            return str;
        }
        StringBuffer sb = new StringBuffer();
        for(int i = str.length()-1; i >= 0; i--){
            sb.append(str.charAt(i));
        }
        return sb.toString();
    }    

    /**
     * 递归
     * @param str 需要转换的字符串
     * @return 翻转好的字符串
     */
    public static String method(String str){
        if(str.length() > 1)
            return method(str.substring(1)) + str.substring(0, 1);
        else
            return str;
    }