牛客题目——链表相加、寻找第K大、数组中只出现一次的两个数字

---

题目1——链表相加

假设链表中每一个结点的值都在0-9之间，那么链表整体就可以代表一个整数，给定两个这种链表，请生成代表两个整数相加值的结果链表。
要求：空间复杂度O(n)，时间复杂度O(n)。

解题思路

与大数加法类似，只不过大数用链表表示，初始化两个集合，用来存储链表中的数字，然后采用模拟法，定义两个指针指向数字序列的尾部，数字对齐相加，同时计算进位和当前数字，每计算一次构造一个结点，并且利用头插法插入当前数字的结点，终止条件为处理完所有的数字，返回头结点即可。

代码实现

import java.util.*;
/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */
public class Solution {
    public ListNode addInList (ListNode head1, ListNode head2) {
        if(head1 == null)
            return head2;
        if(head2 == null)
            return head1;
        int carry = 0;
        ArrayList<Integer> h1 = new ArrayList<Integer>();
        ArrayList<Integer> h2 = new ArrayList<Integer>();
        while(head1!=null){
            h1.add(head1.val);
            head1 = head1.next;
        }
        while(head2!=null){
            h2.add(head2.val);
            head2 = head2.next;
        }
        ListNode res = new ListNode(0);
        int i = h1.size()-1;
        int j = h2.size()-1;
        while(i>=0 || j>=0){
            int a = i>=0?h1.get(i):0;
            int b = j>=0?h2.get(j):0;
            int tmp = a+b+carry;
            carry = tmp/10;
            ListNode dummy = new ListNode(tmp%10);
            if(res.next == null)
                res.next = dummy;
            else{
                dummy.next = res.next;
                res.next = dummy;
            }
            i--;
            j--;
        }
        if(carry>0){
            ListNode one = new ListNode(1);
            one.next = res.next;
            res.next = one;
        }
        return res.next;
    }
}

题目2——寻找第K大

给定一个整型数组a，同时给定它的大小n和要找的K，请你根据快速排序的思路，找出数组中第K大的数(包括重复的元素，不用去重)。
要求：时间复杂度O(nlogn)，空间复杂度O(1)。

示例
输入：[1,3,5,2,2],5,3
输出：2

解题思路

使用快速排序，使得数组从大到小排序，同时使用二分法递归确定第K大元素的位置。

代码实现

import java.util.*;
public class Solution {
    //常规的快排划分，但这次是大数在左边
    public int partion(int[] a, int low, int high){ 
        int temp = a[low];
        while(low < high){ 
            //小于枢轴的在右
            while(low < high && a[high] <= temp)
                high--;
            a[low] = a[high];
            //大于枢轴的在左
            while(low < high && a[low] >= temp)
                low++;
            a[high] = a[low];
        }
        a[low] = temp;
        return low;
    }
    public int quickSort(int[] a, int low, int high, int K){
        if(low<=high){
            //先进行一轮划分，p下标左边的都比它大，下标右边都比它小
            int p = partion(a, low, high); 
            //若p刚好是第K个点，则找到
            if(K == p - low + 1)  
                return a[p];
            //从头到p超过k个数组，则目标在左边
            else if(p - low + 1 > K)  
                //递归左边
                return quickSort(a, low, p - 1, K);  
            else  
                //否则，在右边,递归右边,但是需要减去左边更大的数字的数量
                return quickSort(a, p + 1, high, K - (p - low + 1));  
        }
        return -1;
    }
    public int findKth(int[] a, int n, int K) {
        return quickSort(a, 0, n - 1, K);
    }
}

题目3——数组中只出现一次的两个数字

一个整型数组里除了两个数字只出现一次，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。
要求：空间复杂度O(1)，时间复杂度O(n)。

示例
输入：[1,4,1,6]
输出：[4,6] (输出时按非降序排列)

解题思路

很容易想到的就是创建哈希表，当数组元素不再哈希表中，就进行put操作，否则，表明这个数字出现两次，将其从哈希表中删除，最后遍历哈希表，就是只出现一次的数字。但是其空间和时间复杂度都为O(n)。

可以通过位运算来实现，异或运算中，如果两个数字相同，则异或结果为0，例如[1,4,1,6]，如果将数组中所有数字异或1^4^1^6，那么结果应该为4^6，没有办法获得两个数字。如果我们将数组分成两组，然后每一组求出其中出现一次的数字，那么如何将这两个数字分到两组呢?
可以发现，如果两个数字不同，其异或结果一定不为0，并且异或结果中有一位一定为1，所以我们可以根据这一位将数组分成两个集合。

代码实现

//哈希
import java.util.*;
public class Solution {
    public int[] FindNumsAppearOnce (int[] array) {
        Map<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i=0;i<array.length;i++){
            if(!map.containsKey(array[i])){
                map.put(array[i],1);
            }else{
                map.remove(array[i]);
            }
        }
        int[] res = new int[2];
        int k = 0;
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            res[k] = entry.getKey();
            k++; 
        }
        Arrays.sort(res);
        return res;
    }
}

//位运算，空间复杂度为O(1)
import java.util.*;
public class Solution {
    public int[] FindNumsAppearOnce (int[] array) {
        int tmp = 0;
        //先将所有的数字进行异或运算，得到那两个数字异或的结果
        for(int num:array){
            tmp ^= num;
        }
        //找到可以充当分组的那位
        int mask = 1;
        while((tmp&mask) == 0)
            mask <<= 1;
        //分成两组，每组去求出现一次的数字
        int a = 0;
        int b = 0;
        for(int num:array){
            if((num&mask) == 0) a^=num;
            else b^=num;
        }
        if(a>b){
            int c = a;
            a = b;
            b = c;
        }
        return new int[]{a,b};
    }
}