思路1：可以用hash表來儲存陣列中的元素，這樣我們取得一個數後，去判斷sum - val 在不在陣列中，如果在陣列中，則找到了一對二元組，它們的和為sum，該演算法的缺點就是需要用到一個hash表，增加了空間複雜度。

思路2：同樣是基於查詢，我們可以先將陣列排序，然後依次取一個數後，在陣列中用二分查詢，查詢sum -val是否存在，如果存在，則找到了一對二元組，它們的和為sum，該方法與上面的方法相比，雖然不用實現一個hash表，也沒不需要過多的空間，但是時間多了很多。排序需要O(nLogn)，二分查詢需要(Logn)，查詢n次，所以時間複雜度為O(nLogn)。

思路3：該方法基於第2種思路，但是進行了優化，在時間複雜度和空間複雜度是一種折中，但是演算法的簡單直觀、易於理解。首先

1. #include <iostream>
2. #include <algorithm>
3. usingnamespace std;  
4. void printPairSums(int data[], int size, int sum);  
5. int main(int argc, char
   * argv[])  
6. {  
7. int data[] = {1, 5, 9, -1, 4, 6, -2, 3, -8};  
8. int size = sizeof(data) / sizeof(data[0]);  
9. int i;  
10.     sort(data, data + size);  
11.     printPairSums(data, size, 8);  
12. return 0;  
13. }  
14. void printPairSums(int data[], int size, int sum)  
15. {  
16. int first = 0;  
17. int last = size -1;  
18. int s = 0;  
19. while (first < last)  
20.     {  
21.         s = data[first] + data[last];  
22. if (s == sum)  
23.         {  
24.             cout << data[first] << " + " << data[last] << " = " << sum << endl;  
25.             first++;  
26.             last--;  
27.         }  
28. elseif (s < sum)  
29.         {  
30.             first++;  
31.         }  
32. else
33.         {  
34.             last--;  
35.         }  
36.     }  
37. }  

#include <iostream>
#include <algorithm>
using namespace std;

void printPairSums(int data[], int size, int sum);
int main(int argc, char* argv[])
{
	int data[] = {1, 5, 9, -1, 4, 6, -2, 3, -8};
	int size = sizeof(data) / sizeof(data[0]);
	int i;
	sort(data, data + size);
	printPairSums(data, size, 8);

	return 0;
}
void printPairSums(int data[], int size, int sum)
{
	int first = 0;
	int last = size -1;
	int s = 0;
	while (first < last)
	{
		s = data[first] + data[last];
		if (s == sum)
		{
			cout << data[first] << " + " << data[last] << " = " << sum << endl;
			first++;
			last--;
		}
		else if (s < sum)
		{
			first++;
		}
		else
		{
			last--;
		}
	}
}