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,
    class Compare = std::less
> class priority_queue;

默认container是vector。

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

atoi

int atoi( const char *str );

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

min和max

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

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 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;
}