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

:D

    /**
     * 打印九九乘法口诀表
     */
    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);
        }
     }