1 两数之和
public int[] twoSum(int[] nums, int target) {
int[] answer=new int[2];
int a;
HashMap<Integer,Integer> map=new HashMap<Integer, Integer>();
for(int i=0;i<nums.length;i++){
a=target-nums[i];
if(map.containsKey(a)){
answer[0]=i;
answer[1]=map.get(a);
}
map.put(nums[i],i);
}
return answer;
}
13 罗马到整数
public int romanToInt(String s) {
if(s==null||s.length()==0)
return 0;
HashMap<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 n=map.get(s.charAt(0));
for(int i=1;i<s.length();i++){
if(map.get(s.charAt(i))>map.get(s.charAt(i-1))){
n=n+map.get(s.charAt(i))-2*map.get(s.charAt(i-1));//加一减二
}
else
n=n+map.get(s.charAt(i));
}
return n;
}9.回文数
public boolean isPalindrome(int x) {
if(x>0){
return false;
}
int a=0,b=x;
while(b>0){
a=a*10+b%10;//反向赋值
b/=10;
}
if(a==x)
return true;
else
return false;
}14.最长公共前缀
public String longestCommonPrefix(String[] strs) {
if(strs.length==0)
return "";
String prefix =strs[0];
for(int i = 1;i<strs.length;i++){
while(strs[i].indexOf(prefix)!=0){//不存在返回-1
prefix=prefix.substring(0,prefix.length()-1);//去掉一位再比较
}
}
return prefix;
}21.合并链表
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode l=new ListNode(0);//设头结点方便处理
ListNode first=l;
while(l1!=null&&l2!=null){
if(l1.val<l2.val){
l.next=l1;
l1=l1.next;
}else{
l.next=l2;
l2=l2.next;
}
l=l.next;//指向链尾
}
if(l1!=null)
l.next=l1;
if(l2!=null)
l.next=l2;
return first.next;
}26.有序数组去重
不需要考虑数组中超出新长度后面的元素
public int removeDuplicates(int[] A) {
if(A.length == 0) {
return 0;
}
if(A.length == 1) {
return 1;
}
int index = 0;
for(int i = 1; i < A.length; ++i) {
if(A[i] != A[index]) {//不相等则覆盖
++index;
A[index] = A[i];
}
}
return index + 1;
}28. Implement strStr()
实现String的indexOf（）方法
public int strStr(String haystack, String needle) {
if(needle==null||needle.equals(""))
return 0;
int n=haystack.length();
int m=needle.length();
if(m>n) return -1;
for(int i=0;i<=n-m;i++){//后面的没必要比较
int j=0;
for(;j<m;j++){
if(haystack.charAt(i+j)!=needle.charAt(j))
break;
}
if(j==m) return i;
}
return -1;
}35. Search Insert Position
public int searchInsert(int[] nums, int target) {
int l=0,r=nums.length-1, mid=0; //注意边界条件
while(l<=r){
mid=(l+r)/2;
if(nums[mid]>target){
r=mid-1;}
else if(nums[mid]<target){
l=mid+1;}
else{
return mid;}
}
if(nums[mid]<target) return mid+1;
return mid;
}53. Maximum Subarray 子数组最大和
public int maxSubArray(int[] nums) {
int sum=nums[0],n=sum; //初始化第一个值
for(int i=1;i<nums.length;i++){
if(n>=0){
n=n+nums[i];
}else n=nums[i];//小于0直接等于下一个数
if(n>sum) sum=n;
}
return sum;
}58. Length of Last Word
public int lengthOfLastWord(String s) {
if(s==null||s.equals("")||s.equals(" ")){
return 0;
}
int n=0,l=s.length()-1;
while(l>=0&&s.charAt(l)==' '){
l--;
}
while(l>=0&&s.charAt(l)!=' '){
l--;
n++;
}
return n;
}69. Sqrt(x)
public int mySqrt(int x) {
double l=Math.sqrt(x);
int a=(int)Math.floor(l);//去小数
return a;
}88. Merge Sorted Array
多判断条件用while
public void merge(int[] nums1, int m, int[] nums2, int n) {
while(m>0&&n>0){
if(nums1[m-1]>nums2[n-1]){
nums1[m+n-1]=nums1[m-1];
m--;
}else{
nums1[m+n-1]=nums2[n-1];
n--;
}
}
while(n>0){ //剩下的小的放最前面
nums1[m+n-1]=nums2[n-1];
n--;
}
}100. Same Tree
public boolean isSameTree(TreeNode root1, TreeNode root2) {
if (root1 == null && root2 == null) {
return true;
}
if ((root1 == null && root2 != null) || (root1 != null && root2 == null)) {
return false;
}
if (root1.val != root2.val) {//判断每个节点的值是否相等，如果去除此判断，则判断两个二叉树是否结构相等
return false;
}
return isSameTree(root1.left, root2.left) && isSameTree(root1.right, root2.right);
}101. Symmetric Tree
class Solution {
public boolean isSymmetric(TreeNode root) {
if(root==null)
return true;
return isSameTree(root.left,root.right);//比较左右子树是否为镜像
}
public boolean isSameTree(TreeNode root1, TreeNode root2) {
if (root1 == null && root2 == null) {
return true;
}
if ((root1 == null && root2 != null) || (root1 != null && root2 == null)) {
return false;
}
if (root1.val != root2.val) {//判断每个节点的值是否相等，如果去除此判断，则判断两个二叉树是否结构相等
return false;
}
return isSameTree(root1.left, root2.right) && isSameTree(root1.right, root2.left);
}
}104. Maximum Depth of Binary Tree
public int maxDepth(TreeNode root) {
if(root==null)
return 0;
int l=maxDepth(root.left);
int r=maxDepth(root.right);
return (l>r)? l+1:r+1;
}110. Balanced Binary Tree
class Solution {
public boolean isBalanced(TreeNode root) {
if(root==null) return true;
if(Math.abs(maxDepth(root.left)-maxDepth(root.right))>1) return false;
return isBalanced(root.left)&&isBalanced(root.right);
}
public int maxDepth(TreeNode root) {
if(root==null)
return 0;
int l=maxDepth(root.left);
int r=maxDepth(root.right);
return (l>r)? l+1:r+1;
}
}111. Minimum Depth of Binary Tree
public int minDepth(TreeNode root) {
if (root == null) return 0;
if (root.left == null && root.right == null) return 1;
int left, right;
if (root.left != null) left = minDepth(root.left);
else left = Integer.MAX_VALUE; //不存在设为最大，逆向思维
if (root.right != null) right = minDepth(root.right);
else right = Integer.MAX_VALUE;
return Math.min(left, right) + 1;
}112. Path Sum
给定二叉树和求和，确定树是否具有根到叶路径，使得沿路径的所有值相加等于给定的总和。
public boolean hasPathSum(TreeNode root, int sum) {
if(root==null) return false;
if(root.val==sum&&root.right==null&&root.left==null) return true;//判断是否满足叶子节点
return hasPathSum(root.left,sum-root.val)||hasPathSum(root.right,sum-root.val);
}118. Pascal's Triangle
List的set（）方法要设置数值的位置不能为空。
public List<List<Integer>> generate(int numRows) {
List<List<Integer>> cur=new ArrayList<>();
for(int i=0;i<numRows;i++){
List<Integer> l=new ArrayList<>();
l.add(1);
if(i>1){ //从第三排开始
for(int j=1;j<i;j++){
List<Integer> t=cur.get(i-1);
l.add(t.get(j-1)+t.get(j));
}
}
if(i>0)
l.add(1);
cur.add(l);
}
return cur;
}121. Best Time to Buy and Sell Stock
维护一个min变量存储当前遇到的最低股价，维护一个money存储当前可能的最大利润（用当前股价减去min），一次顺序遍历数组最后返回money
public int maxProfit(int[] prices) {
if(prices==null||prices.length==0) return 0;//考虑数值为空
int min=prices[0],money=0;
for(int i=1;i<prices.length;i++){
if(money<prices[i]-min) money=prices[i]-min;
if(prices[i]<min) min=prices[i];
}
return money;
}122. Best Time to Buy and Sell Stock II
贪心算法
public int maxProfit(int[] prices) {
int money=0;
for(int i=0;i<prices.length-1;i++){
if(prices[i]<prices[i+1])
money+=prices[i+1]-prices[i];
}
return money;
}136. Single Number
交换律a ^ b = b ^ a，性质2：0 ^ a = a
public int singleNumber(int[] nums) {
int n=0;
for(int i=0;i<nums.length;i++){
n^=nums[i];
}
return n;
}141. Linked List Cycle
public boolean hasCycle(ListNode head) {
if(head==null||head.next==null) return false;
ListNode p=head;
ListNode q=head;
while(p!=null&&q!=null&&q.next!=null){ //如果不存在快指针为null
p=p.next;
q=q.next.next;
if(p==q) return true;
}
return false;
}160. Intersection of Two Linked Lists
让两条链表分别从各自的开头开始往后遍历，当其中一条遍历到末尾时，我们跳到另一个条链表的开头继续遍历。两个指针最终会相等，而且只有两种情况，一种情况是在交点处相遇，另一种情况是在各自的末尾的空节点处相等。为什么一定会相等呢，因为两个指针走过的路程相同，是两个链表的长度之和，所以一定会相等。
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if(headA==null||headB==null) return null;
ListNode p=headA;
ListNode q=headB;
while(p!=q){
p=(p==null)?headB:p.next;
q=(q==null)?headA:q.next;
}
return p;
}168. Excel Sheet Column Title
实质是十进制换成26进制
public String convertToTitle(int n) {
String s = "";
while (n != 0) {
int temp = (n-1) % 26;
s = (char) ('A' + temp) + s;
n = (n-1) / 26;
}
return s;
}
public void binaryToDecimal(int n){//转二进制
String str = "";
while(n!=0){
str = n%2+str;
n = n/2;
}
System.out.println(str);
}169. Majority Element
给定大小为n的数组，找到多数元素。多数元素是出现次数多 的元素⌊ n/2 ⌋。
您可以假设该数组非空，并且多数元素始终存在于数组中。
public int majorityElement(int[] nums) {
int n=1,a=nums[0];
for(int i=1;i<nums.length;i++){
if(n==0){
a=nums[i];
n=1;
continue;
}
if(a!=nums[i]){
n--;
}else{
n++;
}
}
return a;
}解法二
class Solution {
public int majorityElement(int[] nums) {
Arrays.sort(nums);
return nums[nums.length/2];
}
}
172. Factorial Trailing Zeroes
给定一个整数n，返回n！中的尾随零的数量。
public int trailingZeroes(int n) {
int count = 0;
while (n != 0) {
count += n / 5;
n /= 5;
}
return count;
}190. Reverse Bits
public int reverseBits(int n) {
int v=0;
for(int i=0;i<32;i++){
if((n&1)==1){
v=(v<<1)+1;+优先级比较高
n>>=1;
}else{
v=v<<1;
n>>=1;
}
}
return v;
}191. Number of 1 Bits
每一次循环消去最低为的1
public int hammingWeight(int n) {
int i=0;
while(n!=0){
i++;
n=n&(n-1);
}
return i;
}198. House Robber
假设dp[i]是截止到nums[i]为止能抢到的最多的钱，那么它要么是抢nums[i]，要么不抢。如果抢，那就是dp[i-2] + nums[i]，如果不抢，那就是dp[i-1]，二者取最大值。
public int rob(int[] nums) {
if(nums==null||nums.length==0) return 0;
if(nums.length==1) return nums[0];
int p2=nums[0];
int p1=Math.max(p2,nums[1]);
int p=p1;
for(int i=2;i<nums.length;i++){
p=Math.max(p2+nums[i],p1);
p2=p1;
p1=p;
}
return p;
}202. Happy Number
public boolean isHappy(int n) {
HashSet<Integer> set=new HashSet<Integer>();
int sum,t;
while(!set.contains(n)){//不存在说明没有重复
set.add(n);
sum=0;
while(n>0){
t=n%10;
sum+=t*t;
n/=10;
}
if(sum==1) return true;
n=sum;
}
return false;
}203. Remove Linked List Elements
Input: 1->2->6->3->4->5->6, val = 6
Output: 1->2->3->4->5设置头结点方便处理，链表要注意表头表尾的处理
public ListNode removeElements(ListNode head, int val) {
ListNode p=new ListNode(Integer.MAX_VALUE);
p.next=head;
ListNode l=p;
ListNode q=head;
while(p!=null&&q!=null){
if(q.val==val){
p.next=q.next;
q=q.next;
}else{
p=p.next;
q=q.next;
}
}
return l.next;
}204. Count Primes
计算小于非负数n的素数的数量。
public int countPrimes(int n) {
if(n<=1) return 0;
boolean[] NotPrime=new boolean[n];
NotPrime[0]=true;
NotPrime[1]=true;
for(int i=0;i<Math.sqrt(n);i++){
if(!NotPrime[i]){
for(int j=2*i;j<n;j+=i){//将质数的倍数设为true
NotPrime[j]=true;
}
}
}
int m=0;
for(boolean b:NotPrime){
if(b==false) m++;
}
return m;
}205. Isomorphic Strings
给定两个字符串s和t，确定它们是否是同构的。
如果s中的字符可以替换为t，则两个字符串是同构的。
在保留字符顺序的同时，必须用另一个字符替换所有出现的字符。没有两个字符可以映射到相同的字符，但字符可以映射到自身。
输入： s = "egg", t ="add"
输出： true建一个map保存映射关系, 同时用一个set保持 被映射的char, 保证同一个char 不会被映射两次.
public boolean isIsomorphic(String s, String t) {
if (s == null && t == null) {
return true;
}
// 只有一个为空
else if (s == null || t == null) {
return false;
}
// 两个字符串的长度都为0
else if (s.length() == 0 && t.length() == 0) {
return true;
}
// 两个字符串的长度不相等
else if (s.length() != t.length()) {
return false;
}
HashMap<Character,Character> map=new HashMap<Character,Character>(26);
HashSet<Character> set=new HashSet<Character>();
for(int i=0;i<s.length();i++){
if(map.containsKey(s.charAt(i))){
if(map.get(s.charAt(i))!=t.charAt(i))
return false;
}else{
if(set.contains(t.charAt(i))){
return false;
}
set.add(t.charAt(i));
map.put(s.charAt(i),t.charAt(i));
}
}
return true;
}206. Reverse Linked List
public ListNode reverseList(ListNode head) {
if(head==null) return null;
ListNode p=head;//三个指针
ListNode q=head.next;
ListNode r;
p.next=null;
while(q!=null){
r=q.next;
q.next=p;
p=q;
q=r;
}
return p;
}217. Contains Duplicate
public boolean containsDuplicate(int[] nums) {
HashSet<Integer> set=new HashSet();//使用SET的不重复性
for(int i=0;i<nums.length;i++){
if(set.contains(nums[i])) return true;
set.add(nums[i]);
}
return false;
}219. Contains Duplicate II
给定一个整数数组和一个整数k，找出数组中是否存在两个不同的索引i和j，使得nums [i] = nums [j]并且i和j之间的绝对差值最多为k
输入： nums = [1,2,3,1]，k = 3
输出：truepublic boolean containsNearbyDuplicate(int[] nums, int k) {
if(nums==null||k<=0||nums.length==0) return false;
HashMap<Integer,Integer> map=new HashMap();
for(int i=0;i<nums.length;i++){
if(map.containsKey(nums[i])){
if(i-map.get(nums[i])<=k) return true;
else{
map.remove(nums[i]);//重新覆盖k—v键值对
map.put(nums[i],i);
}
}else{
map.put(nums[i],i);
}
}
return false;
}226. Invert Binary Tree 构造镜像树
public TreeNode invertTree(TreeNode root) {
if(root==null) return null;
TreeNode t=root.left;
root.left=root.right;
root.right=t;
invertTree(root.right);
invertTree(root.left);
return root;
}
231. Power of Two
给定一个整数，写一个函数来确定它是否是2的幂。
public boolean isPowerOfTwo(int n) {
if(n<=0) return false;
while(n>1){
if((n&1)==1)
return false;
n>>=1; //n=n>>1;
}
return true;
} public boolean isPowerOfTwo(int n) {
if(n<=0)
return false;
return (n&(n-1))==0;
}
>>> : 无符号右移，忽略符号位，空位都以0补齐
public boolean isPowerOfThree(int n) {
if(n==0) return false;
while(n!=1){
if(n%3!=0) return false;//不整除三不是三的幂次方
n/=3;
}
return true;
}235. Lowest Common Ancestor of a Binary Search Tree
根据搜索树左小右大的特性
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
int rv=root.val;
int pv=p.val;
int qv=q.val;
if(pv>rv&&qv>rv){
return lowestCommonAncestor(root.right,p,q);
}else if(pv<rv&&qv<rv){
return lowestCommonAncestor(root.left,p,q);
}else return root;
}242. Valid Anagram
判断字符串同构；
public boolean isAnagram(String s, String t) {
char[] a=s.toCharArray();
char[] b=t.toCharArray();
Arrays.sort(a);
Arrays.sort(b);
return Arrays.equals(a,b);//使用Arrays.equals()比较内容；
}257. Binary Tree Paths
打印根到叶子节点的路径。
解耦，一个方法一个功能。递归不需要每次创建的属性可以考虑充当形参
public List<String> binaryTreePaths(TreeNode root) {
List<String> l=new ArrayList<String>();
add(l,root,"");
return l;
}
public void add(List<String> l,TreeNode t,String s){
if(t==null) return;
s+=t.val;
if(t.left!=null) add(l,t.left,s+"->");
if(t.right!=null) add(l,t.right,s+"->");
if(t.left==null&&t.right==null) l.add(s);
}263. Ugly Number
注意交换律
public boolean isUgly(int num) {
if(num<=0) return false;
while(num%2==0){//循环除2,3,5，最后判断是否等于一
num>>=1;
}
while(num%3==0){
num/=3;
}
while(num%5==0){
num/=5;
}
return num==1;
}278. First Bad Version
public int firstBadVersion(int n) {
int l=1;
int r=n;
int mid;
while(l<r){
mid=l+(r-l)/2;
if(isBadVersion(mid))
r=mid;
else l=mid+1;
}
return l;
}
扫一扫
350
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
