Prácticas y optimización de dos y tres sumas de clasificación y no clasificación

Two_sum es para determinar si la suma de dos elementos en una matriz dada es igual al valor del elemento dado, el código es simple y fácil de entender primero mire dos_sum de
two_sum

#include <iostream>
#include <unordered_map>
#include <vector>

using namespace std;

/*
Sum Find a pair of two elements in an array, whose sum is a given target number.Assume only one qualified pair of numbers existed in the array, return the index of there numbers*/

// 排序部分
int partition(int* arr, int left, int right){
	int temp = arr[left];
	while(left < right){
		while(arr[right] >= temp && left < right){
			right--;
		}
		arr[left] = arr[right];
		while(arr[left] <= temp && left < right){
			left++;
		} 
		arr[right] = arr[left];
	}
	arr[left] = temp;
	return left;
}
void quickSort(int* arr, int left, int right){
	if(left < right){
		int pivod = partition(arr, left, right);
		quickSort(arr, left, pivod - 1);
		quickSort(arr, pivod + 1, right); 
	}
}
// hashmap做法
// map, O(n)
vector<int> addsToTarget(vector<int> &numbers, int target){
	unordered_map<int, int> numToIndex;
	vector<int> vi(2);
	for(auto it = numbers.begin(); it != numbers.end(); it++){
		if( numToIndex.count(target - *it)){
			vi[0] = numToIndex[target - *it] + 1;
			vi[1] = (int)(it - numbers.begin()) + 1;
			return vi;
		}
		numToIndex[*it] = (int)(it - numbers.begin());
	}
} 
// 快排做法 
// quicksort, O(nlgn)
bool hashArrayTwoCandidates(int* arr, int size, int sum){
	quickSort(arr, 0, size - 1);
	int l = 0, r = size - 1;
	while(l < r){
		int sum_ = arr[l] + arr[r];
		if(sum_ == sum){
			return true;
		}else if(sum_ < sum){
			l++;
		}else{
			r--;
		}
	}
	return false;
}

int main(){

	return 0;
}

suma tres

#include <iostream>
#include <set>
#include <vector>
#include <algorithm>
#include <iterator>
#include <unordered_map>

using namespace std;

// 使用排序
// use sort
set<vector<int>> find_three(vector<int> arr){
    sort(arr.begin(), arr.end());
    set<vector<int>>results;
    vector<int> result(3);
    int n = arr.size();
    for(int i = 0; i < n; i++){
        int k = arr.size() - 1;
        int j = i + 1;
        while(j < k){
            int sum_two = arr[i] + arr[j];
            if(sum_two + arr[k] < 0){
                j++;
            }else if(sum_two + arr[k] > 0){
                k--;
            }else{
                result[0] = arr[i];
                result[1] = arr[j];
                result[2] = arr[k];
                results.insert(result);
                j++;
                k--;
            }
        }
    }
    return results;
}

// 使用hash表不用排序
// use hash
set<vector<int>> find_three_(vector<int> arr){
    unordered_map<int, int> hash;
    set<vector<int>> results;
    vector<int> result(3);
    for(int i = 0; i < arr.size(); i++){
        hash[arr[i]] = i; 
    }

    unordered_map<int, int>::iterator iter;
    for(int i = 0; i < arr.size() - 1; i++){
        for(int j = i + 1; j < arr.size(); j++){
            int sum = arr[i] + arr[j];
            iter = hash.find(0 - sum);
            if(iter != hash.end()){
                if(iter->second > j){
                    result[0] = arr[i];
                    result[1] = arr[j];
                    result[2] = (*iter).first;
                    sort(begin(result), end(result));
                    results.insert(result); 
                }
            }
        }
    }
    return results;
}

int main(){
    vector<int>arr {-1, 0, 1, 2, -1, -4};
    set<vector<int>> ret;
    ret = find_three_(arr);
    for(auto i = begin(ret); i != end(ret); i++){
        copy(begin(*i), end(*i), ostream_iterator<int>{cout, ", "});
        cout << "\n";
    }
    return 0;
}