小白刷题-1-1206

387 fist unique character in a string

 

pubic int Firstunique(string s){

int pos=-1;

int[] bits=new int[26];

for(int i=0; i<s.length;i++){

char c=s.charAt(i);//将字符串中的字母依次给c用来计算这个字母出现的次数

++bits[c-‘a’];//在该字母的位置处计数，每次加一

}

for(int i=0;i<s.lenth;i++){

char c=s.charAt(i);

if(bits[c-‘a’]==1){

pos=i;

break;

 }

}

return pos;

}

创建一个26长度的数组，用字符减法来标记出现的字母，index相当于字母位置，entries为出现次数。第一个for循环记录，第二个取出符合标准的字母在字符串中的位置， 进行for循环，当entris为1时记录位置；

 

2. add two numbers

先创建一个新的listnode， 和他的指针（没有必要对l1l2设置新的指针），以及一个进位；

用进位对每个链表的值相加，余数为该位此时的值；

P3一开始的时候指向的是一个新建的链表，当得到carry之后，将p3.next指向新得到的carry,然后更新之前的p3指针；

然后对carry取整，取得进位，与下一轮的数字相加，这样就解决了进位的问题

 

pubic ListNode addTwoNumbwes(ListNode l1, ListNode l2){

       int carry=0;

       ListNodenewHead= new ListNode(0);

       ListNode p3=newHead;

 

       While(l1 !=null||l2!=null){

              If(l1!=null){

              Carry+=l1.val;

              l1=l1.next;

 }

if (l2!=null){

carry+=l2.val;

l2=l2.next;

}

p3.next=new ListNode(carry%10);

p3=p3.next;

carry/=10;

}

if(carry==1)

       p3.next=newListNode(1);

 

return newHead.next;

 

 

}

 

1.    two sum

 

用目标数-减数1=减数2，

将减数2存在hashmap里，以及当前减数1的index存为map.value

当循环进行到i次时，能在hashmap里找到减数2了，此时的i就是减数2的index， 再从map中取出减数1的index

pubic int twoSum(int[] nums, int target){

int[] res=new int[2];

HashMap<Integer, Integer> map= new HashMap<Integer,Integer>();

 

if (nums==null||nums.length<2){

return null;

}

 

for (int i=0,i<nums.length,i++){

if(map.containsKey(nums[i])){

res[0]=map.get(nums[i]);

res[1]= i;

break;

}else{

map.put(target-nums[i],i);

 

}

}

return res;

}

 

104. Maximum depth of binary tree

非递归解法：keyword： 层序遍历，广度优先；

广度优先，先进先出，使用queue；

深度优先，先进后出， 使用stack；

 

算level的关键是使用curnumber记当前层的节点数，使用nextnumber记下一层的节点数，当当前节点数为零时，则level加一；

 

本例中，这个树进入queue的排序为 4261357， 先进先出

 

   4

         2      6

              1  3  5   7

 

pubic int maxDepth(TreeNode root){

if(root=null){return 0;}

 

int level=0;

LinkedList<TreeNode> queue = newLinkedList<TreeNode>();

 

queue.add(root );    queue: 4

int curNum=1;

int nextNum=0;  

 

while(!queue.isEmpty()){

       treeNode n=queue.poll();  // n=4;n=2; n=6; n=1;

       curNum--;//curNum=0; 1; 0;2

 

       if(n.left!=null){

       queue.add(n.left);//queue: 2;  queue 6,1; queue:1,5

       nextNum++;  //nextNum=1; 1; 3

 

}

if(n.right!=null){

queue.add(n.right);//queue: 2,6;queue:613; quque:1,3,5,7

nextNum++;//nextNum=2; 2; 4

}

if(curNum==0){

       curNum=nextNum;//curnum=2;cur=4;

       nextNum=0;

       level++;//level=1; 2;

 

}

 

}

return level;

 

回归解法：

理解： 左右两边各算各的，慢慢体会

  4

         2     5

              1 

maxdepth(4) ->maxDepth(2)+1 -> (maxDepth(1)+1)+1->0+1+1;

 

maxdepth(4)-> 

 

      maxDepth(2)                       maxDepth(5) 

 

  (maxDepth(1)+1)+1->1+1+1;               0

 

pubic int maxDepth(TreeNode root){

       if(root==null)

       return 0;

       returnMath.max(maxDepth(root.left), maxDepth(root.right))+1;

 

}

层序遍历：

http://ptr.chaoxing.com/nodedetailcontroller/visitnodedetail?knowledgeId=3461260