编程题

题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一
个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中

，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？

分析：假设桃子的数量为total，则每次猴子拿走后桃子的数量为total=total-(total/5+1),当每只猴子拿桃子的时候恰好桃子数量对5求余数刚好为1且桃子数量大于5的时候，累计得到的桃子的数量达到最小，本人给的思路是穷举法，代码如下：

public int getTaoZi(){
		//假设桃子的数量
		int result = 6;
		//用于存放当前桃子的数量
		int temp = 0;
		while(true){
			//每次循环记录下当前桃子的数量
			temp = result;
			//对每只猴子拿完桃子进行分析
			for(int i=0;i<5;i++){
				//判断剩下的桃子是否还足够可以分配给其它猴子
			    if((temp>5&&(temp%5==1))){	
			    	//计算每只猴子拿完桃子后所剩下的桃子数量
			    	temp -= ((temp/5)+1);
			    	//当5只猴子全部拿完后，返回桃子的最少数量
			    	if(i==4){
			    		return result;
			    	}
			    }else{
			    	break;
			    }
			}
			result++;
			
		}
		
		
	}

最大整数

     设有n个正整数，将它们连接成一排，组成一个最大的多位整数。

     例如：n=3时，3个整数13，312，343，连成的最大整数为34331213。

     又如：n=4时，4个整数7，13，4，246，连成的最大整数为7424613。

     输入：n

     N个数

     输出：连成的多位数

     算法分析：此题很容易想到使用贪心法，在考试时有很多同学把整数按从大到小的顺序连接起来，测试题目的例子也都符合，但最后测试的结果却不全对。按这种标准，我们很容易找到反例：12，121应该组成12121而非12112，那么是不是相互包含的时候就从小到大呢？也不一定，如12，123就是12312而非12123，这种情况就有很多种了。是不是此题不能用贪心法呢？

     其实此题可以用贪心法来求解，只是刚才的标准不对，正确的标准是：先把整数转换成字符串，然后在比较a+b和b+a，如果a+b>=b+a，就把a排在b的前面，反之则把a排在b的后面。

     java源程序：

public static void main(String[] args){  
  String str = "";  
  ArrayList<String> array = new ArrayList<String>();  
  Scanner in = new Scanner(System.in);  
  System.out.println("Please input the number of data:");  
  int n = in.nextInt();  
  System.out.println("Please input the data:");  
  while (n-- > 0) {  
   array.add(in.next());     
  }  
  for(int i = 0; i < array.size(); i ++)  
   for(int j = i + 1; j < array.size(); j ++){  
    if((array.get(i) + array.get(j)).compareTo(array.get(j) + array.get(i)) < 0){  
     String temp = array.get(i);  
     array.set(i, array.get(j));  
     array.set(j, temp);  
    }  
   }    
  for(int i = 0; i < array.size(); i ++){  
   str += array.get(i);  
  }  
  System.out.println("str=:"+str);    
 }  
}  

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

输入描述:

二叉树的镜像定义：源二叉树 
    	    8
    	   /  \
    	  6   10
    	 / \  / \
    	5  7 9 11
    	镜像二叉树
    	    8
    	   /  \
    	  10   6
    	 / \  / \
    	11 9 7  5

解决思路：本题采用递归解决，将每一个左子节点和右子节点进行交换

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public void Mirror(TreeNode root) {
        TreeNode currentNode  = root;
        if(root==null){
            return;
        }
        TreeNode tempNode  = currentNode.left;
        currentNode.left = currentNode.right;
        currentNode.right = tempNode;
            Mirror(currentNode.left);
            Mirror(currentNode.right);
    }
}

题目描述

输入：输入一行字符，计算每个字符的个数

输出：例如：‘1234123’ ；输出：‘1’：2，‘2’：2，‘3’：2，‘4’：1

public static void quickSort(char[] data,int left,int right){
    	int i,j;
    	char base,temp;
    	if(left>right){
    		return;
    	}
    	i = left;
    	j = right;
    	base = data[left];
    	while(i!=j){
    		while(data[j]>=base&&i<j){
    			j--;
    		}
    		while(data[i]<=base&&i<j){
    			i++;
    		}
    		if(i<j){
    			temp = data[i];
    			data[i]=data[j];
    			data[j]=temp;
    		}
    	}
    	data[left]=data[i];
    	data[i]=base;
    	quickSort(data,left,i-1);
    	quickSort(data,i+1,right);
    }
    public static void total(char[] data){
    	int start = 0;
    	int count = 0;
    	boolean isFinish =false;
    	while(start<data.length&&!isFinish){
    		char temp = data[start];
    		for(int i=start;i<data.length;i++){
    			if(start==data.length-1){
    				isFinish = true ; 
    			}
    			if(data[start]==data[i]){
    				count++;
    			}else{
    				start = i;
    				break;
    			}
    		}
    		
    		System.out.print("'"+temp+"'"+":"+count+" ");
    		count=0;
    	}
    	
    }
    public static void main(String[] args) {
    	String str = "1234123";
    	char[] data = str.toCharArray();
		quickSort(data, 0, data.length-1);
		total(data);
	}

题目描述

把字符串：“aaa23nadfs343”，数字放前面字母放后面

public static void divide(String str){
    	char[] data = str.toCharArray();
    	for(int i=0;i<data.length;i++){
    		if(data[i]>='0'&&data[i]<='9'){
    			int k = i;
    			char temp = data[i];
    		    while(k>0&&!(data[k-1]>='0'&&data[k-1]<='9')){
    		    	data[k]=data[k-1];
    		    	k--;
    		    }
    		    data[k]=temp;
    		}
    	}
    	System.out.println(new String(data,0,data.length));
    	
    }

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

分析：本题解决思路是利用递归来进行解答，两个链表首先找出头结点较小的链表，并进行交换，再遍历头结点较小的链表，直到找到比另一个链表中头结点要大的节点，找到后，将遍历后的当前节点与另一个链表的头结点进行连接，依照此规律进行递归，递归完成后，返回较小链表的头结点，即可满足要求。

代码如下：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1==null){
            return list2;
        }
        if(list2==null){
            return list1;
        }
       return getResult(list1,list1,list2);
        
    }
    public ListNode getResult(ListNode list1,ListNode leftNode,ListNode rightNode){
        
        if(leftNode.val>rightNode.val){
         ListNode tempNode = leftNode;
         leftNode = rightNode;
         rightNode = tempNode;
        }
        //遍历list1链表，直到找到list1链表中比list2中头结点大的元素，再进行链表连接
        ListNode list1CurrentNode  = leftNode.next;
        ListNode list1ParentNode = leftNode;
        ListNode list2CurrentNode  = rightNode;
          if(list1CurrentNode==null){
                list1ParentNode.next = list2CurrentNode;
                return list1;
            }
        while(list1CurrentNode.val<=list2CurrentNode.val){
            list1ParentNode = list1CurrentNode;
            list1CurrentNode = list1CurrentNode.next;
            if(list1CurrentNode==null){
                list1ParentNode.next = list2CurrentNode;
                return list1;
            }
        }
        list1ParentNode.next = list2CurrentNode;
       return getResult(list1,list2CurrentNode,list1CurrentNode);
        
    }
}