leetcode two-sum之排序解法（C语言）

简介

leetcode 原题链接：two-sum

• 描述

  给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

  你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

  示例:

    给定 nums = [2, 7, 11, 15], target = 9
    
    因为 nums[0] + nums[1] = 2 + 7 = 9
    所以返回 [0, 1]

	/**
	 * Note: The returned array must be malloced, assume caller calls free().
	 */
	int* twoSum(int* nums, int numsSize, int target, int* returnSize){
	
	}

思路

• 排序算法
  将nums中的元素从小到大排序，然后利用双指针，前指针初始化时指向头（最小的位置），
  另外一个后指针指向尾（最大的位置），如果前指针指向的元素加上后指针指向的元素之和
  大于target，那么就将后指针向前移动一位，反之就将前指针向后移动一位。

• 示意图

• 流程图

• 代码

/**
* Note: The returned array must be malloced, assume caller calls free().
*/

typedef struct t_node
{
   int val;
   int pos;
}T_NODE;

void select_sort(T_NODE *nums, int numsSize)
{
   for (int i = 0; i < numsSize - 1; i++)
   {
   	int k = i;
   	for (int j = i + 1; j < numsSize; j++)
   	{
   		if (nums[k].val > nums[j].val)
   			k = j;
   	}        
   	T_NODE temp = nums[k];
   	nums[k] = nums[i];
   	nums[i] = temp;
   }
}

int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
   
   T_NODE* nodes = (T_NODE*)malloc(sizeof(T_NODE)*numsSize);
   if (nodes == NULL)
   {
   	*returnSize = 0;
   	return NULL;
   }

   for (int i = 0; i < numsSize; i++)
   {
   	nodes[i].val = nums[i];
   	nodes[i].pos = i;
   }
   select_sort(nodes, numsSize);

   T_NODE* nodes_front = &nodes[0];
   T_NODE* nodes_behind = &nodes[numsSize - 1];
   int sum_temp;

   while(nodes_front != nodes_behind)
   {
   	sum_temp = nodes_behind->val + nodes_front->val;
   	if (sum_temp > target)
   	{
   		nodes_behind--;
   	}
   	else if(sum_temp < target)
   	{
   		nodes_front++;
   	}
   	else
   	{
   		int* return_nums = (int *)malloc(sizeof(int) * 2);
   		if (return_nums == NULL)
   		{
   			free(nodes);
   			*returnSize = 0;
   			return NULL;
   		}

   		return_nums[0] = nodes_front->pos;
   		return_nums[1] = nodes_behind->pos;
   		*returnSize = 2;
   		return return_nums;
   	}
   }

   *returnSize = 0;
   return NULL;
}

• 总结
  这种算法，需要先排序，然后再计算，不一定比暴力方法效率更高。