Algorithm Day 5 —— 字符串中的第一个唯一字符，合并两个有序数组，相交链表

题目一：字符串中的第一个唯一字符
给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
案例:

s = “leetcode”
返回 0.

s = “loveleetcode”,
返回 2.

class Solution {
    //空间换时间
    public int firstUniqChar(String s) {
        int[]  nums = new int[256];
    	int index = -1;
    	Arrays.fill(nums, 0);
    	for(int i = 0 ; i < s.length(); i++){
    		nums[s.charAt(i)]++;
    		
    	}
    	for(int i = 0; i < s.length(); i++){
    		if(nums[s.charAt(i)] == 1){
    			index = i;
    			break;
    		}
    	}
    	return index;
    }
}

题目二：合并两个有序数组
给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。

说明:

• 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
• 你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

示例:

输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3
输出: [1,2,2,3,5,6]

//从末尾向前，将最大的数字写到最后
//写法一
class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        while(i >= 0 && j >= 0) {
             if(nums1[i] > nums2[j]) {
                 nums1[k--] = nums1[i--];
             } else {
                 nums1[k--] = nums2[j--];  
             }
        }
        while(j >= 0){
            nums1[k--] = nums1[j--];
       } 
    }
}
//合并写法
class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = m - 1, j = n - 1, k = m + n - 1;
        while(j >= 0) {
            nums1[k--] = i >= 0 && nums1[i] > nums2[j] ? nums1[i--] : nums2[j--]; 
        }
    }
}

题目三：编写一个程序，找到两个单链表相交的起始节点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
 //方法一：遍历链表，到达末尾之后，指向另一个链表的头部，这二次循环的时候，长度差消失，同时到达相交节点
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null) return null;
        ListNode pA = headA;
        ListNode pB = headB;
        while(pA != pB){
            pA = pA==null ? headB : pA.next;
            pB = pB==null ? headA : pB.next;
        }
        return pA;
    }
}

//方法二：遍历链表，分别找到两个链表的长度，然后让长的链表比短链表先开始走len(L) - len(S) 步，然后开始同时遍历
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode pL = headA;
        ListNode pS = headB;
        int lenA = 0;
        while(pL != null){
            lenA++;
            pL = pL.next;
        }
        int lenB = 0;
        while(pS != null){
            lenB++;
            pS = pS.next;
        }
        pL = headA;
        pS = headB;
        int len = lenA - lenB;
        if(len < 0){
            //单链表B是长的
            pL = headB;
            pS = headA;
            len = lenB - lenA;
        }
        //最长的单链表永远是pL,并且差值len是一个正数
        for(int i = 0;i < len; i++){
            pL = pL.next;
        }
        //pL和pS在同一个起跑线上
        while(pL != null && pS != null && pL != pS){
            pL = pL.next;
            pS = pS.next;
        }
        if(pL == pS && pL != null && pS != null ){
            return pL;
        }
        return null;
    }
}