梦想101

题目描述
统计一个数字在排序数组中出现的次数。

public class Solution {
    public int GetNumberOfK(int [] array , int k) {
       int count  =  0;
        for(int i =0 ;i<array.length;i++){
            if(array[i]==k){
                count++;
            }
        }
        return count;
    }
}

题目描述
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

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

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

    }

}
*/
public class Solution {
    public int TreeDepth(TreeNode root) {
        if(root==null){
            return 0;
        }
        int left = TreeDepth(root.left);
        int right = TreeDepth(root.right);
        
        return Math.max(left,right)+1;
    }
}

题目描述
输入一棵二叉树，判断该二叉树是否是平衡二叉树。

平衡二叉树：某节点的左右子树深度差绝对值不超过1。利用递归求左右子树的深度，以判断这颗树是不是平衡的。

public class Solution {
    public boolean IsBalanced_Solution(TreeNode root) {
        //首先判断是不是空
        if(root ==null){
            return true;
        }
        
        int left = getpath(root.left);
        int right = getpath(root.right);
        
        int diff = left-right;
       if (diff > 1 || diff < -1)
            return false;
       return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
        
    }
    
    public int getpath(TreeNode root){
        if(root==null){
            return 0;
        }
        
        else
    
         return Math.max(getpath(root.left), getpath(root.right)) + 1;
        
        
    }
    
    
}

题目描述
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

首先：位运算中异或的性质：两个相同数字异或=0，一个数和0异或还是它本身。
当只有一个数出现一次时，我们把数组中所有的数，依次异或运算，最后剩下的就是落单的数，因为成对儿出现的都抵消了。加粗样式

Stack.peek()和Stack.pop(）的相同点是 获取栈顶的值，不同点 则是 Stack.peek()只是获取栈顶的值，而Stack.pop()是获取栈顶的值然后删除。
Java 实现
1、Arrays.sort 数组排序
2、使用栈进行从小到大入栈，一样的则弹出，不一样则入栈
3、取栈中剩余的元素

//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
import java.util.Arrays;
import java.util.Stack;
public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        
        Stack <Integer> sta = new Stack<Integer>();
        
        Arrays.sort(array);
        
        for(int i =0; i<array.length;i++)
        {
            if(sta.isEmpty()||sta.peek()!=array[i]){
                sta.push(array[i]);
            }else{
                sta.pop();
            }
        }
        num1[0]=sta.pop();
        num2[0]=sta.pop();
        
    }
}

题目描述
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

import java.util.ArrayList;
public class Solution {

    public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
       //保存数组 就是又几个数组是满足的条件的
          ArrayList<ArrayList<Integer>> aList=new ArrayList<ArrayList<Integer>>();
           if(sum<2)
               return aList;
           for(int i=1;i<=sum/2;i++){
           //找出来对的 先存入到新建的list中存下来数值
               ArrayList<Integer> aList2=new ArrayList<Integer>();
               int count=0;
               for(int j=i;j<sum;j++){
                   count+=j;
                   aList2.add(j);
                   if(count>sum)
                       break;
                   else if(count==sum){
                       aList.add(aList2);
                      break;  
                   }
               }
           }
            
           return aList;
        
        
    }
}

题目描述
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
        ArrayList<Integer>list = new ArrayList<Integer>();
         if(array.length==0)  return list;
        for(int  i =0;i<array.length;i++){
            int c = array[i];
            int j = i+1;
          
             while(j<array.length&&(c+array[j])!=sum){
                 
                if(c+array[j]>sum)
                    break;
                 
                j++;
            }
            if(j<array.length&&(array[j]+c)==sum){
                list.add(c);
                list.add(array[j]);
                break;
            }
            
        }
        return list;
        
    }
}

题目描述
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

public class Solution {
    public String LeftRotateString(String str,int n) {
        if(str.length()==0){
            return "";
        }
        
        //首先是先删除 0----》 n 个字母组成一个字符串
        //其次删除 n---->最后的字幕组成一个字符串
        //最后创建一个字符串 增加第一个 添加第二个字符串结束。
        
        StringBuffer s1 = new StringBuffer(str);
        
        StringBuffer s2 = new StringBuffer (str);
        
        StringBuffer s3 = new StringBuffer();
        
        s1.delete(0,n);
        
        s2.delete(n,str.length());
        
        s3.append(s1.toString()).append(s2.toString());
        return s3.toString();
    }
}