【leetcode算法】更新至62题

原创 2015年07月07日 09:45:15

1T104  树的深度

public class T104 {

 

 

}

 

  class TreeNode {

      int val;

      TreeNode left;

      TreeNode right;

     TreeNode(int x) { val = x; }

  }

 

 

2、判断两棵树是否相等

   public boolean isSameTree(TreeNode p, TreeNode q) {

        if(p ==null || q==null)

            return p == q;

        if(p.val != q.val)

            return false;

        else

            return isSameTree(p.left,q.let) && isSameTree(p.right,q.right);

    }

 

 

 

3、判断一个数组中值出现一次的数

 

public class Solution {

    public int singleNumber(int[] A) {

        int result = 0;

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

            result = result ^ A[i];

        }

        return result;    

    }

}

 

4、判断一个数的二进制有多少个1

 

public int hammingWeight(int n) {

 int count=0;

 if(n !=0)

 count=1;

 while((n & (n-1))!=0){

 n=n&(n-1);

 count+=1;

 }

 return count;

 }

 

5、罗马数字变整数

public int romanToInt(String s) {

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

        map.put('I', 1);

        map.put('V', 5);

        map.put('X', 10);

        map.put('L', 50);

        map.put('C', 100);

        map.put('D', 500);

        map.put('M', 1000);

 

        int sum=0;

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

            if(i!=s.length()-1 && map.get(s.charAt(i))<map.get(s.charAt(i+1))){

                sum-=map.get(s.charAt(i));

            }else{

                sum+=map.get(s.charAt(i));

            }

        }

        return sum;

    }

 

 

 

 

 

 

 

 

6、链表反转

 

   public ListNode reverseList(ListNode head) {

     if(head==null)

     return null;

        ListNode pre=head;

        

        ListNode nextN=head.next;

        pre.next=null;

     while(nextN !=null){

     ListNode temp=nextN.next;

     nextN.next=pre;

     pre=nextN;

         nextN=temp;

        }

     return pre;

    }

 

 

 

7happy Number

 

 

 

 

8Excel Sheet Column Number

 

 

√9Majority Element

Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.

 

 

 

 

 

 

 

 

 

10、判断回文字符串

 

 

 

 

11、Count and Say 

 

 

 public String countAndSay(int n) {

 String s="1";

 if(n==1)

 return s;

 for(int i=1;i<=n-1;i++){

 s=getN(s);

 

 }

 return s;

 }

 

 public String getN(String s){

 int pos=0;

 int length=s.length();

 Integer flag=0;

 Character ch=' ';

 String back="";

 while(pos<=length-1){

 char a=s.charAt(pos++);

 if(flag==0){

 flag=1;

 ch=a;

 }else{

 if(a==ch){

 flag++;

 }else{

 back+=flag.toString()+ch.toString();

 flag=1;

 ch=a;

 

 }

 }

 }

 back+=flag.toString()+ch.toString();

 return back;

 }

 

 

12Isomorphic Strings 

判断两个字符串的结构是否相同

 

 

 

 

√13、判断素数的个数

 

 

超时算法:

 

判断一个数是不是质数:

检查一个正整数N是否为素数,最简单的方法就是试除法,将该数N用小于等于根号N的所有素数去试除,若均无法整除,N则为素数

 

接受:

 

 

 

 

所有的偶数(除2外)都不是素数,所有素数的倍数都不是素数

 

 

更好的方法

 

 

√14Two Sum

 

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

int ret[]=new int[2];

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

boolean flag=map.containsKey(nums[i]);

if(flag){

map.get(nums[i]).add(i);

}else{

List<Integer> list=new ArrayList<Integer>();

list.add(i);

map.put(nums[i], list);

}

}

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

int val=target-nums[i];

if(map.get(val) != null){

List key=map.get(val);

if(val==nums[i]){

if(key.size()>1){

int j=(Integer) key.get(1);

ret[0]=i+1;

ret[1]=j+1;

break;

}

}else{

int j=(Integer) key.get(0);

ret[0]=i+1;

ret[1]=j+1;

break;

}

}

}

return ret;

 

15、求中位数

已知两个排好序的数组AB,长度分别为mn.求他们联合数组的中位数。

 

如果两个数组的长度一样长,则比较好求。

分别求出两个数组的中位数。如果A的中位数大的话,则中位数不可能在A的右半部分,同时中位数也不可能在B的左半部分。依次类推。等剩下两个的时候截止。选出两个小值的大数,大值的小数求评价即可。

 

 

 

如果两个数组的长度不一样,则

先合并,再找出中位数。

 

 

 

求等长数组的中位数:

 

public double get(int[] a,int[] b){

int length=a.length;

double midA,midB;

if(length==0){

return 0;

}

if(length==1){

return (a[0]+b[0])/2.0;

}

if(length==2){

return (Math.min(a[1], b[1])+Math.max(a[0], b[0]))/2.0;

}

//如果a数组长度是个偶数

if(length%2==0){

midA=(a[length/2]+a[length/2-1])/2.0;

midB=(b[length/2]+b[length/2-1])/2.0;

if(midA==midB){

return  midA;

}

if(midA<midB){

int[] ab=Arrays.copyOfRange(a, length/2-1, length);

int[] bb=Arrays.copyOfRange(b, 0, length/2+1);

return get(ab,bb);

}

else{

int[] bb=Arrays.copyOfRange(b, length/2-1, length);

int[] ab=Arrays.copyOfRange(a, 0, length/2+1);

return get(ab,bb);

}

}

//a数组长度为奇数

else{

midA=a[length/2];

midB=b[length/2];

if(midA==midB){

return  midA;

}

if(midA<midB){

int[] ab=Arrays.copyOfRange(a, length/2, length);

int[] bb=Arrays.copyOfRange(b, 0, length/2+1);

return get(ab,bb);

}

else{

int[] bb=Arrays.copyOfRange(b, length/2, length);

int[] ab=Arrays.copyOfRange(a, 0, length/2+1);

return get(ab,bb);

}

}

}

 

 

求不等长的:

 

 public double findMedianSortedArrays(int nums1[], int nums2[]) {

 int a=nums1.length;

 int b=nums2.length;

 int len=a+b;

 if(len%2==1 ){

 int k=len/2+1;

 return getKth(nums1, nums2, k);

 }else{

 int k=len/2;

 int k1=len/2+1;

 return (getKth(nums1, nums2, k)+getKth(nums1, nums2, k1))/2.0;

 

 }

 }

 

 public int getKth(int[] a,int[] b,int k){

 if(a.length>b.length){

 return getKth(b,a,k);

 }

 if(a.length ==0){

 return b[k-1];

 }

 if(k==1){

 return Math.min(a[0], b[0]);

 }

 int pa=Math.min(a.length, k/2);

 int pb=k-pa;

 int mida=a[pa-1];

 int midb=b[pb-1];

 if(mida<midb){

 a=Arrays.copyOfRange(a, pa, a.length);

 return getKth(a, b, k-pa);

 }

 if(mida>midb){

 b=Arrays.copyOfRange(b, pb, b.length);

 return getKth(a, b, k-pb);

 }else{

 return mida;

 }

 }

 

 

 

16Remove Linked List Elements

 

 

 

 

 

 

 

√17House Robber

动态规划,设置maxV[i]表示到第i个房子位置,最大收益。

递推关系为maxV[i] = max(maxV[i-2]+num[i], maxV[i-1])

 

 public int rob(int[] nums) {

 int n = nums.length;

        if(n == 0)

            return 0;

        else if(n == 1)

            return nums[0];

        else

        {

           int[] maxV=new int[n];

            maxV[0] = nums[0];

            maxV[1] = Math.max(nums[0], nums[1]);

            for(int i = 2; i < n; i ++)

                maxV[i] = Math.max(maxV[i-2]+nums[i], maxV[i-1]);

            return maxV[n-1];

        }

 }

 

 

 

18Reverse Bits

 public int reverseBits(int n) {

       String s=Integer.toBinaryString(n);

       int length=s.length();

       if(length<32){

        String padding="";

        for(int i=0;i<32-length;i++){

        padding+="0";

        }

        s=padding+s;

       }

       int temp;

       char[] news=new char[32];

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

        news[i]=s.charAt(31-i);

        

       }

       int sum=0;

       int pos=1;

       int value=0;

       for(int j=news.length-1;j>=0;j--){

        if(news[j]=='1'){

        value=pos;

        sum+=value;

        

       

        }

        pos=pos*2;

       }

       return sum;

 }

 

 

 

 

 

19、判断是否是平衡二叉树

 public boolean isBalanced(TreeNode root) {

        if(root==null)

         return true;

        int leftd=depth(root.left);

        int rightd=depth(root.right);

        int width=leftd-rightd;

        if(width>1 || width<-1){

         return false;

        }else{

         boolean leftb=isBalanced(root.left);

         if(!leftb){

         return false;

         }

         boolean rightb=isBalanced(root.right);

         if(!rightb){

         return false;

         }

        }

        return true;

    }

    

    public int depth(TreeNode root){

     if(root==null){

     return 0;

     }

     int leftd=depth(root.left);

     int rightd=depth(root.right);

     return Math.max(leftd, rightd)+1;

    }

 

 

 

 

 

 

 

20、判断n!尾数中0的个数

 

   public int trailingZeroes(int n) {

   

      if (n / 5 == 0) return 0;

         return n / 5 + trailingZeroes(n / 5);

    }

 

 

 

 

21Rotate Array

 

 

 

 

22Insertion Sort List

 

  public ListNode insertionSortList(ListNode head) {

 if(head==null || head.next==null){

 return head;

 }

 ListNode cur=head.next;

 ListNode pre=head;

 

 while(cur!=null){

 if(cur.val<pre.val){

if(cur.val<head.val){

pre.next=cur.next;

cur.next=head;

head=cur;

cur=pre.next;

}else{

ListNode bi=head;

while(bi.next.val<cur.val){

bi=bi.next;

}

pre.next=cur.next;

cur.next=bi.next;

bi.next=cur;

cur=pre.next;

}

 

 

 

 

 }else{

 pre=pre.next;

 cur=cur.next;

 }

 

 

 }

 return head;

  }

 

 

 

23Plus One

 public int[] plusOne(int[] digits) {

 return addN(digits,digits.length-1);

  }

  

  public int[] addN(int[] a,int n){

  if(n<0){

  int[] b=new int[a.length+1];

  b[0]=1;

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

  b[i+1]=a[i];

  }

  return b;

  }

  a[n]+=1;

  if(a[n]==10){

  a[n]=0;

  return addN(a,n-1);

  }

  return a;

  }

 

24Merge Sort

public void merge(int[] nums1, int m, int[] nums2, int n) {

  int[] c=new int[m+n];

  int ap=0;

  int bp=0;

  int z=0;

  while(ap<m && bp<n){

  if(nums1[ap]<nums2[bp]){

  c[z++]=nums1[ap++];

  }else{

  c[z++]=nums2[bp++];

  }

  }

      if(ap<m){

       for(int i=ap;i<m;i++){

       c[z++]=nums1[i];

       }

      }

      if(bp<n){

       for(int j=bp;j<n;j++){

       c[z++]=nums2[j];

       }

      }

      for(int k=0;k<c.length;k++){

       nums1[k]=c[k];

      }

  }

 

 

 

 

25Remove Duplicates from Sorted List 

 

 

 

26Merge Two Sorted Lists

 

 

 

 public ListNode mergeTwoLists(ListNode l1, ListNode l2) {

      

  if(l1==null){

  return l2;

  }

  if(l2==null)

  return l1;

  ListNode now1=l1;

  ListNode now2=l2;

  ListNode next;

  if(l1.val>l2.val)

 return  mergeTwoLists(l2, l1);

  while(now2!=null){

  next=now2.next;

  now1=insert(now1,now2);

  now2=next;

  }

  return l1;

  }

  public ListNode insert(ListNode l1,ListNode l2){

  

  while(l1.next!=null && l1.next.val<l2.val){

  l1=l1.next;

  }

  l2.next=l1.next;

  l1.next=l2;

  return l2;

  }

 

 

 

 

27Valid Parentheses (有效的括号)

public boolean isValid(String s) {

  if(s.length()<2){

  return false;

  }

  char[] arr=new char[s.length()];

  int top=0;

  arr[0]=s.charAt(top++);

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

  arr[top]=s.charAt(i);

  top++;

  if(top>1){

  if(arr[top-1]=='}' && arr[top-2]=='{')

  top=top-2;

  else if(arr[top-1]==']' && arr[top-2]=='[')

  top=top-2;

  else if(arr[top-1]==')' && arr[top-2]=='(')

  top=top-2;

  }

  }

  if(top==0)

  return true;

  else 

  return false;

  }

 

 

28Excel Sheet Column Title

  public String convertToTitle(int n) {

        char[] map={'Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N',

'O','P','Q','R','S','T','U','V','W','X','Y'};

     String str="";

     int yu;

     int shang;

     while(n!=0){

      yu=n%26;

      n=n/26;

      if(yu==0){

      n=n-1;

      }

      str=map[yu]+str;

     }

     return str;

    }

 

 

 

 

29Path Sum

 

 

 /**

   * Definition for a binary tree node.

   * public class TreeNode {

   *     int val;

   *     TreeNode left;

   *     TreeNode right;

   *     TreeNode(int x) { val = x; }

   * }

   */

  public boolean hasPathSum(TreeNode root, int sum) {

  if(root==null){

  return false;

  }

  if(root.left==null && root.right==null){

  if(root.val==sum)

  return true;

  else{

  return false;

  }

  }

   boolean flagl=hasPathSum(root.left,sum-root.val);

   boolean flagr=hasPathSum(root.right, sum-root.val);

  

  return flagl||flagr;

  }

 

 

 

30、杨辉三角

public List<List<Integer>> generate(int numRows) {

      List<List<Integer>> list=new ArrayList<List<Integer>>();

      if(numRows<=0)

       return list;

      for(int i=1;i<=numRows;i++){

       if(i==1){

       List<Integer> li=new ArrayList<Integer>();

       li.add(1);

       list.add(li);

       continue;

       }

       if(i==2){

       List<Integer> li=new ArrayList<Integer>();

       li.add(1);

       li.add(1);

       list.add(li);

       continue;

       }

       List<Integer> li=new ArrayList<Integer>(i);

       li.add(1);

       List<Integer> list2=list.get(i-2);

       for(int j=1;j<i-1;j++){

       li.add(list2.get(j-1)+list2.get(j));

       }

       li.add(1);

       list.add(li);

      }

      return list;

  }

 

 

31Pascal's Triangle II

 

 

  public List<Integer> getRow(int rowIndex) {

  List<Integer> list=new ArrayList<Integer>();

  List<Integer> list2=new ArrayList<Integer>();

 

  if(rowIndex==0){

      list.add(1);

      return list;

  }

  if(rowIndex==0){

      list.add(1);

      return list;

  }

  if(rowIndex==1){

  

  list.add(1);

  list.add(1);

  return list;

  }

      list.add(1);

      list.add(2);

      list.add(1);

   

  

  for(int i=3;i<=rowIndex;i++){

  list2= new ArrayList<Integer>(list);

  list.clear();

  list.add(1);

  for(int j=0;j<=list2.size()-2;j++){

  list.add(list2.get(j)+list2.get(j+1));

  }

  list.add(1);

  }

  return list;

  }

 

 

 

32Min Stack

 

 

class MinStack {

   int[] arr=new int[5000];

int top=-1;

    public void push(int x) {

     if(top==arr.length-1){

    

     arr=Arrays.copyOf(arr, arr.length+5000);

     }

        arr[++top]=x;

    }

 

    public void pop() {

        if(top==-1)

         return;

        --top;

    }

 

    public int top() {

        return arr[top];

    }

 

    public int getMin() {

     int min=arr[0];

        for(int i=1;i<=top;i++){

         if(arr[i]<min)

         min=arr[i];

        }

        return min;

    }

    

}

 

 

 

 

33Minimum Depth of Binary Tree

 

 

 

34Intersection of Two Linked Lists 

 

 

 public ListNode getIntersectionNode(ListNode headA, ListNode headB) {

         int len1=0;

     int len2=0;

     ListNode a=headA;

     ListNode b=headB;

 while(a!=null ){

 

 len1++;

 a=a.next;

 }

 while(b!=null){

 len2++;

 b=b.next;

 }

 if(len1<len2){

 return getIntersectionNode(headB, headA);

 }

 ListNode ret=null;

 

 for(int i=0;i<len1;i++){

 if(i<len1-len2)

 headA=headA.next;

 else{

 if(headA.val==headB.val){

 if(ret==null)

 ret=headA;

 }else{

 ret=null;

 }

  headA=headA.next;

 headB=headB.next;

 }

 }

 return ret;

    }

 

 

35Contains Duplicate 

 

 

 

36Symmetric Tree

 

 

 

 

 

37Integer Reverse

 

 

 

 

 

 

 

38Palindrome Number 

 

public boolean isPalindrome(int x) {

        if(x<0) return false;

        return String.valueOf(x).equalsIgnoreCase(new StringBuffer(String.valueOf(x)).reverse().toString());

    }

 

 

 

 

 

39Remove Nth Node From End of List

 

 

40ZigZag Conversion

 public String convert(String s, int numRows) {

 int len=s.length();

 if(numRows==1)

 return s;

 int shang=len/(numRows+numRows-2);

 int yu=len%(numRows*2-2);

 if(yu<=numRows)

 yu=1;

 else{

 yu=yu%numRows+1;

 }

 

 int lie=shang*(1+numRows-2)+yu;

 char[][] arr=new char[numRows][lie];

 for(int w=0;w<numRows;w++){

 for(int f=0;f<lie;f++){

 arr[w][f]=' ';

 }

 }

 int pos=0;

 int j=0;

 for(int i=0;i<lie;i++){

 if(j==0){

 while(j<numRows && pos<s.length()){

 arr[j][i]=s.charAt(pos++);

 j=j+1;

 }

 j=j-1;

 continue;

 }else{

 if(pos<s.length())

 arr[--j][i]=s.charAt(pos++);

 if(j==0){

 while(j<numRows-1 && (pos-1)<s.length()-1){

 arr[++j][i]=s.charAt(pos++);

 }

 

 }

 }

 

 }

 String str="";

 for(int k=0;k<numRows;k++){

 for(int z=0;z<lie;z++){

 if(arr[k][z]!=' '){

 str=str+arr[k][z];

 }

 }

 }

 return str;

 }

 

 

 

41Compare Version Numbers

public int compareVersion(String version1, String version2) {

        String[] arr1=version1.split("\\.");

       if(arr1.length==0){

        arr1=new String[1];

        arr1[0]=version1;

       }

       String[] arr2=version2.split("\\.");

       if(arr2.length==0){

        arr2=new String[1];

        arr2[0]=version2;

       }

       int length=arr1.length>arr2.length ? arr2.length :arr1.length;

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

        if(Integer.valueOf(arr1[i])>Integer.valueOf(arr2[i])){

        return 1;

        }

        if(Integer.valueOf(arr1[i])<Integer.valueOf(arr2[i])){

        return -1;

        

        }  

       }

      

        if(arr1.length>arr2.length){

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

        if(Integer.valueOf(arr1[i])!=0)

        return 1;

        }

        return 0;

        }

        if(arr1.length<arr2.length){

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

        if(Integer.valueOf(arr2[i])!=0)

        return -1;

        }

        return 0;

        }

        else

        return 0;

    }

 

 

42Longest Common Prefix

 public String longestCommonPrefix(String[] strs) {

        String str="";

        int len=strs.length;

        int flag=0;

        if(len==0)

         return "";

        for(int i=0;i<strs[0].length();i++){

         char c=strs[0].charAt(i);

         for(int j=1;j<len;j++){

         try{

         if(strs[j].charAt(i)!=c){

             return str;

             }

         }catch(Exception e){

         return str;

         }

        

         }

         str=str+c;

        

        }

        return str;

    }

43Remove Duplicates from Sorted Array 

 

 

 

 

 

44Binary Tree Level Order Traversal II 

 

public List<List<Integer>> levelOrderBottom(TreeNode root) {

List<List<Integer>> list=new ArrayList<List<Integer>>();

if(root==null)

return list;

List<Integer> li=new ArrayList<Integer>();

List<TreeNode> pre=new ArrayList<TreeNode>();

List<TreeNode> now=new ArrayList<TreeNode>();

pre.add(root);

li.add(root.val);

list.add(new ArrayList<Integer>(li));

li.clear();

while(pre.size()!=0){

for(int i=0;i<pre.size();i++){

if(pre.get(i).left!=null){

now.add(pre.get(i).left);

li.add(pre.get(i).left.val);

}

if(pre.get(i).right!=null){

now.add(pre.get(i).right);

li.add(pre.get(i).right.val);

}

}

if(li.size()>0){

list.add(0,new ArrayList<Integer>(li));

li.clear();

pre=new ArrayList<TreeNode>(now);

now.clear();

}else{

break;

}

}

return list;

    }

 

 

 

45Binary Tree Level Order Traversal 

 

public List<List<Integer>> levelOrder(TreeNode root) {

 List<List<Integer>> list=new ArrayList<List<Integer>>();

 List<TreeNode> li=new ArrayList<TreeNode>();

 List<TreeNode> pre=new ArrayList<TreeNode>();

 

 List<Integer> val=new ArrayList<Integer>();

 if(root==null)

 return list;

 li.add(root);

 val.add(root.val);

 list.add(new ArrayList<Integer>(val));

 val.clear();

 while(li.size()!=0){

 pre=new ArrayList<TreeNode>(li);

 li.clear();

 for(TreeNode node:pre){

 if(node.left!=null){

 li.add(node.left);

 val.add(node.left.val);

 }

 if(node.right!=null){

 li.add(node.right);

 val.add(node.right.val);

 }

 }

 pre.clear();

 if(val.size()>0)

 list.add(new ArrayList<Integer>(val));

 val.clear();

 }

 return list;

 

 }

 

46Remove Element

 

 

 

 

 

 

47Implement strStr()

 

 

public int strStr(String haystack, String needle) {

       int len1=haystack.length();

       int len2=needle.length();

       if(len1<len2)

        return -1;

       int i,j;

       for( i=0;i<=len1-len2;i++){

        for(j=0;j<len2;j++){

        if(haystack.charAt(i+j)!=needle.charAt(j)){

        break;

        }

        }

        if(j==len2)

        return i;

       }

       return -1;

       

 }

 

 

 

48Valid Sudoku

 public boolean isValidSudoku(char[][] board) {

 List<Character> ch=new ArrayList<Character>();

 ch.add('1');

 ch.add('2');

 ch.add('3');

 ch.add('4');

 ch.add('5');

 ch.add('6');

 ch.add('7');

 ch.add('8');

 ch.add('9');

 List[][] temps=new List[3][3];

 for(int i=0;i<3;i++){

 for(int j=0;j<3;j++){

 temps[i][j]=new ArrayList<Character>(ch);

 }

 }

 for(int i=0;i<9;i++){

 List<Character> temp=new ArrayList<Character>(ch);

 List<Character> temp0=new ArrayList<Character>(ch);

 for(int j=0;j<9;j++){

 if(board[i][j]!='.'){

int row=i/3;

int column=j/3;

boolean b1=temps[row][column].remove(new Character(board[i][j]));

if(!b1)

return false;

boolean b=temp.remove(new Character(board[i][j]));

if(!b)

return false;

 }

 if(board[j][i]!='.'){

boolean b=temp0.remove(new Character(board[j][i]));

if(!b)

return false;

 }

 }

 }

 

 return true;

 }

 

 

 

 

 

49Climbing Stairs

 

方法一:

 

 

方法二:

 

 

 

50Add Binary

 

 public String addBinary(String a, String b) {

 

 int len1=a.length();

 int len2=b.length();

 if(len2>len1)

 return addBinary(b, a);

 int len=len2;

 String str="";

 char flag='0';

 for(int i=0;i<len;i++){

 char ch1=a.charAt(len1-i-1);

 char ch2=b.charAt(len2-1-i);

 char temp;

 //首先和进位相加

 if(ch1=='1' && flag=='1'){

 temp='0';

 }

 else if(ch1=='1' || flag=='1'){

 temp='1';

 flag='0';

 }else{

 temp='0';

 flag='0';

 }

 //其次和对应位相加

 if(ch2=='1' && temp=='1'){

 temp='0';

 flag='1';

 }

 else if(ch2=='1' || temp=='1'){

 temp='1';

 }else{

 temp='0';

 }

 str=temp+str;

 }

 

 for(int i=len;i<len1;i++){

 char ch2=a.charAt(len1-1-i);

 if(flag=='0'){

 str=ch2+str;

 }else{

 if(ch2=='1'){

 str='0'+str;

 

 }else{

 str='1'+str;

 flag='0';

 }

 }

 }

 if(flag=='1'){

 str='1'+str;

 }

 

 

 return str;

 }

 

 

 

 

 

 

 

51Length of Last Word 

 

 

 

 

 

52Best Time to Buy and Sell Stock

 

 

 

53Best Time to Buy and Sell Stock 2

 

public int maxProfit(int[] prices) {

 if(prices==null || prices.length==0 ||prices.length==1){

 return 0;

 }

     int min=prices[0];   

     int max=0;

     int pos=1;

     int pre=prices[0];

     while(pos<prices.length){

      if(pre>prices[pos]){

      max=max+pre-min;

      min=prices[pos];

      

      }

      pre=prices[pos];

      pos++;

     }

     max+=prices[prices.length-1]-min;

     return max;

 }

 

 

 

 

√54Integer to Roman

 

 

 

 

 

 

55Find Minimum in Rotated Sorted Array

 

 

 

 

 

 

 

56Sum Root to Leaf Numbers

 

 

 

 

 

 

 

57Triangle

 

 public int minimumTotal(List<List<Integer>> triangle) {

List<Integer> nums=new ArrayList<Integer>();

List<Integer> pre=new ArrayList<Integer>();

for(int i=0;i<triangle.size();i++){

if(pre.size()==0){

pre=new ArrayList<Integer>(triangle.get(i));

}else{

List<Integer> list=triangle.get(i);

for(int k=0;k<list.size();k++){

if(k==0){

nums.add(pre.get(0)+list.get(k));

}

else if(k==list.size()-1){

nums.add(pre.get(k-1)+list.get(k));

}

else{

nums.add(Math.min(pre.get(k-1)+list.get(k), pre.get(k)+list.get(k)));

}

}

pre=new ArrayList<Integer>(nums);

nums.clear();

}

}

int sum=pre.get(0);

for(int j=1;j<pre.size();j++){

if(pre.get(j)<sum)

sum=pre.get(j);

}

return sum;

 }

 

 

 

58Binary Tree Preorder Traversal

 

 

 

59Linked List Cycle

 

 

 

 

 

 

60Linked List Cycle II

 

 

 

 

 

 

61Single Number II 

 

 

 public int singleNumber(int[] nums) {

        HashSet<Integer> garbage= new HashSet<Integer>();

        HashSet<Integer> set= new HashSet<Integer>();

 

        for(int num : nums)

            if(garbage.contains(num)){

 

            } else if( set.contains(num)){

                set.remove(num);

                garbage.add(num);

            } else{

                set.add(num);

            }

 

        return set.iterator().next();      

    }

 

 

 

 

 

 

62Populating Next Right Pointers in Each Node

 

public void connect(TreeLinkNode root) {

      

        Queue<TreeLinkNode> s=new LinkedList<TreeLinkNode>();

        int count=1;

        if(root==null || root.right==null)

         return;

        TreeLinkNode pre=root.right;

        s.offer(root.left);

        s.offer(root.right);

        root.left.next=root.right;

        while(s.size()!=0){

         count++;

         int num=count;

        

         while(num%2==0){

         if(num==2){

         num=0;

         break;

         }

         num=num/2;

         }

         TreeLinkNode node=s.poll();

         if(node.left!=null)

         s.offer(node.left);

         if(node.right!=null)

         s.offer(node.right);

         if(node.left!=null && node.right!=null)

         node.left.next=node.right;

         if(num==0){

        

         }else{

         if(node.left !=null)

         pre.next=node.left;

         }

         if(node.right!=null)

         pre=node.right;

        

        }

        

 }

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

求前K大数

寻找前k大:

1、对数组进行排序,取前k大的数O(nlgn);

2、部分排序:

对于前k个数排序,后n-k个数不排序:O(n*k)

选择排序,交换排序

对于前k个数也不排序:O(nlgk)

快速排序,将数组分成两部分,一部分大于某个数,一部分小于某个数。如果大的部分的长度>k,则取大的这里面的k大的数,如果小于,则大的全取,小的取k-大的长度个数。

 

寻找第k大:

   3、堆排序(如果数特别大,无法放入内存中的时候。O(nlgk)

k个数放入小顶堆,顶部为最小,如果新来的数比他大,则换掉,但有可能破坏顶堆的结构,需要重排,复杂度为lgk.

   4、以空间换时间

 

构建一个很大的数组,以值为下标,将数组中的值都存入,然后从后往前,直到和为k则跳出循环。

 

版权声明:本文为博主原创文章,未经博主允许不得转载。

寻找第k大数字

1003. 寻找第k大数字(numberk)
  • t6_17
  • t6_17
  • 2016年12月10日 14:20
  • 745

中位数(第k大数)快速求法

本文为twenz根据个人经验整理,转载请注明来源,谢谢! 中位数即为一系列数中的大小在中间位置的数,快速找中位数的有效方法有:1.排序法:先对数组进行排序,时间复杂度为O(nlogn),然后选择中间的...

算法设计Week12 LeetCode Algorithms Problem #62 Unique Paths

题目描述: A robot is located at the top-left corner of a m x n grid (marked ‘Start’ in the diagram bel...

[Leetcode刷题总结系列][Dynamic Programming]62. Unique Paths

Leetcode Dynamic Programming 62. Unique Paths A robot is located at the top-left corner of a m*n gr...

leetcode 算法题源代码

  • 2017年04月08日 10:03
  • 204KB
  • 下载

leetcode算法题答案PDF

  • 2016年10月14日 22:53
  • 1.54MB
  • 下载

leetcode_middle_62_75. Sort Colors

题意: 给定一个数组,数组里面有0,1,2三种数值。排序这个数组,使所有的0在最前面,之后是所有的1,再最后是所有的2 分析: 我们要对数组进行排序,就是要将旧数组变成一个新数组。从...
  • pusude
  • pusude
  • 2017年03月05日 10:32
  • 163

Java算法刷题带注释Leetcode

  • 2017年06月19日 16:41
  • 142KB
  • 下载

leetcode - 62,63. Unique Paths(II) & 64.Minimum Path Sum

算法系列博客之Dynamic Programming 本篇博客将运用动态规划的思想来解决leetcode上264号问题这三个题目的共同之处在于均是二维矩阵上的规划问题问题描述:62 Unique Pa...
  • Quiteen
  • Quiteen
  • 2017年06月11日 20:40
  • 134

Leetcode62 Unique Paths

Unique Paths A robot is located at the top-left corner of a m x n grid (marked ‘Start’ in the diag...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【leetcode算法】更新至62题
举报原因:
原因补充:

(最多只允许输入30个字)