简单题目汇总

1.最长公共子串

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if(strs.length == 0) 
            return "";
        String ans = strs[0];  //将第一个字符串当作ans
        for(int i =1;i<strs.length;i++) {
            int j=0;
            //看一下这两个字符擦串里面的有多少个元素是一样的，不一样就截至循环
            //循环结束时，j不算在里面。所以是不包含第j个元素的
            for(;j<ans.length() && j < strs[i].length();j++) {
                if(ans.charAt(j) != strs[i].charAt(j))
                    break;
            }
            ans = ans.substring(0, j);  //这里出来的就是0-j，j不算
            if(ans.equals(""))
                return ans;
        }
        return ans;
    }
}

---

2.有效的括号

        public static boolean isValid(String s){
        if(s.isEmpty()){
            return true;
        }
        Stack<Character> stack = new Stack<Character>(); 
        //比较巧妙，在c为左括号时，将对应的右括号压入stack。
        //在c为右括号时，弹出stack，看是不是c。
        for(char c:s.toCharArray()){
            if(c == '('){
                stack.push(')');
            }
            else if(c == '['){
                stack.push(']');
            }
            else if(c == '{'){
                stack.push('}');
            } //在c是右括号时，直接弹出stack，看是不是和c相等
            else if(stack.empty() || c!=stack.pop()){   
                return false;
            }
        }
        if(stack.empty()){
            return true;
        }
        return false;			//其他的情况直接判断为false
    }
}

---

3.合并两个有序链表

//这里主要有三个东西: l1 l2 cur, 这三个东西位置定位好了就行了。
//l1为第一个链表的定位点
//l2为第二个链表的定位点
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        // 类似归并排序中的合并过程
        ListNode dummyHead = new ListNode(0);
        ListNode cur = dummyHead;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                cur.next = l1;
                cur = cur.next;
                l1 = l1.next;
            } else {
                cur.next = l2;
                cur = cur.next;
                l2 = l2.next;
            }
        }
        
        // 任一为空，直接连接另一条链表
        if (l1 == null) {
            cur.next = l2;
        } 
        if (l2 == null) {
            cur.next = l1;
        }
        return dummyHead.next; 
          
        //dummyHead不是头节点，它的下一个节点才是我们需要的的头节点
    }

---

4.删除有序数组的重复项

class Solution {
    public int removeDuplicates(int[] nums) {
        int len = nums.length;
        int j=0;
        for(int i=1; i<nums.length; i++){
            if(nums[i-1]==nums[i]){
                len--;    
            }
            else{
                nums[++j] = nums[i];
            }
        }
        return len;
    }
}

//采用双指针解法
 public int removeDuplicates(int[] nums) {
    if(nums == null || nums.length == 0) return 0;
    int p = 0;
    int q = 1;
    while(q < nums.length){
        if(nums[p] != nums[q]){
            nums[p + 1] = nums[q];
            p++;
        }
        q++;
    }
    return p + 1;
}

---

5.移除元素

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

    }
}

---

6.搜索插入位置

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

---

7.最大数组和

class Solution {
    public int maxSubArray(int[] nums) {
        int ans = nums[0];
        int sum = 0;
        for(int num: nums) {
     //前面的增益对于现在是一种正的增益，就将现在的num加上前面的正的增益
            if(sum > 0) {	
                sum += num;
            } 
     //前面的增益对于现在是一种负的增益，就将前面的负的增益不要，只需要将sum更新为现在的num就行 
            else {
                sum = num;
            }
            ans = Math.max(ans, sum); //比较大小，若sum变化后变大，就将最大值更新
        }
        return ans;
    }
}

---

8.最长字符串的长度

class Solution{
    public int lengthOfLastWord(String s) {
        char[] ch = s.toCharArray();
        int temp = 0;
        for(int i=0; i<ch.length; i++){
            if(ch[i]==' '){ //在最后一个字符串的时候，将temp变为0
                temp = 0;
            }   
            temp++;
        }
        return temp-1;
    }
}

---

9.只出现一次的数

//异或运算简单
class Solution {
     public int singleNumber(int[] nums) {
         int ans=0;
        for(int i=0;i<nums.length;i++){
            ans^=nums[i];   //异或运算
        }
        return ans;
    }
}

---

10.爬楼梯

class Solution {
    public int climbStairs(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;
        for(int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}

---

11.删除排序链表中的重复元素

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode temp = head;
        while(temp != null && temp.next != null){
            if(temp.val == temp.next.val){	
                temp.next = temp.next.next;	//这一步是最容易出错的地方，改变链表temp的指向，而不是改变temp节点的位置。意思是，经过这一步temp的位置是没有变的。
            }
            else{
                temp = temp.next;
            }   
        }
        return head;
    }
}

---

12.反转链表

//采用迭代法，不断迭代。直到到达最后的终点。
    public static ListNode reverseListIterative(ListNode head) {
        ListNode prev = null; //前指针节点
        ListNode curr = head; //当前指针节点
        //每次循环，都将当前节点指向它前面的节点，然后当前节点和前节点后移
        while (curr != null) {
            ListNode nextTemp = curr.next; //临时节点，暂存当前节点的下一节点，用于后移
            curr.next = prev; //将当前节点指向它前面的节点
            prev = curr; //前指针后移
            curr = nextTemp; //当前指针后移
        }
        return prev;
    }

---

13.合并两个有序数组

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1 = 0, p2 = 0;
        int[] sorted = new int[m + n];
        int cur;
        while (p1 < m || p2 < n) {
            if (p1 == m) {
                cur = nums2[p2++];		//第一个数组满了，把第二个继续加进来，最后p2得增一
            } else if (p2 == n) {
                cur = nums1[p1++];      //第二个数组满了，把第一个继续加进来，最后p1得增一
            } else if (nums1[p1] < nums2[p2]) {
                cur = nums1[p1++];		//这种情况下，将P1加进来，最后p1得增一
            } else {
                cur = nums2[p2++];		//这种情况下，将p2加进来，最后p2得增一
            }
            sorted[p1 + p2 - 1] = cur;	//将对应的数组的值加进来
        }
        for (int i = 0; i != m + n; ++i) {
            nums1[i] = sorted[i];		//根据题目，将所有的
        }
    }
}
 

---

14.无重复的最长子串

class Solution{
	public int lengthOfLongestSubstring(String s){
		HashMap<Character,Integer> map = new HashMap<>();  //用于存放所有遍历过的字符
		int maxLen = 0;  //目前最长的窗口长度
		int left = 0;	//滑动窗口左指针
		
		for(int i=0;i<s.length();i++){
			//判断左边界位置
			if(map.containsKey(s.charAt(i))){
				// 1.重复啦，但是是在左指针的左边，那么这个时候的left依然是原来的left
				//2.重复啦，但是是在左指针的右边。这个时候这个i位置的为重复的元素，不能要了，左指针变为map中重复元素的位置+1(+1是因为重复的不能算在窗口里面了)
				left = Math.max(left,map.get(s.charAt(i))+1);
			}
			//更新左右差值，不管是否达到更新条件
			map.put(s.charAt(i),i);
			maxLen = Math.max(maxLen,i-left+1);
		}
	}
}