一些常见的(关于算法)java面试题!供大家参考

[NickCheng]

    /**
     * 打印九九乘法口诀表
     */
    public static void nineNineMulitTable(){
        for (int i = 1,j = 1; j <= 9; i++) { 
              System.out.print(i+"*"+j+"="+i*j+" "); 
              if(i==j){ 
                  i=0; 
                  j++; 
                  System.out.println(); 
              } 
          } 
    }
    /** 
     * * 将某个日期以固定格式转化成字符串 * 
     * @param date * @return str 
     * */ 
    public String date2FormatStr(Date date) 
    { 
    	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
    	String str = sdf.format(date); 
    	return str; 
    }
    /**
     * 判断任意一个整数是否素数
     * @param num
     * @return boolean
     */
     public static boolean isPrimeNumber(int num)
     {
       for (int i = 2; i <= Math.sqrt(num); i++) {
           if(num%i==0)
           {
        	   System.out.println("不是素数");
               return false;
           }
       }
	   System.out.println("是素数");
       return true;
     } 

     /** 
      * *获得任意一个整数的阶乘 *
      * @param n *@returnn! 
      * */ 
     public static int factorial(int num) 
     { 
    	 //递归  
    	 if(num == 1) 
    	 {
    		 return 1; 
    	 } 
    	 return num*factorial(num-1); 
    }
     /** *二分查找特定整数在整型数组中的位置(递归) 
      * *@param dataset 
      * *@param data 
      * *@param beginIndex 
      * *@param endIndex 
      * *@return index 
      * */ 
     public static int binarySearch(int[] dataset,int data,int beginIndex,int endIndex)
     { 
    	 int midIndex = (beginIndex+endIndex)/2; //如果查找的数要比开始索引的数据要小或者是比结束索引的书要大，或者开始查找的索引值大于结束的索引值返回-1没有查到  
    	 if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex)
    	 { 
    		 return -1; 
    		 } 
    	 if(data <dataset[midIndex])
    	 { 
    		 return binarySearch(dataset,data,beginIndex,midIndex-1); 
    	 }
    	 else if(data>dataset[midIndex]) 
    	 { 
    		 return binarySearch(dataset,data,midIndex+1,endIndex); 
    		 }else 
    	{ return midIndex; 
    	} 
    	}
     /** *二分查找特定整数在整型数组中的位置(非递归) *
      * @param dataset *
      * @param data *
      * @return index 
      * */ 
     public static int binarySearch(int[] dataset ,int data) 
     { 
    	 int beginIndex = 0; 
    	 int endIndex = dataset.length - 1; 
    	 int midIndex = -1; 
    	 if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex)
    	 { 
    		 return -1; 
    		 } 
    	 while(beginIndex <= endIndex) 
    	 { 
    		 midIndex = (beginIndex+endIndex)/2; 
    		 if(data <dataset[midIndex]) 
    		 { 
    			 endIndex = midIndex-1; 
    		 } 
    		 else if(data>dataset[midIndex]) 
    		 { 
    			 beginIndex = midIndex+1; 
    		 }else 
    		 { 
    				 return midIndex; 
    		 } 
    	 } 
    	 return -1; 
     }
     /** 
      * 冒泡排序
      * @param dataset *
      * @param data *
      * @return index 
      * */ 
     public static void maopaoPrint(int[] before){
    	 String result = "" ;
    	 for (int i = 0; i < before.length; i++) {
			 result +=before[i]+" ";
		}   	 
		 System.out.println(result);
     }
     public static void maopaoSort(int[] arrys){
    	 int temp = 0;
    	 for (int j = 0; j < arrys.length; j++) {
			for (int k = 0; k < arrys.length-j-1; k++) {
				if(arrys[k] > arrys[k+1]){
					temp = arrys[k];
					arrys[k]= arrys[k+1];
					arrys[k+1]=temp;
				}
			}			
		}
		maopaoPrint(arrys);
     }
     /**
      * 快速排序1
      * @param pData
      * @param pDataNum
      * @param left
      * @param right
      * */
     public static void QuickSort(String[] pData,int[] pDataNum,int left,int right)
     { 
	     int i,j; 
	     int iTemp; 
	     String middle,strTemp;
	     i = left; 
	     j = right; 
	     middle = pData[(left+right)/2]; 
	     do{ 
	    	 while((pData[i].compareTo(middle)<0) && (i<right)) 
	    		 i++; 
	    	 while((pData[j].compareTo(middle))>0 && (j>left)) 
	    		 j--; 
	     if(i<=j) 
	     { 
		     strTemp = pData[i]; 
		     pData[i] = pData[j]; 
		     pData[j] = strTemp; 
		
		     iTemp = pDataNum[i]; 
		     pDataNum[i] = pDataNum[j]; 
		     pDataNum[j] = iTemp; 
		
		     i++; 
		     j--; 
	     } 
	     }while(i<=j);//如果两边扫描的下标交错，就停止（完成一次） 
	
	     if(left<j) 
	    	 QuickSort(pData,pDataNum,left,j); 
	
	     if(right>i) 
	    	 QuickSort(pData,pDataNum,i,right); 
     } 
     /**
      * 快排2
      * 
      * */
     public static void quickSort(int[] array) {
         quickSort(array, 0, array.length - 1);
     }

     private static void quickSort(int[] array, int low, int high) {
         if (low < high) {
             int p = partition(array, low, high);
             quickSort(array, low, p - 1);
             quickSort(array, p + 1, high);
         }

     }

     private static int partition(int[] array, int low, int high) {
         int s = array[high];
         int i = low - 1;
         for (int j = low; j < high; j++) {
             if (array[j] < s) {
                 i++;
                 swap(array, i, j);
             }
         }
         swap(array, ++i, high);
         return i;
     }
     //掉位方法
     private static void swap(int[] array, int i, int j) {
         int temp;
         temp = array[i];
         array[i] = array[j];
         array[j] = temp;
     }

     /**
      *插入排序(WHILE循环实现)
      *插入排序的基本思想是，经过i-1遍处理后,L[1..i-1]己排好序。
      *第i遍处理仅将L[i]插入L[1..i-1]的适当位置，使得L[1..i]又是排好序的序列。
      *要达到这个目的，我们可以用顺序比较的方法。首先比较L[i]和L[i-1]，如果L[i-1]≤ L[i]騆[1..i]
      *已排好序，第i遍处理就结束了；否则交换L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，
      *直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止。
　　	  *简言之,插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，
	  *直到全部插入完毕。插入排序方法分直接插入排序和折半插入排序两种，这里只介绍直接插入排序，
	  *折半插入排序留到“查找”内容中进行。
　　   *图1演示了对4个元素进行直接插入排序的过程，共需要(a),(b),(c)三次插入。
      *@paramsrc待排序数组
      */
     public static  void doInsertSort1(int[] src)
     {
        int len=src.length;
        for(int i=1;i<len;i++)
        {  
            int temp=src[i];
            int j=i;
           
            while(src[j-1]>temp)
            {
               src[j]=src[j-1];
               j--;
               if(j<=0)
                   break;
            }
            src[j]=temp;
            printResult(i+1,src);
        }
     }
     /**
      *插入排序(FOR循环实现)
      *@paramsrc待排序数组
      */
     public static void doInsertSort2(int[] src)
     {
        int len=src.length;
        for(int i=1;i<len;i++)
        {
            int j;
            int temp=src[i];
            for(j=i;j>0;j--)
            {
               if(src[j-1]>temp)
               {
                   src[j]=src[j-1];
                  
               }else//如果当前的数，不小前面的数，那就说明不小于前面所有的数，
                    //因为前面已经是排好了序的，所以直接通出当前一轮的比较
                   break;
            }
            src[j]=temp;
            printResult(i,src);
        }
     }

[aloie]

收藏

[diggywang]

看到第三个我就不看下去了，素数有这样判断的么？效率低得要命！

 public static boolean isPrimeNumber(int num)
     {
       for (int i = 2; i <= Math.sqrt(num); i++) {
           if(num%i==0)
           {
               System.out.println("不是素数");
               return false;
           }
       }
       System.out.println("是素数");
       return true;
     } 

我先来指正一下哪些地方不对，Math.sqrt(num)不能在每个循环都算一遍，这个很影响效率。应该拿到循环外面一次性计算出结果，如：

 public static boolean isPrimeNumber(int num)
     {
       long sqrtNum = Math.sqrt(num);
       for (int i = 2; i <=sqrtNum; i++) {
         .....
       }
     } 

还有，应该先判断是否是偶数，如果不是偶数，就要在判断时候直接跳过所有偶数因子，如：

 public static boolean isPrimeNumber(int num)
     {
       if(num%2!=0){
          long sqrtNum = Math.sqrt(num);
          for (int i = 3; i <=sqrtNum; i=i+2) {
             .....
          }
       }       
     } 

其实，还有很多要优化的，比如，3判断过了，6,9,15之类的就不用判断了......
算法不光是要考虑功能实现，但更要注重效率。

[yufuhang3]

楼上 果然....佩服

[NickCheng]

[Quote=引用 3 楼 diggywang 的回复:]
看到第三个我就不看下去了，素数有这样判断的么？效率低得要命！
Java codepublicstaticbooleanisPrimeNumber(intnum)
{for(inti=2; i<=Math.sqrt(num); i++) {if(num%i==0)
{
System.out.println("不是素数");returnfalse;
}
}
System.out.println("是素数");returntrue;
}


我先来指正一下哪些地方不对，Math.sqrt(num)不能在每个循环都算一遍，这个很影响…
[/Quote]
谢谢指教！~

[bigbug9002]

第一个九九乘法表的算法,效率没有比两个for循环高.这样的代码除了让人一头雾水之外没有任何好除.
求阶乘的那个,能不用递归就不要用递归,递归的效率是非常低的.

支持三楼.

[bigbug9002]

阶乘那个,如果给num传0,结果要溢出了.0的阶乘应该是1.
传一个负数就不用说了.

[zhaoxiaoyao194]

楼上都好强啊！小弟是那个佩服啊！可能是小弟我太懒了，平时敲得的代码不多呵呵看来要多像大哥们看齐啊!!!

[bigbug9002]

冒泡排序那个:
1.n个元素最应该是n-1趟冒泡,但给出程序却用了n次冒泡.
2.如果某趟冒泡排序过程中,没有发生过元素交换,说明排序已经完成.不需要再冒泡下去了.
最极端的例子就是,如果数组里的元素已经是有序的了,只要经过一趟冒泡就可以了.

[其实我是真性情]

mark

[j1223jesus]

mark

[tonytone2008]

呵呵，终于发现这些东西我也会了，好像还要更有效率些样！

[Yedy2000]

mark

[happygao521]

收藏了！！！

[zsy_0617]

mark

[码之魂]

呵呵,顶...都不简单啊,素数也变的麻烦了...

[xqn516]

说两句：一。1不是素数，但是2是素数。所以3楼针对偶数的判断有欠考虑。
二。这个判断，只要有数字满足整除就返回了，所以说判断到3能整除，就不会去判断6,9,15等了。3楼多虑了。

[cexowfntkg]

mark