342. Power of Four
Given an integer (signed 32 bits), write a function to check whether it is a power of 4.
Example:
Given num = 16, return true.
Given num = 5, return false.
public class Solution {
public boolean isPowerOfFour(int num) {
if(num==0)
return false;
while(num%4==0){
num = num>>2;
}
if(num==1)
return true;
return false;
}
}
326. Power of Three
Given an integer, write a function to determine if it is a power of three.
Follow up:
Could you do it without using any loop / recursion?
public class Solution {
public boolean isPowerOfThree(int num) {
if(num==0)
return false;
while(num%3==0){
num = num/3;
}
if(num==1)
return true;
return false;
}
}
231. Power of Two
Given an integer, write a function to determine if it is a power of two.
public class Solution {
public boolean isPowerOfTwo(int n) {
if(n==0)
return false;
while(n%2==0){
n = n>>1;
}
if(n==1)
return true;
return false;
}
}
349. Intersection of Two Arrays
Given two arrays, write a function to compute their intersection.
Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].
Note:
- Each element in the result must be unique.
- The result can be in any order.
思路：使用一个BitSet集合存放一个数组数据，之后再用另一个数组与其比较，把集合中有的数据放入返回的数组中
import java.util.Arrays;
import java.util.BitSet; public class Solution { /**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int nums1[] = {1,2,3,2,4,2,5,2};
int nums2[] = {2,3,5,6};
int num[] = intersection(nums1, nums2);
for(int i=0;i<num.length;i++){
System.out.print(num[i]+" ");
}
} public static int[] intersection(int[] nums1, int[] nums2) {
if(nums1.length==0||nums2.length==0)
return new int[0];
int len1 = nums1.length;
int len2 = nums2.length;
int[] result = new int[Math.min(len1, len2)];
BitSet set = new BitSet();
for(int i=0;i<len1;i++){
set.set(nums1[i]);
}
int k = 0;
for(int j=0;j<len2;j++){
if(set.get(nums2[j])){
result[k++] = nums2[j];
set.set(nums2[j], false);
}
}
return Arrays.copyOfRange(result, 0, k);
} }
349. Intersection of Two Arrays
Given two arrays, write a function to compute their intersection.
Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].
思路：使用hashset去重nums1，在对nums2去重时，同时过滤nums1中的数
import java.util.*;
public class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
Set<Integer> set = new HashSet<Integer>();
Set<Integer> insect = new HashSet<Integer>();
for(int i=0;i<nums1.length;i++){
set.add(nums1[i]);
}
for(int i=0;i<nums2.length;i++){
if(set.contains(nums2[i])){
insect.add(nums2[i]);
}
}
int[] res = new int[insect.size()];
int i=0;
for(Integer num : insect){
res[i++] = num;
}
return res;
}
}
137. Single Number II
Given an array of integers, every element appears three times except for one. Find that single one.
Note:
Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
思路：先排序
1）当只有一个数时，直接return；
2）当刚好四个数时，两种情况-->第一个数或最后一个数；
3）>4个数时，三种情况：a.第一个数；b.最后一个数；c.循环中部查找；
public class Solution {
public int singleNumber(int[] nums) {
Arrays.sort(nums);
if(nums.length==1)
return nums[0];
if(nums.length==4){
if(nums[0]==nums[1]){
return nums[3];
}else{
return nums[0];
}
}
if(nums[0]!=nums[1])
return nums[0];
if(nums[nums.length-1]!=nums[nums.length-2])
return nums[nums.length-1];
for(int i=1;i<nums.length-1;i++){
if(nums[i]!=nums[i-1]&&nums[i]!=nums[i+1]){
return nums[i];
}
}
return -1;
}
}
260. Single Number III
Given an array of numbers nums, in which exactly two elements appear only once and all the other elements appear exactly twice. Find the two elements that appear only once.
For example:
Given nums = [1, 2, 1, 3, 2, 5], return [3, 5].
Note:
- The order of the result is not important. So in the above example,
[5, 3]is also correct. - Your algorithm should run in linear runtime complexity. Could you implement it using only constant space complexity?
169. Majority Element
Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.
You may assume that the array is non-empty and the majority element always exist in the array.
思路1（笨办法）：1）考虑数组为空，则直接返回-1；
2）数组只有一个时，则返回该数；
3）其他，先排序，再将数组长度切成两半：n/2，再循环判断i对应的数是否等于n/2+i所对应的数，如果存在，则直接返回nums[i]，否则返回-1；
public class Solution {
public int majorityElement(int[] nums) {
if(nums.length==0||nums==null)
return -1;
Arrays.sort(nums);
int len = nums.length;
for(int i=0;i<len-len/2;i++){
if(nums[i]==nums[len/2+i]){
return nums[i];
}
}
return -1;
}
}
思路2：1）隐含：数组中有一个数字出现的次数超过了数组长度的一半，则如果对数组进行排序，那么排序后位于数组中间的数字一定就是那个出现次数超过数组长度一般的数字；
2）使用快排的partition函数来辅助，如果partition函数返回的index>middle，则中位在左边，若index<middle，则中位在右边；
3）最后统计middle所对应的数出现的次数是否超过一半，超过则返回，否则返回-1；
思路3：数组中有一个数字出现的次数超过数组的一半，则该数出现的次数超过其他数字出现的次数；因此遍历数组时，保存两个值：一个是数组中的一个数字，一个是次数；
1）当我们遍历到下一个数字时，如果下一次遍历的数字与保存的数字相同，则次数加1，否则次数减1，当次数减为0时，保存下一个数字；
public class Solution {
public int majorityElement(int[] nums) {
if(nums==null||nums.length==0)
return -1;
int number = nums[0];
int count = 1;
for(int i=1;i<nums.length;i++){
if(count==0){
number = nums[i];
count = 1;
}else if(nums[i]==number){
count++;
}else{
count--;
}
}
return number;
}
}
229. Majority Element II
Given an integer array of size n, find all elements that appear more than ⌊ n/3 ⌋ times. The algorithm should run in linear time and in O(1) space.
217. Contains Duplicate
Given an array of integers, find if the array contains any duplicates. Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.
思路：1）考虑数组为空时，return false；
2）考虑数组长度为1或0时，return false；
3）将数组进行排序，再比较相邻的两个数，如果相等，则return true，否则return fasle；
public class Solution {
public boolean containsDuplicate(int[] nums) {
if(nums==null||nums.length<=1)
return false;
Arrays.sort(nums);
for(int i=1;i<nums.length;i++){
if(nums[i-1]==nums[i]){
return true;
}
}
return false;
}
}
219. Contains Duplicate II
Given an array of integers and an integer k, find out whether there are two distinct indices i and j in the array such that nums[i] = nums[j]and the difference between i and j is at most k.
202. Happy Number
Write an algorithm to determine if a number is "happy".
A happy number is a number defined by the following process: Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers.
Example: 19 is a happy number
思路：使用一个HashSet来保存每一次平方和的结果，如果HashSet添加时有相同的数时，直接返回false(因为进入了死循环)，直到结果为1结束，返回true。
public static boolean isHappy(int n){
if(n==0)
return false;
HashSet<Integer> set = new HashSet<Integer>();
while(n!=1){
n = sumOfSquar(n);
if(!set.add(n)){
return false;
}
set.add(n);
}
return true;
}
// public static boolean isHappy(int n) {
// if(n==0)
// return false;
//
// while(n!=1&&n!=4){
// n = sumOfSquar(n);
// }
// return (n==1)?true:false;
// }
public static int sumOfSquar(int n){
int m = 0;
int sum = 0;
while(n!=0){
m = (n%10);
sum += m*m;
n = n/10;
}
return sum;
}