2018年9月 打卡

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。

n<=39

package test;

public class practiceEighth {
	
		public int Fibonacci(int n) {
		     
		         
		        //使用迭代法，用fn1和fn2保存计算过程中的结果，并复用起来
		        int fn1 = 1;
		        int fn2 = 1;
		         
		        //考虑出错情况
		        if (n <= 0) {
		            return 0;
		        }
		        //第一和第二个数直接返回
		        if (n == 1 || n == 2) {
		            return 1;
		        }
		 
		        //当n>=3时
		     
		        while (n-- > 2) {
		            fn1 += fn2;
		            fn2 = fn1 - fn2;
		        }
		        return fn1;
		    }
}

 

 

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

package test;

public class practiceNinth {
    public int JumpFloor(int target) {

	     
        
        //使用迭代法，用fn1和fn2保存计算过程中的结果，并复用起来
        int fn1 = 0;
        int fn2 = 1;
        int fn3 = 2;

        //考虑出错情况
        if (target <= 0) {
            return 0;
        }
        //第一和第二个数直接返回
        if (target == 1 ) {
            return 1;
        }
        if (target == 2 ) {
            return 2;
        }
 
        //当n>=3时
     
        while (target-- > 2) {
            fn1 = fn2 + fn3;
            fn2 = fn3;
            fn3 = fn1;

        }
        return fn1;
    
    }

}

 

 

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

package test;

public class practiceTenth {
    public int JumpFloorII(int target) {
        int a=1;
        return a<<(target-1);

    }

}

 

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

•  

  package test;
  
  public class practiceEleventh {
      public int RectCover(int target) {
          
          //考虑出错情况
          if (target <= 0) {
              return 0;
          }
  
      	if(target == 1){
          return 1;
      }
      else if(target==2){
          return 2;
      }else{
          return RectCover(target-1)+RectCover(target-2);
      }
      }
      
  
  }
  

  输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

package test;

public class practiceTwelfth {
	  public int NumberOf1(int n) {
			   int count = 0;
			          while (n != 0) {
			              ++count;
			              n = (n - 1) & n;
			          }
			          return count;
	    }
}

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

package test;

public class practiceThirteenth {
	 public double Power(double base, int exponent) {
         
	        //由于exponent是int类型的整数，则可能包含正整数、0以及负整数三种情况。
	        double temp=1;
	        if(exponent>0){
	            for(int i=1;i<=exponent;i++){
	                temp=temp*base;
	                if(temp>1.7976931348623157E308){
	                    System.out.println("已经超出double类型的取值范围。");
	                    return -1;
	                }
	            }
	            return temp;
	             
	        }if(exponent<0){
	            exponent=-exponent;
	            for(int i=1;i<=exponent;i++){
	                temp=temp*base;
	                if(temp>1.7976931348623157E308){
	                    System.out.println("已经超出double类型的取值范围。");
	                    return -1;
	                }
	            }
	            temp=1.0/temp;
	            return temp;
	        }else{
	            return 1;
	        }
	         
	  }
	}

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

package test;

public class practiceFourteenth {
	 public void reOrderArray(int [] array) {
	       for(int i= 0;i<array.length-1;i++){
	            for(int j=0;j<array.length-1-i;j++){
	                if(array[j]%2==0&&array[j+1]%2==1){
	                    int t = array[j];
	                    array[j]=array[j+1];
	                    array[j+1]=t;
	                }
	            }
	        }
	    }
}

 

输入一个链表，输出该链表中倒数第k个结点。

package test;

 class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
public class practiceFifteenth {
    public ListNode FindKthToTail(ListNode head,int k) {
    	
    		  ListNode p, q;
    		        p = q = head;
    		        int i = 0;
    		        for (; p != null; i++) {
    		            if (i >= k)
    		                q = q.next;
    		            p = p.next;
    		        }
    		        return i < k ? null : q;
    }

}