【LeetCode 1】两数之和

思路1

先对数组进行排序，之后从已经排序的数组两侧开始进行加法；如果两数之和大于target，则左侧数字变小，即数组下标变小；如果两数之和小于target，则右侧数字变大，即数组下标变大。

快速排序

public static void quickSort(int[] nums, int low, int high) {
		if (low >= high) //只有一个元素或者不满足条件return
		{
			return;
		}
		int i = low; //注意这里没有用low+1
		int j = high;
		int pivot = nums[low];
		while (i < j) {
			while (i < j && nums[j] >= pivot)
			{
				j--;
			}
			while (i < j && nums[i] <= pivot)
			{
				i++;
			}
			//退出：i == j 或者 (nums [i] >= pivot and nums[j] <= pivot)
			//直接进行交换，或者是i<j时，或者是i=j时
			int t = nums[i];
			nums[i] = nums[j];
			nums[j] = t;
		}
		// 退出时候：i=j
		//将low放到确定的j位置
		nums[low] = nums[j];
		nums[j] = pivot;
		quickSort(nums, low, j-1);
		quickSort(nums, j+1, high);
	}

从两侧进行遍历，复杂度O(n)

while (i < j)
		{
			if (nums[i] + nums[j] == target)
			{
			/*确定下标
				ret[0] = indexOf(copy, nums[i], 1); 
				if (nums[i] == nums[j])
				{
					ret[1] = indexOf(copy, nums[j], 2);
				}
				else 
				{
					ret[1] = indexOf(copy, nums[j], 1);
				}
				break;
			*/
			}
			else if (nums[i] + nums[j] < target)
			{
				i++;
			}
			else 
			{
				j--;
			}
		}

思路2

利用字典存储键值对；利用循环次数就是数组下标，保存下标值。

public static int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
        // 可以O(1)的时间复杂度寻找位置
        
        for (int i = 0; i < nums.length; ++i) {
            if (hashtable.containsKey(target - nums[i])) {
            //hashmap中相同的key，只有一个键值对
            //i记录循环次数，又表示数组元素中的位置
                return new int[]{hashtable.get(target - nums[i]), i};
            }
            hashtable.put(nums[i], i);
        }
        return new int[0]; //返回空数组
    }