Day8:刷题

29.归并算法的应用

#include<iostream>
#include<vector>
using namespace std;
//extern int count=0;//记录数组中的逆序对

void msort(vector<int> &nums,vector<int> &arr,int l,int r,int &count){//归并排序，划分
    if(l>=r){//当左边大于等于右边结束
        return ;
    }
    int mid=(l+r)/2;
    msort(nums,arr,l,mid,count);
    msort(nums,arr,mid+1,r,count);
    int i=l, j=mid+1, k=l;
    while(i<=mid && j<=r){
        if(nums[j]<nums[i]){//逆序
            arr[k++]=nums[j++];
            count+= (mid-i+1);//num【j】比j前面i后面的都小,唯一比归并排序多的一句
        }
        else{
            arr[k++]=nums[i++];
        }
    }
    if(i<=mid){//若左边的数组没有排完
        copy(nums.begin()+i,nums.begin()+mid+1,arr.begin()+k);//剩下的部分添加到arr中

    }
    if(j<=r){
        copy(nums.begin()+j,nums.begin()+r+1,arr.begin()+k);
    }
    copy (arr.begin()+l,arr.begin()+r+1,nums.begin()+l);//最终全部放回nums 排序完成
}
int reversePairs(vector<int>& nums,int &count){
    vector<int> arr(nums.size(),0);
    msort(nums,arr,0,nums.size()-1,count);
    return count;
}
int main(){
    int n;
    cin>>n;
    vector<int> nums(n);
    for(int i=0;i<n;++i){
        int temp;
        cin>>temp;
        nums.push_back(temp);
    }
    int count=0;
    cout<<reversePairs (nums,count);
    return 0;
}

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *p=headA;
        ListNode *q=headB;
        int len1=0,len2=0;
        while(p!=NULL){//计算长度
            len1++;
            p=p->next;
        }
        while(q!=NULL){
            len2++;
            q=q->next;
        }
        int plus=abs(len1-len2);//当后面的结点完全相同才能找到公共节点的头
        if(len1>len2){//一个指针移动，令两个链表一样长
            while(plus){
                headA=headA ->next;
                plus--;
            }
        }
        else{
             while(plus){
                headB=headB->next;
                plus--;
            }
   
        }
        while(headA){
            if(headA==headB){//两个链表完全相同
                return headA;
            }
            headA=headA->next;
            headB=headB->next;
        }
        return nullptr;//返回空指针
    }
};

31.

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int count=0;
        for(int i=0;i<nums.size();i++){
            if(nums[i]==target){
                count++;
            }
            if(nums[i]>target){
                return count;
            }
        }
        return count;

    }
};

32.

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        for(int i=0;i<nums.size();i++){
            if(nums[i]!=i){
                return i;
            }
        }
        return nums[nums.size()-1]+1;//注意特殊情况，当最后一个数字在nums中没有出现，期待出现nums最后一个数+1
    }
};

33.后序遍历出来是递减，中序遍历是递增

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
int ans;
    int kthLargest(TreeNode* root, int k) {
        dfs(root,k);//深度遍历
        return ans;
        }
    void dfs(TreeNode* root,int &k){//逆序则遍历顺序为右根左
        if(!root){
            return ;
        }
        dfs(root->right,k);
        k--;//根
        if(!k){//k==0
            ans=root->val;
        }
        if(k>0){
            dfs(root->left,k);
        }
    }    

};