leetcode刷题详解一

算法题常用API

std::accumulate

函数原型：

template< class InputIt, class T >
T accumulate( InputIt first, InputIt last, T init );

一般求和的，代码如下：

int sum = accumulate(vec.begin() , vec.end() , 0);

详细用法参考

lower_bound()

int lower_bound(起始地址，结束地址，要查找的数值) 返回的是数值第一个等于某元素的位置。

int index = upper_bound(vec.begin(), vec.end(), target) - vec.begin()

功能：函数lower_bound()在first和last中的前闭后开区间进行二分查找，返回大于或等于target的第一个元素位置。如果所有元素都小于target，则返回last的位置，因为是前闭后开因此这个时候的last会越界，要注意。

找不到返回nums.end()

upper_bound()

int upper_bound(起始地址，结束地址，要查找的数值) 返回的是数值第一个大于某个元素的位置。

int index = upper_bound(vec.begin(), vec.end(), target) - vec.begin();

功能：函数upper_bound()返回的在前闭后开区间查找的关键字的上界，返回大于target的第一个元素位置。注意：返回查找元素的最后一个可安插位置，也就是“元素值>查找值”的第一个元素的位置。同样，如果target大于数组中全部元素，返回的是last。(注意：数组下标越界)

binary_search()

bool binary_search(起始地址，结束地址，要查找的数值) 返回的是是否存在这么一个数，是一个bool值。

功能：在数组中以二分法检索的方式查找，若在数组(要求数组元素非递减)中查找到indx元素则真，若查找不到则返回值为假。

priority_queue

template<
    class T,
    class Container = std::vector<T>,
    class Compare = std::less<typename Container::value_type>
> class priority_queue;

默认container是vector。

默认compare策略是less。因为默认是大顶堆，首先输出最大元素，所以最开始来的元素最后才输出。记住大顶堆比较策略是std::less<T>，小顶堆的比较策略是std::greater<T>

atoi

int atoi( const char *str );

将char*的字符串转化成整数

min和max

包含在c++标准库中头文件<algorithm>中

std::min(const T& a, const T& b);
std::max(const T& a, const T& b);
//或者自己写comp函数
const T& min (const T& a, const T& b, Compare comp);

//自定义compare函数如下
static bool compare(const string& s1, const string& s2)
{
    string ab = s1 + s2;
    string ba = s2 + s1;
    return ab < ba; //升序排列。如改为ab > ba, 则为降序排列
}

数据结构

链表类型

234. 回文链表

**思路：**回文串是对称的，所以正着读和倒着读应该是一样的，这一特点是解决回文串问题的关键。单链表无法倒着遍历，无法使用双指针技巧。

方法一，把链表节点放入栈中再拿出和原来的链表比较。算法的时间和空间复杂度都是 O(N)

class Solution {
public:
    bool isPalindrome(ListNode* head) {  
        stack<int> rec;
        ListNode *temp = head;
        while(temp){
            rec.push(temp->val);
            temp = temp->next;
        }
        while(!rec.empty()||head){
            if(head->val == rec.top()){
                head = head->next;
                rec.pop();
            }else{
                return false;
            }  
        }
        return true;
    }
};

方法二

**利用双指针的快慢指针的思想，找出链表的中间节点。**双指针的条件是while(fast!=null && fast->next!=null)

然后要分清楚链表是双数还是单数。如果fast==null，表明是偶数链表，否则是奇数链表

双指针找中点+反转一部分节点

bool isPalindrome(ListNode* head) {  
    ListNode* slow = head;
    ListNode* fast = head;
    while(fast && fast->next){
        slow = slow->next;
        fast = fast->next->next;
    }
    //fast=nullptr说明是偶数链表
    //fast!=nullptr说明是奇数链表
    ListNode* tail = reverse(slow);
    ListNode* front = head;
    while(tail || tail == slow){
        if(front->val == tail->val){
            front = front->next;
            tail = tail->next;
        }else{
            return false;
        }
    }
    return true;
}
ListNode* reverse(ListNode* node){
    if(!node || !node->next){
        return node;
    }
    ListNode* tmp = reverse(node->next);
    node->next->next = node;
    node->next = nullptr;
    return tmp;
}