いくつかの典型的なアルゴリズム面接の質問に対する Java ソリューション

質問1:

公共 クラスtestClockwiseOutput {
 //行列を時計回りに印刷する  
    
 @テスト 
公共  voidテスト(){
 int [][] num =新しい 整数[ 100 ][ 100 ];
整数n = 4 ;
整数カウント = 1 ; 
        
 ( int i = 0 ; i < n ; i++ )の場合{
 ( int j = 0 ; j < n ; j++ )の場合{
                num[i][j] = カウント++;
            }
        } 
        
        出力(数値、 0 、n- 1 );
    } 
    
公共  void出力( int [][] num, int開始, int終了){
 (start>=end || end<= 0 )の場合、戻り値:
 ( int i=start;i<=end;i++) {
            System.out.println(num[開始][i]);
        }
 ( int i=start+ 1 ;i<=end;i++) {
            System.out.println(num[i][end]);
        }
 ( int i=end- 1 ;i>=start;i--) {
            System.out.println(num[end][i]);
        }
 for ( int i=end- 1 ;i>start;i--){
            System.out.println(num[i][start]);
        }
        出力(数値、開始+ 1 、終了- 1 );
    }
 }

質問2:

ソートされた配列と数値が与えられた場合、配列内の連続する要素の合計が指定された数値に等しいサブ配列を見つけます。

 // ソートされた配列と数値が与えられた場合、配列内の連続する要素の合計が指定された数値に等しいサブ配列を見つけます  
    
 @テスト 
公共  voidテスト(){
 int [] num = { 1 、 2 、 2 、 3 、 4 、 5 、 6 、 7 、 8 、 9 };
整数合計 = 7 ;
        数値、合計を求める。
    } 
    
公共  void findSum( int [] num, int sum){
 int左 = 0 ;
 int右 = 0 ; 
        
 ( int i = 0 ; i < num.length; i++) {
 int 現在の合計 = 0 ;
            左 = i;
            右 = i;
 (curSum<sum) {
                curSum += num[右++];
            }
 (現在の合計==合計)の場合{
 ( int j=left;j<right;j++) {
                    System.out.print(num[j]+ " " );
                }
                システム出力のprintln();
            }
        }
    }

質問3:

//すべての文字列は文字配列で構成されています  
    
 @テスト 
公共  voidテスト(){
 //char[] cs = {'a','b','c','d','e'};  
 char [] cs = { 'a' 、 'b' 、 'c' };
 int長さ = cs.length;
        再帰スワップ(cs, 0 ,長さ);
    } 
    
公共  void swap( char [] cs, intインデックス1, intインデックス2) {
 char temp = cs[インデックス1];
        cs[インデックス1]=cs[インデックス2];
        cs[インデックス2]=temp;
    } 
    
公共  void recursionSwap( char [] cs, int start, int length){
 (開始>=長さ- 1 )の場合{
            印刷(cs);
戻る;
        }
 ( int i=start;i<length;i++) {
            swap(cs,start,i);
            recursionSwap(cs,開始+ 1 ,長さ);
            swap(cs,start,i);
        }
    } 
    
公共  void print( char []cs) {
 ( int i = 0 ; i < cs.length; i++) {
            System.out.print(cs[i]);
        }
        システム出力のprintln();
    }

質問4:

//配列要素の最小数  
    
 @テスト 
公共  voidテスト(){
 int [] 数値 = { 1 、 5 、 9 、 13 、 442 、 44 、 6 、 21 、 211 };
        qsort(数値、 0 、数値の長さ-1 );
        System.out.println(Arrays.toString(num));
    } 
    
公共  void qsort( int [] num, int left, int right){
 （左<右）の場合{
 intパーティション = パーティション(数値、左、右);
            qsort(数値、左、パーティション-1 );
            qsort(数値、パーティション+ 1 、右);
        }
    } 
    
公共  intパーティション( int [] num, int左, int右){
 intパーティション = num[左];
 （左<右） {
 while ((num[right]==partition || isMBigerThanN(num,num[right],partition)) && left<right){
                右 - ;
            }
            swap(数値、左、右);
 while ((num[left]==partition || isMBigerThanN(num,partition,num[left])) && left<right){
                左++;
            }
            swap(数値、左、右);
        } 
        
左に戻る;
    } 
    
公共  void swap( int [] num, int m, int n){
数値[m]を整数で割ったもの。
        num[m] = num[n];
        num[n] = 一時;
    } 
    
公共 ブール型isMBiggerThanN( int [] num, int m, int n){
        文字列 num1 = String.valueOf(m);
        文字列 num2 = String.valueOf(n); 
        
 int temp1 = Integer.parseInt(num1+num2);
 int temp2 = Integer.parseInt(num2+num1); 
        
 (temp1>temp2)の場合{
戻る 真実;
        }
それ以外{
戻る 間違い;
        }
    }

質問5:

//サブ配列*** と 
 @テスト 
公共  voidテスト(){
 int [] num = { 1 ,- 2 , 3 , 10 ,- 4 , 7 , 2 ,- 5 };
 //int[] 数値 = {1,-2,3,10,-4,10,2,-5};  
        System.out.println(maxSum(num));
    } 
    
公共  int最大合計( int [] 数値) {
 int 現在の合計 = 0 ;
 int curMaxSum = -99999999 ;
 int開始 = 0 ;
 int終了 = 0 ; 
        
 ( int i = 0 ; i < num.length; i++) {
 (現在の合計<= 0 )の場合{
                カーソルの合計 = num[i];
                開始 = i;
            }
それ以外{
                カーソルの合計 += num[i];
            }
 (現在の合計値>現在の最大合計値)の場合{
                curMaxSum = curSum;
                終了 = i;
            }
        }
 ( int i = 開始; i<=終了; i++) {
            System.out.println(num[i]);
        }
 curMaxSumを返します。
    }

質問6:

公共 クラスtestMinStack {
 //カスタムスタック、min関数は現在の最小値を取得します  
    
 @テスト 
公共  voidテスト(){
        MinStack ms =新しいMinStack();
        ms.push( 5 );
        System.out.println(ms.min());
        ms.push( 6 );
        ms.push( 2 );
        ms.push( 1 );
        System.out.println(ms.min());
        ms.pop();
        System.out.println(ms.min());
        ms.pop();
        System.out.println(ms.min()); 
        
    }
 } 
 
クラスMinStack{
プライベートStack<Integer> minStack =新しいStack<Integer>();
プライベートStack<Integer> スタック =新しいStack<Integer>(); 
    
公共 整数ポップ(){
        minStack.pop();
 stack.pop()を返します。
    } 
    
公共  voidプッシュ( int num){
 minStack.size()<= 0の場合{
            minStack.push(数値);
戻る;
        }
        整数 min = minStack.lastElement();
 （数値<最小値）の場合{
            minStack.push(数値);
        }
それ以外{
            minStack.push(min);
        }
        スタックをプッシュします。
    } 
    
公共 整数最小値(){
 minStack.size()<= 0の場合{
戻り値- 1 ;
        }
 minStack.lastElement()を返します。
    }
 }

質問7:

//配列内で半分以上出現する数字を見つける  
    
 @テスト 
公共  voidテスト(){
 int [ ] num = { 1、2、2、2、2、2、2、4、2、4、6、4、2、6、8、2、7、7 } ;​​​​​​​​​​​​​​​​​​​​​​​​​​​​​
        System.out.println(moreThanHaft(num));
    } 
    
公共  int moreThanHaft( int [] num){
 int結果 = - 1 ;
 int回 = 0 ;
 ( int i = 0 ; i < num.length; i++) {
 （回数== 0 ）の場合{
                結果 = num[i];
                回++;
            }
それ以外{
 if (num[i]==結果){
                    回++;
                }
それ以外{
                    回--;
                }
            }
        } 
        
結果を返します。
    }

質問8:

 //配列が別のスタックのポップ順序であるかどうかを判断します  
    
 @テスト 
公共  voidテスト(){
 int [] 数値 = { 1 , 2 , 3 , 4 , 5 };
 //int[] num1={1,2,3,5,4};  
 int [] num2 = { 2 , 1 , 5 , 3 , 4 };
        スタック<Integer> s1 =新しいスタック<Integer>();
        スタック s2 =新しいスタック s2();
 ( int i = 0 ; i < 5 ; i++) {
            s2.push(num2[i]);
        } 
        
        System.out.println(testOrder(num,s1,s2));
    } 
    
公共 ブール型テスト順序( int [] num, Stack<Integer> s1, Stack<Integer> s2) {
 int長さ = num.length;
 ( int i = 0 ; i < 長さ; i++) {
            s1.push(num[i]);
 int s2Num = s2.lastElement();
 s2Num==s1.lastElement().intValue()の場合{
                s1.ポップ();
                s2.pop();
            }
        }
 while (!s1.isEmpty()){
 s1.pop() と s2.pop() が等しい場合{
戻る 間違い;
            }
        }
戻る 真実;
    } 
 
コードをコピー

質問9:

//ポーカーデッキから5枚のカードを引き、0は任意の数字で、ストレートかどうかを判定します  
    
 @テスト 
公共  voidテスト(){
 int [] 数値 = { 0 , 1 , 5 , 3 , 2 };
        System.out.println(チェック(num));
    } 
    
公共 ブールチェック( int []num){
 //0-13  
 int [] pai =新しい 整数[ 14 ]
 ( int n : 数値)の場合
            pai[n]+= 1 ;
        }
        qsort(数値、 0 、数値の長さ-1 );
整数カウント = pai[ 0 ];
 int開始 = 0 ;
 （数値[ 0 ] == 0 ）の場合{
            開始=数値[ 1 ];
        }
それ以外{
            開始=数値[ 0 ];
        }
 ( int i = 開始; i <= 開始 + 5 ; i++) {
 (pai[i]> 1 )の場合、戻り値 間違い;
            カウント += pai[i];
        }
 （カウント == 5 ）の場合、戻り値 真実;
それ以外 戻る 間違い; 
        
    } 
    
公共  void qsort( int [] num, int left, int right){
 （左<右）の場合{
 intパーティション = パーティション(数値、左、右);
            qsort(数値、左、パーティション-1 );
            qsort(数値、パーティション+ 1 、右);
        }
    } 
    
公共  intパーティション( int [] num, int左, int右){
 intパーティション = num[左];
 （左<右） {
 while (left<right && num[right]>=パーティション){
                右 - ;
            }
            swap(数値、左、右);
 while (左<右 && num[左]<=パーティション){
                左++;
            }
            swap(数値、左、右);
        } 
        
左に戻る;
    } 
    
公共  void swap( int [] num, int m, int n){
数値[m]を整数で割ったもの。
        数値[m]=数値[n];
        num[n] = 一時;
    }

質問10:

//k 番目の醜い数を出力します (因数は 2、3、5 のみ)  
 
    
 
@テスト 
公共  void test(){
 
findUglyNum( 8 );
 
}
 
    
公共  void findUglyNum( intインデックス){
 
int [] num = new   int [インデックス];
 
int next = 1 ;
 
num[ 0 ]= 1 ;
 
int index2= 0 ;
 
int index3= 0 ;
 
int index5= 0 ;
 
 
 
while (next<index){
 
int num2 = num[index2]* 2 ;
 
int num3 = num[index3]* 3 ;
 
int num5 = num[index5]* 5 ;
 
            
            num[次] = getSuitable(num2,num3,num5);
 
            
 
while (num[index2]* 2 <=num[next]){
 
index2++;
 
}
 
while (num[index3]* 3 <=num[next]){
 
index3++;
 
}
 
while (num[index5]* 5 <=num[next]){
 
index5++;
 
}
 
next++;
 
            
        }
 
System.out.println(num[index- 1 ]);
 
}
 
    
公共  int getSuitable( int num2, int num3, int num5){
 
int s = num2;
 
if (num3<s){
 
s = num3;
 
}
 
if (num5<s){
 
s = num5;
 
}
 
return s;
 
}

[[137673]]