题目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};
}
}