LeetCode1-(两数之和、两数相加)

一、两数之和

①暴力解法

看到题目，能想到的最简单的方法是，遍历循环整数数组 nums，通过相加得到目标值 target，此方法暴力解法。代码如下：

public int[] twoSum(int[] nums, int target) {
		
	int[] result = new int[2];
	
	boolean bool = false;
	int len = nums.length;
	for(int i=0;i<len;i++){
		for(int j=0;j<len;j++){
			if(j!=i&&nums[i]+nums[j]==target){
				result[0] = i;
				result[1] = j;
				bool = true;
				break;
			}
		}
		if(bool){break;}
	}
	
	return result;
}

②list实现

第一种方法效率较低，时间复杂度为O(n²)，采用一次循环，判断list中是否存在相应的差值，时间复杂度为O(n)，代码如下：

public int[] twoSum(int[] nums, int target) {
	int[] result = new int[2];
	List<Integer> lists = new ArrayList<Integer>();
	
	int len = nums.length;
	for(int i=0;i<len;i++){
		int x = target - nums[i];
		if(lists.indexOf(x)>=0){
			result[0] = lists.indexOf(x);
			result[1] = i;
			break;
		}
		lists.add(nums[i]);
	}
	return result;
}

③哈希表

由于效率都不高，查看了官方解题方法，使用哈希表的方式，时间复杂度从 O(N)O(N) 降低到 O(1)O(1)，代码如下：

public int[] twoSum(int[] nums, int target) {
	int[] result = new int[2];
	Map<Integer, Integer> map = new HashMap<Integer, Integer>();
	int len = nums.length;
	for(int i=0;i<len;i++){
		if(map.containsKey(target-nums[i])){
			result[0] = map.get(target-nums[i]);
			result[1] = i;
			break;
		}
		map.put(nums[i], i);
	}
	return result;
}

总结：哈希表能快速的查询到数值所在的位置，由于原本习惯了使用list+map的组合进行获取对象，此题目只存在integer一种类型，所以反向将值作为key，而将位置作为value。

二、两数相加

①暴力解法

看到此题目想到了就是反向解析，然后再相加，再将结果转换。不停的转换，逻辑比较混乱，考虑到肯定存在简便方法，未详细思考，采用暴力方法。代码如下：

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
	StringBuffer a = new StringBuffer();
	StringBuffer b = new StringBuffer();
	
	a.insert(0, String.valueOf(l1.val));
	ListNode l1_temp = l1.next;
	while(null!=l1_temp){
		a.insert(0, String.valueOf(l1_temp.val));
		l1_temp = l1_temp.next;
	}
	
	b.insert(0, String.valueOf(l2.val));
	ListNode l2_temp = l2.next;
	while(null!=l2_temp){
		b.insert(0, String.valueOf(l2_temp.val));
		l2_temp = l2_temp.next;
	}
	//需要使用大数相加
	BigDecimal c = new BigDecimal(a.toString()).add(new BigDecimal(b.toString()));
	String str = String.valueOf(c);
	char[] array = str.toCharArray();
	
	int len = array.length;
	ListNode first = new ListNode(Integer.valueOf(String.valueOf(array[0])));//第一个链表
	ListNode temp = first;//临时对象
	for(int i=1;i<len;i++){
		char arr = array[i];
		int val = Integer.valueOf(String.valueOf(arr));
		
		ListNode model = new ListNode(val, temp);
		temp = model;
	}
	return temp;
}

②模拟

参考了官方解题，详细解析参考官方解析。

简便方法，指针逆序存储，使用数学个位相加，满十进位的逻辑，采用一个临时指针和临时进位值。注意点：最后需要加一个进位，各种情况需考虑完整。

代码如下：

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
	ListNode x = null;//头指针
	ListNode tt = null;//临时指针
	int temp = 0;//进位值
	
	while(null!=l1||null!=l2){
		int a = l1!=null?l1.val:0;
		int b = l2!=null?l2.val:0;
		int sum = a + b + temp;
		
		if(x==null){
			x = tt = new ListNode(sum%10);
		}else{
			tt.next = new ListNode(sum%10);
			tt = tt.next;
		}
		temp = sum/10;
		if(null!=l1){
			l1 = l1.next;
		}
		if(null!=l2){
			l2 = l2.next;
		}
		//最后需进位
		if(temp>0){
			tt.next = new ListNode(temp);
		}
	}
	return x;
}

总结：题目存在可转换，转换成熟悉的数学情况，即可简单写出简单的算法。