leetcode代码记录

记录代码
保存了在leetcode(https://leetcode-cn.com/)刷过的题目的代码。不方便，直接把代码传到github上了。此篇博客先不删了。

1. 两数之和

难度：简单
题目描述:给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

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

示例:

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

C++，直接暴力求解代码如下（复杂度O(n^2)）：

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

方法二：先对数组先排序，这样只用遍历一遍（首位递进），复杂度(O(nlogn)),但是会排序以后和原来数组的索引顺序不同,需要处理一下。代码省略。
方法三：如果使用哈希可以将复杂度降低到O(n),（使用map，时间复杂度为O(nlogn)，空间复杂度为 O(n)）键：原数组元素，值：原数组索引。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int,int> hashmap;
        vector<int> res;
        for(int i = 0,t; i <nums.size();i++){
            t = target - nums[i];
            if(hashmap.count(t)!=0){
                res.push_back(hashmap[t]);
                res.push_back(i);
                return res;
            }
            hashmap[nums[i]]=i;
        }
        return {};
    }
};

2. 两数相加

难度：中等
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

思路较为简单，代码如下，复杂度为O(max(m,n))

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int cf = 0;
        int sum;
        ListNode *head,*p,*p1,*p2;
        p1 = l1;p2 = l2;
        head = new ListNode(0);
        p = head;
        int x,y;
        while(p1!=NULL||p2!=NULL||cf==1){
            if(p1==NULL){
                x = 0;
            }
            else{
                x = p1->val;
                p1 = p1->next;
            }
            if(p2==NULL){
                y = 0;
            }
            else{
                y = p2->val;
                p2 = p2->next;
            }
            sum = x+y+cf;
            p->next =new ListNode(sum%10);
            cf = sum/10;
            p = p->next;
        }
        return head->next;
    }
};

1122. 数组的相对排序

难度: 简单
给你两个数组，arr1 和 arr2，

arr2 中的元素各不相同
arr2 中的每个元素都出现在 arr1 中
对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。
示例

输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
输出：[2,2,2,1,4,3,3,9,6,7,19]

提示

arr1.length, arr2.length <= 1000
0 <= arr1[i], arr2[i] <= 1000
arr2 中的元素 arr2[i] 各不相同
arr2 中的每个元素 arr2[i] 都出现在 arr1 中

考虑到把arr1中在arrr2中的元素计数，再把不在arr2中的元素排序，代码如下:

class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        int i,j,k;
        vector<int>::iterator arrit=arr1.end();
        map<int,int>::iterator hashit;
        map<int,int> hashmap;   //键:数组元素 值:该元素出现的数量
        for(i = 0;i<arr2.size();i++)
            hashmap[arr2[i]]=0;   
        for(j = arr1.size()-1;j>=0;j--){
            hashit = hashmap.find(arr1[j]);
            if(hashit!=hashmap.end())
                hashmap[arr1[j]]++;
            else{
                arrit--;
                *arrit=arr1[j];
            }
        }
        sort(arrit,arr1.end());
        for(i = 0,k=0;i<arr2.size();i++){
            for(j = 0;j<hashmap[arr2[i]];j++,k++){
                arr1[k]=arr2[i];
            }
        }
        return arr1;
    }
};

在提交以后发现了别人提交的一个其他方法，使用到了题目给的条件（数组长度和元素取值范围有限制），通过设置元素的权值和重载sort的排序条件完成，代码如下:

int rnk[1050];//排序权重
bool cmp(int a,int b) { //比较大小时，去rnk中比较这两个元素对应的权重
    return rnk[a]<rnk[b];
}

class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        int arr2num = arr2.size(),arr1num = arr1.size();
        for(int i=0;i<=1000;i++) rnk[i]=1050+i;//按顺序
        for(int j=0;j<arr2num;j++) rnk[arr2[j]]=j;//在arr2中的元素的排序权重一定在1000以内
        sort(arr1.begin(),arr1.end(),cmp);
        return arr1;
    }
};