算法总结

常用算法总结

归并

void Merge(vector<int>& vec,int low,int high){
    if(low>=high) return;
    else{
        int mid=low+(high-low)/2;
        Merge(vec,low,mid);
        Merge(vec,mid+1,high);
        MergeSort(vec,low,mid,high);
    }
}
void MergeSort(vector<int>& vec,int low,int mid,int high){
    int start=low;
    int center=mid+1;
    int num=low;
    vector<int> temp(vec.size(),0);
    while(start<=mid&&center<=high){
        if(vec[start]<vec[center])
            temp[num++]=vec[start++];
        else
            temp[num++]=vec[center++];
    }
    while(start<=mid){
        temp[num++]=vec[start++];
    }
    while(center<=high){
        temp[num++]=vec[center++];
    }
    for(int i=low;i<=high;i++){
        vec[i]=temp[i];
    }
}

快排

void QuickSort(vector<int>& vec, int low, int high){
        if (low >= high) return;
        else{
            int key = vec[low];
            int i = low, j = high;
            while (i<j){
                while (i<j&&vec[j] >= key)
                    j--;
                if (i<j)
                vec[i++] = vec[j];
                while (i<j&&vec[i] <= key){
                    i++;
                }
                if (i<j)
                vec[j--] = vec[i];
            }
            vec[i] = key;
            QuickSort(vec, low, i - 1);
            QuickSort(vec, i + 1, high);
        }
}

冒泡排序

void swap(int& a,int& b){
    int temp;
    temp=a;
    a=b;
    b=temp;
}
void BubbleSort(vector<int>& vec){
    int len=vec.size();
    for(int i=0;i<len-1;i++)
       for(int j=len-1;j>i;j--){
            if(vec[j]<vec[j-1]){
                swap(vec[j],vec[j-1]);
            }
       }
}
//优化的冒泡排序
void BubbleSort(vector<int>& vec){
    int len=vec.size();
    int flag=0;
    for(int i=0;i<len-1;i++)
    {
       flag=0;
       for(int j=len-1;j>i;j--){
            if(vec[j]<vec[j-1]){
                flag=1;
                swap(vec[j],vec[j-1]);
            }
       }
       if(flag==0)
           break;
    }
}

二分查找

int Search(vector<int> vec,int key){
    int low=0,high=vec.size()-1,mid;
    while(low<=high){
        mid=low+(high-low)/2;
        if(vec[mid]==key)
            return mid;
        else if(vec[mid]<key){
            low=mid+1;
        }
        else
            high=mid-1;
    }
    return -1;
}

combination sum

Two Sum

两个数的和为目标数字，可通过遍历一遍数组，通过mp值存入数字，每次在mp中查找mp[target-num[i]]，有的话就打印，没有的话，将当前数字num[i]放到mp中。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int size=nums.size();
        map<int,int>mp;
        vector<int> nums1;
        vector<int> res;
        for(int i=0;i<size;i++)
        {
            int findnum=target-nums[i];
            if(mp[findnum]){
                res.push_back(mp[findnum]-1);
                res.push_back(i);
                break;
            }
            else{
                mp[nums[i]]=i+1;
            }
        }
        return res;
    }
};

Combination Sum

从一个数组中选择不确定的几个数字，和为target。
原数组中没有重复的数字，但原数组中的数字可以重复使用。
没有重复的数字不需要考虑组合重复的情况。

vector<vector<int>> sumArray(vector<int> vec,vector<int> array,int index,int target,int sum,vector<vector<int>> res){
    if(sum==target)
        res.push_back(vec);
    else{
        for(int i=index;i<array.size();i++){
            if(sum+array[i]>target)
                continue;
            else{
                vec.push_back(array[i]);
                sumArray(vec,array,i,target,sum+array[i],res);
                vec.pop_back();
            }
        }
    }
    return res;
}

Combination Sum II

从一个数组中选择不确定的几个数字，和为target。
原数组中有重复的数字，原数组中的数字不可以重复使用。
先进行排序：sort(candidates.begin(),candidates.end());
然后如果当前的i不等于index说明不是遍历到当前数字时选择，然后又等于前一个数字的话，continue;
if(i!=index&&array[i]==array[i-1]) continue。

class Solution {
public:
    void sumArray(vector<int> array,vector<int> vec,vector<vector<int>>& res,int index,int sum,int target){
        if(sum==target)
            res.push_back(vec);
        else{
            for(int i=index;i<array.size();i++){
                if(sum+array[i]>target) continue;
                else{
                    if(i!=index&&array[i]==array[i-1]) continue;
                    vec.push_back(array[i]);  
                    sumArray(array,vec,res,i+1,sum+array[i],target);
                    vec.pop_back();
                }
            }

        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<int> vec;
        vector<vector<int>> res;
        sort(candidates.begin(),candidates.end());
        sumArray(candidates,vec,res,0,0,target);
        return res;
    }
};

Combination Sum III

指定K个数字(1~9)，使其和为n。

class Solution {
public:
    void sumArray(vector<int> vec,int index,int sum,int target,int count,int k,vector<vector<int>>& res){
        if(sum==target){
            if(count==k) res.push_back(vec);
        }
        else{
            for(int i=index;i<10;i++){
                if(sum+i>target) continue;
                else{
                    vec.push_back(i);
                    sumArray(vec,i+1,sum+i,target,count+1,k,res);
                    vec.pop_back();
                }
            }
        }
    }
    vector<vector<int>> combinationSum3(int k, int n) {
        vector<vector<int>> res;
        vector<int> vec;
        sumArray(vec,1,0,n,0,k,res);
        return res;
    }
};

全排列

class Solution{
public:
    void rankArray(vector<int> vec,vector<vector<int>> res,int len,int index){
        if(index==len){
            res.push_back(vec);
        }
        else{
            for(int i=index;i<len;i++){
                swap(vec[index],vec[i]);
                rankArray(vec,res,len,index+1);
                swap(vec[index],vec[i]);
            }
        }
    }
}