我的顺序是从最简单开始,速度是一天2道(18.3.22start-),都是以自己最low想法来随意写,以后补充优化。
一、easy
title 108:将有序数组转为二叉搜索树
public class title108 {
public TreeNode sortedArrayToBST(int[] nums) {
TreeNode root = createTree(nums,0,nums.length-1);
return root;
}
private TreeNode createTree(int[] nums,int left,int right){
if(left > right){
return null;
}
int mid = (left + right) / 2;
TreeNode root = new TreeNode(nums[mid]);
root.left = createTree(nums,left,mid-1);
root.right = createTree(nums,mid+1,right);
return root;
}
}
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
title 504:十进制转7进制
public class title504 {
public String convertToBase7(int num) {
StringBuffer res = new StringBuffer();
if(num < 0){
num = Math.abs(num);
res.append("-");
}
int max = getMax(num);
System.out.println("max="+max);
while(max >= 0){
int cur = (int)(num / Math.pow(7,max));
num -= cur * Math.pow(7,max);
System.out.println("cur="+cur);
res.append(cur);
max--;
}
return res.toString();
}
private int getMax(int num){
int res = 0;
int sum = 7;
while(sum <= num){
sum = sum * 7;
res++;
}
return res;
}
public static void main(String[] args){
title504 test = new title504();
System.out.println(test.convertToBase7(-7));
}
}
优化一下:
title 541:反转字符串
public String reverseStr(String s, int k) {
StringBuilder res = new StringBuilder();
int len = s.length();
while(len > 0) {
if(len >= 2*k) {
res.append(getReverse(s.substring(0, 2*k), k));
}else{
res.append(getReverse(s,k));
break;
}
s = s.substring(2*k);
len = s.length();
}
return res.toString();
}
private String getReverse(String str,int k){
int len = str.length();
if(len > k){
String tmp = str.substring(0,k);
str = new StringBuffer(tmp).reverse().append(str.substring(k)).toString();
}else if(len <= k){
str = new StringBuffer(str).reverse().toString();
}
return str;
}
public static void main(String[] args){
title541 test = new title541();
System.out.println(test.reverseStr("absdhcgeowmfrg",2));
}
优化一下:
title 746:每次只能上1个或者2个台阶,每个台阶有cost,求上到顶端的最小代价
public int minCostClimbingStairs(int[] cost) {
int length = cost.length + 1;
int dp0 = 0;
int dp1 = 0;
int dp2 = 0;
for (int i = 2; i < length; i++) {
dp2 = Math.min(dp0 + cost[i - 2] , dp1 + cost[i - 1]);
dp0 = dp1;
dp1 = dp2;
}
return dp2;
}
title 350:返回两个数组的交集,与顺序无关。
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
if(nums1.length == 0 || nums2.length == 0){
return new int[]{};
}
List<Integer> cur = new ArrayList<Integer>();
quickSortArr(nums1,0,nums1.length-1);
quickSortArr(nums2,0,nums2.length-1);
int len1 = nums1.length;
int len2 = nums2.length;
int i = 0;
int j = 0;
while(i < len1 && j < len2){
if(nums1[i] == nums2[j]){
cur.add(nums1[i]);
i++;
j++;
}else if(nums1[i] > nums2[j]){
j++;
}else{
i++;
}
}
int[] res = new int[cur.size()];
for(int index = 0; index < cur.size();index++){
res[index] = cur.get(index);
}
return res;
}
private void quickSortArr(int[] arr,int left,int right){
if(left > right){
return;
}
int key = arr[left];
int i = left;
int j = right;
while(i < j){
while(i < j && arr[j] > key){
j--;
}
while(i < j && arr[i] <= key){
i++;
}
if(i < j){
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
int t = arr[i];
arr[i] = arr[left];
arr[left] = t;
quickSortArr(arr,left,i-1);
quickSortArr(arr,i+1,right);
}
}
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
if(nums1.length == 0 || nums2.length == 0){
return new int[]{};
}
List<Integer> cur = new ArrayList<Integer>();
Arrays.sort(nums1);
Arrays.sort(nums2);
int len1 = nums1.length;
int len2 = nums2.length;
int i = 0;
int j = 0;
while(i < len1 && j < len2){
if(nums1[i] == nums2[j]){
cur.add(nums1[i]);
i++;
j++;
}else if(nums1[i] > nums2[j]){
j++;
}else{
i++;
}
}
int[] res = new int[cur.size()];
for(int index = 0; index < cur.size();index++){
res[index] = cur.get(index);
}
return res;
}
}
title 121:给一个价值数组,求出一次买入一次卖出后的最高收益;
public int maxProfit(int[] prices) {
if(prices.length < 1){
return 0;
}
int min = prices[0];
int profit = 0;
int len = prices.length;
for(int i = 1; i < len; i++){
if(min > prices[i]){
min = prices[i];
}else{
if(profit < prices[i] - min){
profit = prices[i] - min;
}
}
}
return profit;
}
title 674:给一个无序数组,返回数组中最长自增序列长度;
public int findLengthOfLCIS(int[] nums) {
if(nums.length == 0){
return 0;
}
int count = 1;
int cur = nums[0];
int max = 1;
for(int i = 1; i < nums.length;i++){
if(nums[i] > cur){
count++;
}else {
max = count > max ? count : max;
count=1;
}
cur = nums[i];
}
max = count > max ? count : max;
return max;
}
title 107:自下向上将二叉树节点值放在数组中,一层一个list;
public List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> traversal = new ArrayList<List<Integer>>();
if(root == null) return traversal;
LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
queue.add(root);
while(!queue.isEmpty()) {
int levelLen = queue.size();
List<Integer> levelNodes = new ArrayList<Integer>();
for (int i = 0; i < levelLen; i++) {
TreeNode node = queue.removeFirst();
levelNodes.add(node.val);
if(node.left != null) queue.add(node.left);
if(node.right != null) queue.add(node.right);
}
traversal.add(0, levelNodes); //*头插法 和正常层次遍历的不同
}
return traversal;
}
title 747:判断一个有最大数的数组的最大值是否比其他值的2倍还大,也就是比第二大的数的2倍还大;
public int dominantIndex(int[] nums) {
if(nums.length == 0){
return -1;
}
if(nums.length == 1){
return 0;
}
int index = 0;
int max = nums[0];
int submax = nums[0];
int len = nums.length;
int count = 1;
for(int i = 1; i < len;i++){
if(max < nums[i]){
submax = max;
max = nums[i];
index = i;
count = 1;
}else if(max == nums[i]){
count++;
}else{
if(submax == max){
submax = nums[i];
continue;
}
if(submax < nums[i]){
submax = nums[i];
}
}
}
if(max >= 2*submax && count < 2){
return index;
}
return -1;
}
title 458:有1000个瓶子里有一个有毒药,15分钟毒药生效,需要多少头小猪才能在1小时内确定哪一个是毒药?
public int poorPigs(int buckets, int minutesToDie, int minutesToTest) {
int res = 0;
while(Math.pow((minutesToTest/minutesToDie + 1),res) < buckets){
res++;
}
return res;
}
title 415:求两个只包含数字的字符串的和。