算法分析（含答案）笔试题

626. 判断身份证：要么是 15 位，要么是 18 位，最后一位可以为字母，并写
     出程序提出其中年月日。要求：
     写出合格的身份证的正则表达式，
     ^(\d{15}|\d{17}[\dx])$
     写程序提取身份证中的年月日
     public class IdCard
     {
     private String idCard;//私有变量
     public IdCard(){}//构造方法
     //构造方法
     public IdCard(String idCard){
     this.idCard=idCard;
     }

public void setIdCard(String idCard)
{
this.idCard=idCard;
}

public String getIdCard()
{
return idCard;
}

//从身份证号码中截取生日
public String getBirthday()
{
return this.getIdCard().substring(6, 14);
}

public static void main(String args[])
{
ShenFenZheng sfz = new
ShenFenZheng("420154199908157841");
//调用 getBirthday()方法获取生日
System.out.println("生日：" + sfz.getBirthday());
} }
627. 对于一个字符串，请设计一个高效算法，找到第一次重复出现的字符保
证字符串中有重复的字符，字符串的长度小于等于 500.
package com.bjsxt;
import java.util.ArrayList;
import java.util.List;
public class FirstRepeat {
public static void main(String[] args) {
System.out.println(findFirstRepeat("pmedmitjtckhxwhvpwemznh
mhzhpueainchqrftkmbjlradhmjekcqzansyzkvqhwnrdgzdbzewdmxkzrscik
daugbvygntrifnolehdtrqjlasofuvzeijbmzehkxknmjekcxswqldknysfsxr
qaqzp",152));
}
//返回:y
public static char findFirstRepeat(String A, int n) {
String[] str=A.split("");
for(int x=0;x<n;x++){
int index=0;
int num=0;
//对于每一个值，都需要从前开始遍历
while(index<=x){
if(str[index].equals(str[x])){
num++;
}
index++;
}
//该值出现了两次，说明重复了
if(num>1){
char flag='x';
flag=str[x].toCharArray()[0];
return flag;
}
}
//返回该值说明已经没有重复的
return 'p';
}
}
628. 写一个完整函数，实现拷贝数组
public class test {
public static void main(String[] args) {
int [] arr1 = {10,20,30,40,50};
int [] arr2 = CopyArray(arr1);
System.out.println(Arrays.toString(arr2));
}
private static int[] CopyArray(int[] arr) {
int [] arr2 = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
arr2[i] = arr[i];
}
return null; } }
629. 写一排序算法，输入 10 个数字，以逗号分开，可根据参数选择升序或者
降序排序，须注明是何种排序算法。
package cn.bjsxt.demo;
import java.util.Scanner;
public class SortDemo {
/**

• 给定的字符串使用，号分隔
• @param strNumber
• @return/
  public static String [] split(String strNumber){
  String [] strSplit=strNumber.split(",");
  return strSplit;
  }
  /*
• 将String类型的数组转换成int类型的数组
• @param strSplit
• @return/
  public static int [] getInt(String [] strSplit){
  int arr[]=new int[strSplit.length];
  for (int i = 0; i < strSplit.length; i++) {
  arr[i]=Integer.parseInt(strSplit[i]);
  }
  return arr;
  }
  /*
• 冒泡排序
• @param arr/
  public static void sort(int [] arr){
  for (int i = 0; i < arr.length-1; i++) {
  for (int j = 0; j < arr.length-1-i; j++) {
  if (arr[j]>arr[j+1]) {
  change(arr,j,j+1);
  } } } }
  /*
• 两数交换的方法
• @param arr 数组
• @param x 数组中元素的下标
• @param y 数组中元素的下标/
  public static void change(int [] arr,int x,int y){
  int temp=arr[x];
  arr[x]=arr[y];
  arr[y]=temp;
  }
  /*
• 测试类
• @param args
  */
  public static void main(String[] args) {
  Scanner input=new Scanner(System.in);
  System.out.println("请输入一个数字串，每个数字以逗号分隔
  ");
  String str=input.next();
  //调用方法
  String [] s=split(str);//使用逗号分隔
  int [] arr=getInt(s);//调有获得整型数组的方法
  sort(arr);//调用排序的方法
  for (int i : arr) {
  System.out.print(i+"\t");
  } } }

630. 判断字符串是否是这样的组成的，第一个字母，后面可以是字母、数字、
     下划线、总长度为 5-20。
     package cn.bjsxt.demo;
     import java.util.Scanner;
     public class StringDemo {
     public static void main(String[] args) {
     Scanner input=new Scanner(System.in);
     System.out.println("请输入一个字符串，第一个字符必须是字母：
     ");
     String str=input.next();
     if (str.length()<5||str.length()>20) {
     System.out.println("对不起，字符串的长度必须在5-20之 间!");
     }else{
     char []ch=str.toCharArray();
     if (Character.isLetter(ch[0])) {//判断第一个字符是否是
     字母
     for (int i = 1; i < ch.length; i++) {
     if
     (!Character.isLetterOrDigit(ch[i])&&ch[i]!='_') {
     System.out.println("字符串不符合要求");
     break; } } } } } }
631. 已排好序的数组 A，一般来说可用二分查找可以很快找到，现有一特殊
     数组 A，它是循环递增的，如 a[]={17, 19 ,20, 25, 1, 4, 7, 9}，在这样的
     数组中找一元素，看看是否存在。请写出你的算法，必要时可写伪代码，并
     分析其空间，时间复杂度。
     思路说明：循环递增数组有这么一个性质：以数组中间元素将循环递增数组划分为两部
     分，则一部分为一个严格递增数组，而另一部分为一个更小的循环递增数组。当中间元
     素大于首元素时，前半部分为严格递增数组，后半部分为循环递增数组；当中间元素小
     于首元素时，前半部分为循环递增数组；后半部分为严格递增数组。
     记要检索的元素为 e，数组的首元素为 a[low]，中间元素为 a[mid]，末尾元素为 a[high]。
     则当 e 等于 a[mid] 时，直接返回 mid 的值即可；当 e 不等于 a[mid] 时:

1. a[mid] > a[low]，即数组前半部分为严格递增数组，后半部分为循环递增数组时，若
   key 小于 a[mid]并且不小于 a[low]时，则 key 落在数组前半部分；否则，key 落在数组
   后半部分。
2. a[mid] < a[high]，即数组前半部分为循环递增数组，后半部分为严格递增数组时，
   若 key 大于 a[mid]并且不大于 a[high]时，则 key 落在数组后半部分；否则，key 落在
   数组前半部分。
   这种方式的时间复杂度为：O(log(n))，空间复杂度为 O(1)。
   public class TestBinarySearch {
   public static void main(String[] args) {
   // 定义数组
   int[] a = { 17, 19, 20, 21, 25, 1, 4, 7 };
   // 调用改进后的二分查找法求索引
   int pos = search(a, 7);
   System.out.println("要查找的元素的索引为：" + pos);
   }
   /** 改进后的二分查找法：e 为要查找的元素 */
   public static int search(int[] a, int e) {
   int low = 0;
   int high = a.length - 1;
   int mid = 0;
   int pos = -1; // 返回-1，表示查找失败
   // 如果 low < high，说明循环查找结束，直接返回-1;否则循环查
   找
   while (low <= high) {
   // mid 为中间值索引
   mid = (low + high) / 2;
   // 如果中间值刚好是 e，则查找成功，终止查找，e 的索引为 mid
   if (a[mid] == e) {
   pos = mid;
   break;
   }
   // 如果 a[low] <= a[mid]，说明原数组的前半部分是严格递增
   的，后半部分是一个更小的循环递增数组
   if (a[low] <= a[mid]) {
   // 如果要查找的元素 e 小于 a[mid]并且不小于 a[low]时，
   则说明 e 落在数组前半部分
   if (a[low] <= e && e < a[mid]) {
   high = mid - 1;
   } else {// 否则的话，需要在数组的后半部分继续查找
   low = mid + 1;
   }
   } else {// 否则，后半部分是严格递增的，前半部分是一个更
   小的循环递增数组
   // 如果要查找的元素 e 大于 a[mid]并且不大于 a[high]时，
   则说明 e 落在数组后半部分
   if (a[mid] < e && e <= a[high]) {
   low = mid + 1;
   } else {// 否则的话，需要在数组的前半部分继续查找
   high = mid - 1;
   } } }
   return pos; } }

632. 请编写一个完整的程序，实现如下功能：从键盘输入数字 n，程序自动
     计算 n!并输出。(注 1：n！=123...n, 注 2：请使用递归实现)
     思路说明：因为 n! = (n-1)! * n，所以要求 n!首先要求出(n-1)!，而(n-1)! = (n-1-1)! *
     (n-1)，以此类推，直到 n = 1 为止。
     import java.util.Scanner;
     public class TestFactorial {
     public static void main(String[] args) {
     System.out.print("请输入一个整数：");
     Scanner sc = new Scanner(System.in);
     int n = sc.nextInt();
     System.out.println(n + "的阶乘是：" + factorial(n));
     }
     /**求阶乘的方法/
     public static int factorial(int n) {
     if(n == 1){
     return 1;
     }
     return factorial(n - 1) * n; } }
633. 请用递归的方法计算斐波那契数列的同项 F(n)，已知
     F0=0,F1=1,F(n)=F(n-1)+F(n-2)(n>=2,n∈N*).
     思路说明：斐波那契数列的排列是：0，1，1，2，3，5，8，13，21，34，55，89，
     144……，特别指出的是 0 不是第一项而是第 0 项；因为 F(n)=F(n-1)+F(n-2)，所以要
     求 F(n)首先要求出 F(n-1)和 F(n-2)，而 F(n-1)=F(n-1-1)+F(n-1-2)，以此类推，直
     到,F(2)=F(1)+F(0)为止，已知 F(1) = 1，F(0) = 0。
     import java.util.Scanner;
     public class TestFibo {
     public static void main(String[] args) {
     System.out.print("请输要求斐波那契数列的第几项：");
     Scanner sc = new Scanner(System.in);
     int n = sc.nextInt();
     System.out.println("斐波那契数列的第"+ n + "是：" +
     fibo(n));
     }
     public static int fibo(int n) {
     if(n == 0){
     return 0;
     } else if(n == 1){
     return 1;
     }
     return fibo(n -1) + fibo(n - 2);
     } }
634. 现在有整数数组{11,66,22,0,55,32}，请任意选择一种排序算法，用
     Java 程序实现
     冒泡思路说明：
     (1) 最开始将数组看做一个无序数列(个数是数组的长度)与一个有序数列(0 个)的组合；
     (2) 每一趟比较完后, 找到了无序数列的最大值, 将其放到有序数列中(有序数列个数+1)；
     (3) N 个数, 比较 N-1 趟；
     (4) 每一趟挨个进行比较：从数组的第一个元素开始, 到无序数列的最后一个为止；
     (5) 如果前边一个大于后边一个, 那么交换位置；
     (6) 每趟比较的次数与趟数有关；
     (7) 根据每趟比较是否发生了交换判断数据是否已经有序，从而进行优化。
     public class TestSort {
     public static void main(String[] args) {
     int[] arr = {11, 66, 22, 0, 55, 32};
     // 调用排序方法
     sort(arr);
     // 输出排除后的数组
     for (int num : arr) {
     System.out.print(num + "\t");
     } }
     public static void sort(int[] arr) {
     // 定义标记
     boolean flag = false;
     int temp;
     // 排序
     // 外层循环控制的是比较的趟数
     for (int i = 0; i < arr.length - 1; i++) {
     // 每一趟比较之前初始化, 否则会保留上一堂比较的结果
     flag = false;
     // 内层循环控制的是每趟比较的次数
     for (int j = 0; j < arr.length - 1 - i; j++) {
     // 挨个进行比较: 从数组的第一个元素开始, 到无序数列的
     最后一个
     if (arr[j] > arr[j + 1]) {
     // 交换
     temp = arr[j];
     arr[j] = arr[j + 1];
     arr[j + 1] = temp;
     //如果发生交换，改变 flag 的值
     flag = true; } }
     if (!flag) {
     break; } } } }
635. 请根据注释，编码实现下面类的方法
     // 这个类用于存取一组权限，每个权限用非负整数表示的.这组枳限存储在
     // righiString 属性中。如果权限 N 权限存在，rightString 第 N 个字符为“1”,
     否则， 为空格。
     class RightStore {
     public String righString = "";
     // 如果传入的权限 right 存在，该方法返回 true.否期，为 false.,
     // right 为传入的权限的整数值.
     public boolean getRight(int right) {
     return true; }
     // 该方法存储或消除传入的权限.如果 value 为 true,存储传入的权限,
     // 否则淸除该权限.
     // right 为传入的权限的整数值.
     public void setRight(int right, boolean value) {
     } }
     思路说明：我们首先要读懂这道题的意思：righString 这个字符串是用来存储一系列权
     限的，并且权限的取值只有两种：有和没有；在 righString 中使用字符‘1’表示有权
     限，字符空格‘ ’表示没有权限。举个例子：如果 righString 的长度为 3，第一位表示
     对订单系统是否有权限，第二位表示对人员管理系统是否有权限，第三位表示对库存系
     统是否有权限。而方法中的 int right 参数则表示的是字符串的第几位。
     上边这些搞明白之后，方法的编写就简单多了。
     public class RightStore {
     public String righString = "";
     public boolean getRight(int right) {
     //先求得第 right 个字符
     char ch = righString.charAt(right - 1);
     //如果 ch 为'1'，返回 true，否则返回 false
     return ch == '1'; }
     public void setRight(int right, boolean value) {
     //如果 value 为 true,存储传入的权限，否则消除权限(改为空格)
     righString.replace(righString.charAt(right - 1), value ?
     '1' : ' ');
     } }
636. 二分法查询(递归实现)
     思路说明：假设在一个已经排好序的有序序列(N 个元素，升序排