蓝桥杯刷题JAVA（3）

1. 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

class Solution {
    public int removeElement(int[] nums, int val) {
        if(nums.length == 0)
            return 0;
        if(nums.length == 1)
            if(nums[0] == val)
                return 0;
            else
                return 1;
        int length = 0;
        
        for(int index = 0; index < nums.length; index++)
            if(nums[index] != val)
                nums[length++] = nums[index];
        return length;
    }
}

经验：
此处的length返回与之前那题不同，需要思考后输出。

2.实现strStr

实现 strStr() 函数。
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

class Solution {
    public int strStr(String haystack, String needle) {
        return haystack.indexOf(needle);
    }
}

本意应当是KMP。。然而调内置函数就解决了。。

3.搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。

class Solution {
    public int searchInsert(int[] nums, int target) {
        if(target < nums[0])
            return 0;
        for(int i = 0; i < nums.length; i++){
            if(target == nums[i])
                return i;
            if(target > nums[i] && i + 1 < nums.length && target < nums[i + 1])
                return i + 1;
        }
        return nums.length;
    }
}

经验：
注意头尾以及短路逻辑

4.外观数列

class Solution {
    public String countAndSay(int n) {
        if(n == 1)
        	return "1";
        if(n == 2)
        	return "11";
        if(n == 3)
        	return "21";
        String  targetString = countAndSay(n - 1);
        String[] splitstringarray = new String[targetString.length() * 2];
        for(int i = 0; i < splitstringarray.length; i++)
        	splitstringarray[i] = new String();
        int count = 0;
        char flag = targetString.charAt(0);
        int flagindex = 0;
        for(int i = 0; i < targetString.length(); i++) {
        	if(flag != targetString.charAt(i) && i != targetString.length() - 1) {
        		splitstringarray[count++] = targetString.substring(flagindex, i);
        		flag = targetString.charAt(i);
        		flagindex = i;
        	}else if(flag != targetString.charAt(i) && i == targetString.length() - 1) {
        		splitstringarray[count++] = targetString.substring(flagindex, i);
        		splitstringarray[count++] = targetString.substring(i);
        	}
        	else if(flag == targetString.charAt(i) && i == targetString.length() - 1)
        		splitstringarray[count++] = targetString.substring(flagindex);
        	
        }
        
        String resultString = new String();
        for(int i = 0; i < count; i++) {
        	resultString = resultString.concat(String.valueOf(splitstringarray[i].length()));
        	resultString = resultString.concat(String.valueOf(splitstringarray[i].charAt(0)));
        }
        return resultString;
    }
}

经验：
事实上不需要用splitstringarray来装载最后再统计，直接在遍历的过程中就可以处理掉了，还会省略很多恶心的bug（譬如指针越界，溢出等问题），这样子就可以沈略掉很多初始化的时候存在的bug了，尤其是nullpointerexception。

5.最大子序列和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

class Solution {
    public int maxSubArray(int[] nums) {
    	int res = 0;
    	int max = -100001;
    	for(int i = 0; i < nums.length; i++) {
    		res += nums[i];
    		if(res > max)
    			max = res;
    		if(res < 0)
    			res = 0;
    	}
    	return max;
    }
}

class Solution(object):
	//DP，原数组上操作
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
         """
        for i in range(1, len(nums)):
            nums[i]= nums[i] + max(nums[i-1], 0)
        return max(nums)

经验：
DP思想，负值不加入连续子序列即为0。

6.最后一个单词

给你一个字符串 s，由若干单词组成，单词之间用空格隔开。返回字符串中最后一个单词的长度。如果不存在最后一个单词，请返回 0 。
单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。

class Solution {
    public int lengthOfLastWord(String s) {
    	String[] splitStrings = s.split(" ");
    	if(splitStrings.length == 0)
    		return 0;
    	else 
			return splitStrings[splitStrings.length - 1].length();
    }
}

class Solution {
    public int lengthOfLastWord(String s) {
        int length = 0;
        for (int i = s.length() - 1; i >= 0; i--) {
            if (s.charAt(i) != ' ') {
                length++;
            } else if (length != 0) {
                return length;
            }
        }
        return length;
    }
}

经验：
年轻的人还在倒序遍历找，直接split冲锋完事儿。第二版本的代码可以判断尾部空格，比较巧妙

7.加一

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。

class Solution {
    public int[] plusOne(int[] digits) {
    	if(digits.length == 1 && digits[0] != 9)
    		return new int[] {digits[0] + 1};
    	else if(digits.length == 1 && digits[0] == 9)
    		return new int[] {1, 0};
        int alert = 0;
    	int i = digits.length - 1;
    	digits[i] = (digits[i] + 1) % 10;
    	if(digits[i] == 0)
			alert = 1;
		else
			alert = 0;
    	i--;
    	while (alert > 0 && i >= 0) {
    		digits[i] = (digits[i] + alert) % 10;
        	if(digits[i] == 0) {
        		alert = 1;
        		i--;
        	}else
    			alert = 0;        	
		}
    	if(i < 0) {
    		int[] newarray = new int[digits.length + 1];
    		for(int ii = 1; ii < digits.length + 1; ii++)
    			newarray[ii] = digits[ii - 1];
    		newarray[0] = 1;
    		return newarray;
    	}else {
			return digits;
		}
    }
}

经验：
自己的算法个位数易出错，虽然时间和空间上效果可观。
改进会明白这个alert是没有意义的，因为如果不进位直接返回结果即可，只要循环遍历一直在执行就说明一定有进位产生，因此直接加1即可。