5专题总结-数据结构

专题5-数据结构 2017-07-13

C++ Primer P329好好研读,stack,queue,priority_queue都是顺序容器适配器adaptor。接受一种已有的容器类型,使其行为看起来像另一种事物一样)

适配器的底层容器(array和forward_list都不行)
stack默认基于deque实现,除array和forward_list以外的容器都可以
queue默认基于deque实现,可以构造于list和deque之上,但是不能基于vector进行构造
priority_queue默认基于vector实现,最大堆max-heap,可以基于vetor和deque,但是不能基于list(需要随机访问能力)

1、基础知识

1.1、stack栈

栈操作
s.pop()删除栈顶元素O(1)
s.push()压入元素O(1)
s.top()返回首元素,但是不删除O(1)
s.swap(stack)交换两个栈的内容 

1.2、队列queue:


C++ primer P330

queue模板类的定义在<queue>头文件中。记住队列没有top()函数,使用front(),总是记错

与stack模板类很相似,queue模板类也需要两个模板参数,一个是元素类型,一个容器类型,元素类型是必要的,容器类型是可选的,默认为deque类型。

定义queue对象的示例代码如下:

queue<int> q1; queue<double> q2;

queue的基本操作有: 

q.push(x)入队,将x接到队列的末端时间复杂度是O(1)
q.pop()出队,弹出队列的第一个元素,注意,并不会返回被弹出元素的值时间复杂度是O(1)
q.front()访问队首元素,即最早被压入队列的元素时间复杂度是O(1)
q.back()访问队尾元素,即最后被压入队列的元素时间复杂度是O(1)
q.empty()判断队列空 
q.size()访问队列中的元素个数 

队列经常用于BFS,之前总结过BFS要利用queue + unordered_map实现,还有就是二叉树的层次遍历。

 

1.3、priority_queue 


主要操作是:pop(),top(),push()。pop,push都是O(logk),top是O(1)的。

左边是队头,右边是队尾,默认是最大堆即返回的top是目前最大的元素,默认是less<>,实现是x < y,因为有个建堆的过程,所以不能以平常的大小来比较。

STL里面容器默认用的是 vector. 比较方式默认用 operator< , 所以如果你把后面俩个参 缺省的话,优先队列就是大顶堆,队头元素最大。

     priority_queue利用一个最大堆完成,最大堆是一个以vector表现的完全二叉树,所以缺省情况下它的底部容器是vector。,queue以底部容器完成其所有的工作,具有这种“修改某物接口,形成另一种风貌”之性质者,称为adapter(适配器)。

    priority_queue 对于基本类型的使用方法相对简单。他的模板声明带有三个参数,priority_queue<Type, Container, Functional>,Type 为数据类型, Container 为保存数据的容器,Functional 为元素比较方式。
Container 必须是用数组实现的容器,比如 vector, deque 但不能用 list。STL里面默认用的是 vector. 比较方式默认用 operator< , 所以如果你把后面俩个参数缺省的话,优先队列就是大顶堆,队头元素最大。

    如果要用到小顶堆,则一般要把模板的三个参数都带进去。

使用方法:

头文件:

#include <queue>

声明方式:

1、普通方法:

priority_queue<int>q;
//通过操作,按照元素从大到小的顺序出队

2、自定义优先级:

struct cmp  
{  bool operator()(int x, int y)  {  return x > y;  }  
}; 

 

//其中,第二个参数为容器类型。第三个参数为比较函数。
结构体声明方式:
struct node
{
      int x, y;
       friend bool operator < (node a, node b)
      {
             return a.x > b.x; //结构体中,x小的优先级高
      }
};
priority_queue<node>q;//定义方法
//在该结构中,y为值, x为优先级。
//通过自定义operator<操作符来比较元素中的优先级
//在重载”<”时,最好不要重载”>”,可能会发生编译错误
#include <iostream>
#include <queue>
using namespace std;
int main(){priority_queue<int, vector<int>, greater<int> > q;    for( int i= 0; i< 10; ++i ) q.push( rand() );while( !q.empty() ){cout << q.top() << endl;q.pop();}    getchar();return 0;
}

 

**对于自定义类型,则必须自己重载 operator< 或者自己写仿函数**

1)重载 operator<(自己联想一下每次弹出最小元素的queue形式,{3,2,1}所以必须是返回a.x> b.x;)sort默认是小于排序,从大到小排序,所以重载的时候需要operator<。只有自定义类类型才能重写操作符:

 

bool operator>( Node left, Node right ){if( left.x== right.x ) 
return left.y> right.y;return left.x> right.x; }

   写仿函数注意有模板的时候才需要greater<int>写这种形式是为了将模板里面的T变为int,如果没用模板,直接写greater。

 

struct greater{bool operator() (const int &a, const int &b) {return a > b;}
};
//用的时候直接使用geater
template<typename T>
struct greater{bool operator() (const T &a, const T &b) {return a > b;}
};//用的时候使用greater<int>,匹配模板

 

#include <iostream>
#include <queue>using namespace std;struct Node{int x, y;Node( int a= 0, int b= 0 ):x(a), y(b) {}
};bool operator<( Node a, Node b ){if( a.x== b.x ) return a.y> b.y;return a.x> b.x; 
}int main(){priority_queue<Node> q;for( int i= 0; i< 10; ++i )q.push( Node( rand(), rand() ) );while( !q.empty() ){cout << q.top().x << ' ' << q.top().y << endl;q.pop();}getchar();return 0;
}
重载operator<形式代码示例

 

2)自己写仿函数

       自定义类型重载 operator< 后,声明对象时就可以只带一个模板参数。但此时不能像基本类型这样声明priority_queue<Node, vector<Node>, greater<Node> >;原因是 greater<Node> 没有定义,如果想用这种方法定义
则可以按如下方式:

      记住调用的时候格式为:priority_queue<Node, vector<Node>, cmp> q;

struct cmp{bool operator() ( Node a, Node b ){if( a.x== b.x ) {return a.y> b.y;}return a.x> b.x; }
};

 

#include <iostream>
#include <queue>using namespace std;struct Node{int x, y;Node( int a= 0, int b= 0 ):x(a), y(b) {}
};struct cmp{bool operator() ( Node a, Node b ){if( a.x== b.x ) return a.y> b.y;return a.x> b.x; }
};int main(){priority_queue<Node, vector<Node>, cmp> q;for( int i= 0; i< 10; ++i )q.push( Node( rand(), rand() ) );while( !q.empty() ){cout << q.top().x << ' ' << q.top().y << endl;q.pop();}getchar();return 0;
}
自己写仿函数形式

 不懂的话看下面的例子:

#include<iostream>
#include<vector>
#include<string>
#include <cstdio>
#include<queue>
#include<algorithm>
using namespace std;
struct cmp {bool operator()(int a,int b) {return a > b;}
};struct node {int x;int y;
};bool operator<(node a, node b) {return a.x > b.y;
}ostream& operator<<(ostream& os,const node&a) {os << a.x << " " << a.y<< endl;return os;}
bool operator<<(node a, node b) {return a.x > b.y;
}int main() {//priority_queue<int> q;priority_queue<node> q;for (int i = 0; i < 5; ++i) {node a;cin >> a.x;cin >> a.y;q.push(a);}cout << q.top() << endl;system("pause");
}
priority_queue仿函数例子,重载

 

 

1.4、Hash哈希


 参考链接:1)解决哈希表的冲突-开放地址法和链地址法 ;

                   2)哈希表的C实现(一);

                        链地址法实现一个很简单的hash表

                   3)哈希函数。

基本概念:

  哈希表(Hash Table,也叫散列表),是根据关键码值 (Key-Value) 而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。哈希表的实现主要需要解决两个问题,哈希函数和冲突解决。

哈希函数:

       哈希函数也叫散列函数,它对不同的输出值得到一个固定长度的消息摘要。理想的哈希函数对于不同的输入应该产生不同的结构,同时散列结果应当具有同一性(输出值尽量均匀)和雪崩效应(微小的输入值变化使得输出值发生巨大的变化)。

 冲突解决:

       现实中的哈希函数不是完美的,当两个不同的输入值对应一个输出值时,就会产生“碰撞”,这个时候便需要解决冲突。常见的冲突解决方法有开放定址法,链地址法,建立公共溢出区等。实际的哈希表实现中,使用最多的是链地址法。

  • 开放定址法

  这个方法的基本思想是:当发生地址冲突时,按照某种方法继续探测哈希表中的其他存储单元,直到找到空位置为止。这个过程可用下式描述: 
                                                         H i ( key ) = ( H ( key )+ d i ) mod m ( i = 1,2,…… , k ( k ≤ m – 1)) 
其中: H ( key ) 为关键字 key 的直接哈希地址, m 为哈希表的长度, di 为每次再探测时的地址增量。 
采用这种方法时,首先计算出元素的直接哈希地址 H ( key ) ,如果该存储单元已被其他元素占用,则继续查看地址为 H ( key ) + d 2 的存储单元,
如此重复直至找到某个存储单元为空时,将关键字为 key 的数据元素存放到该单元。 

增量 d 可以有不同的取法,并根据其取法有不同的称呼: 
( 1 ) d i = 1 , 2 , 3 , …… 线性探测再散列; 
( 2 ) d i = 1^2 ,- 1^2 , 2^2 ,- 2^2 , k^2, -k^2…… 二次探测再散列; 
( 3 ) d i = 伪随机序列 伪随机再散列; 

这种方法删除非常麻烦。

  • 链地址法

       链地址法解决冲突的做法是:如果哈希表空间为 0 ~ m - 1 ,设置一个由 m 个指针分量组成的一维数组 ST[ m ], 凡哈希地址为 i 的数据元素都插入到头指针为 ST[ i ] 的链表中。这种 方法有点近似于邻接表的基本思想,且这种方法适合于冲突比较严重的情况。 实际中使用的比较多。

基本操作:

hash基本操作
插入时间复杂度O(1)
删除时间复杂度O(1)
查找时间复杂度O(1)

 

哈希函数:

              

 

 1.5 堆heap

    

heap可以使用动态数组vector实现,下标从1开始,root就是vec[i],左儿子是2*i,右儿子是2*i+1,插入删除使用siftup,siftdown操作不断进行调整。删除将最下面的一个元素调整到root,如果是最小堆,就按照儿子大于父亲的调整策略进行调整,插入就是插入到最后一个位置,在按照上述策略进行调整。堆的最值放在vector中的第一个位置。

 

建立堆的时间复杂度是O(N)的,

建堆算法是从最后一个非叶子结点开始下溯(即 Max-Heapify操作),也可以把建堆过程想成先对左子树建堆(T(n/2)),再对右子树建堆(T(n/2)),最后对根下溯(O(lg n)),所以递推式是
T(n) = 2*T(n/2) + O(lg n)
它的解是 T(n) = O(n)

链接:https://www.zhihu.com/question/20729324/answer/132711265

函数说明:

std::make_heap将[start, end)范围进行堆排序,默认使用less<int>, 即最大元素放在第一个。

std::pop_heap将front(即第一个最大元素)移动到end的前部,同时将剩下的元素重新构造成(堆排序)一个新的heap,并没有删除该元素。

std::push_heap对刚插入的(尾部)元素做堆排序。(新加入的元素一定放在最下一层作为叶节点,并填补在由左至右的第一个孔哥哥,也就是插入到vector中的end前)。

std::sort_heap将一个堆做排序,最终成为一个有序的系列,可以看到sort_heap时,必须先是一个堆(两个特性:1、最大元素在第一个 2、添加或者删除元素以对数时间),因此必须先做一次make_heap.

其中使用仿函数来指定最大堆和最小堆,less是最大堆,greater是最小堆,默认是最大堆。

 


 

2、leetcode题目实战

2.1 155. Min Stack

https://leetcode.com/problems/min-stack/#/description

思路:使用两个栈,一个栈存正常数据,另一个栈记录每个元素对应的最小值是多少,这题细节,压入MinStack的时候,一定要使用if_else,minStack为空的时候要单独考虑,top()操作是返回stack中的数据。

class MinStack {
public:/** initialize your data structure here. */stack<int> s;stack<int> minStack;MinStack() {}void push(int x) {s.push(x);if(minStack.empty()){minStack.push(x);}else{//总是忘记加上else,只有非空的时候才能这样
            minStack.push(min(x,minStack.top()));}}void pop() {if(!s.empty()){s.pop();}if(!minStack.empty()){minStack.pop();} return;}int top() {//这里的top返回的是当前元素,不是需要返回最小值        if(!s.empty()){return s.top();}return 0;}int getMin() {if(!minStack.empty()){return minStack.top();}return 0;       }
};/*** Your MinStack object will be instantiated and called as such:* MinStack obj = new MinStack();* obj.push(x);* obj.pop();* int param_3 = obj.top();* int param_4 = obj.getMin();*/
MinStack

 

2.2 232. Implement Queue using Stacks

 https://leetcode.com/problems/implement-queue-using-stacks/#/description

思路:这题自己思路不清晰,要理顺。使用两个栈oldStack和newStack,其中newStack总是存储目前压入的元素,在pop和front操作前,如果oldStack中有元素,就直接弹出oldStack的元素,只有oldStack为空的时候,才将newStack中的元素弹出压入到oldStack中。

class MyQueue {
public:/** Initialize your data structure here. */stack<int> newStack,oldStack;//newStack总是存储最新压入的元素
    MyQueue() {}/** Push element x to the back of queue. */void push(int x) {newStack.push(x);}/** Removes the element from in front of queue and returns that element. */int pop() {if(oldStack.empty()){while(!newStack.empty()){oldStack.push(newStack.top());newStack.pop();}}        int tmp = oldStack.top();oldStack.pop();return tmp;}/** Get the front element. */int peek() {if(oldStack.empty()){while(!newStack.empty()){oldStack.push(newStack.top());newStack.pop();}} return oldStack.top();}/** Returns whether the queue is empty. */bool empty() {        return newStack.empty() && oldStack.empty();}
};/*** Your MyQueue object will be instantiated and called as such:* MyQueue obj = new MyQueue();* obj.push(x);* int param_2 = obj.pop();* int param_3 = obj.peek();* bool param_4 = obj.empty();*/
Implement Queue using Stacks

 

2.3 225. Implement Stack using Queues

https://leetcode.com/problems/implement-stack-using-queues/#/description

思路:这题有一个非常简单巧妙无敌的方法,除了push操作其他操作都和queue正常操作一样,使用一个队列就可以实现,将新元素压入queue,然后弹出一个front,再压入到queue中,这样就可以按照stack的顺序保存元素了。

 

 4是需要压入的元素,{1,2,3}是已经压入的元素,然后将123弹出压入重新压入queue,就形成了{1‘,2‘,3’,4};

class MyStack {
public:/** Initialize your data structure here. */queue<int> q;MyStack() {}/** Push element x onto stack. */void push(int x) {q.push(x);for(int i = 0;i < q.size() - 1;++i){q.push(q.front());q.pop();}       }/** Removes the element on top of the stack and returns that element. */int pop() {int tmp = q.front();q.pop();return tmp;}/** Get the top element. */int top() {        return q.front();}/** Returns whether the stack is empty. */bool empty() {return q.empty();}
};/*** Your MyStack object will be instantiated and called as such:* MyStack obj = new MyStack();* obj.push(x);* int param_2 = obj.pop();* int param_3 = obj.top();* bool param_4 = obj.empty();*/
Implement Stack using Queues

 2.4  84. Largest Rectangle in Histogram

https://leetcode.com/problems/largest-rectangle-in-histogram/#/description

思路:参照李二娃的文章,这题思路很重要,注意:单调栈适合只要弹出元素就可以开始计算的情况。

1)heights.push_back(0);是为了后面将栈中所有元素弹出。记住变量一定要在定义的时候初始化,不然后面比较的时候就会出错。stack里面存储的是索引值。

while循环里面的条件记住栈为空的时候,直接将当前元素压栈,当前元素大于栈顶元素的时候也是直接压栈,所以就得到循环的退出条件:

!s.empty() && heights[i] < heights[s.top()]

 

 

2)另外一个细节需要注意的是,弹栈过程中面积的计算。在求出高度后弹出一个元素,保证栈顶元素是小于当前元素高度的,这样求宽度的时候才能得到,

int h = heights[s.top()];
s.pop();//栈中存储的都是比目前索引小的元素
int w = s.empty() ? i : (i - s.top() - 1);  

第二步非常关键一定要理解,再求宽度之前弹出一个元素。而且栈的首元素一定是最小的那个值,最后栈为空的时候一定是目前长度乘上高度。而且访问栈之前一定啊哟判断它是否为空。

h[t] * (stack.isEmpty() ? i : i - stack.peek() - 1)

h[t]是刚刚弹出的栈顶端元素。此时的面积计算是h[t]和前面的“上流社会”能围成的最大面积。这时候要注意哦,栈内索引指向的元素都是比h[t]小的,如果h[t]是目前最小的,那么栈内就是空哦。而在目前栈顶元素和h[t]之间(不包括h[t]和栈顶元素),都是大于他们两者的。如下图所示:

 

class Solution {
public:int largestRectangleArea(vector<int>& height) {if(height.size() == 0){return 0;}int Max = 0;stack<int> s;vector<int> heights{height};heights.push_back(0);for(int i = 0;i < heights.size();++i){           while(!s.empty() && heights[i] < heights[s.top()]){int h = heights[s.top()];s.pop();//栈中存储的都是比目前索引小的元素int w = s.empty() ? i : (i - s.top() - 1);                Max = max(Max,h * w);}s.push(i);}return Max;}
};
Largest Rectangle in Histogram

 2.5 max tree(这题不是leetcode上的题目)

题目描述:

Given an integer array with no duplicates. A max tree building on this array is defined as follow:
- The root is the maximum number in the array. 
- The left subtree and right subtree are the max trees of the subarray divided by the root number. 
- Construct the max tree by the given array.Example 
Given [2, 5, 6, 0, 3, 1], the max tree constructed by this array is:6/ \5   3/   / \
2   0   1Challenge 
O(n) time and memory.

思路:使用一个栈,下一个压栈元素比栈顶元素大的时候,就将栈顶元素置为当前元素的左孩子,如果当前节点小于栈顶元素,那么就将当前节点置为栈顶元素的右孩子。

解题思路

如果是自顶向下,按照 Max Tree 的定义构造,那么时间复杂度至少是 O(nlogn) 。查找最大值的时间复杂度是 O(n) ,如果最大值刚好可以将数组分为两部分,那么复杂度递归关系如下 T(n) = 2 * T(n / 2) + O(n) 。最坏的情况是数组是降序/升序,时间复杂度为 O(n^2) 。

考虑自底向上的方法。对一个数,考察其父亲结点是谁,它是左儿子还是右儿子。对于数 i,寻找左边第一个比它大的数 x ,和右边第一个比它大的数 y ,如果 x > y 那么 i 是 y 的左儿子,否则是 i是 x 的右儿子。可以用反证法证明。

具体实现使用一个降序栈。

  • 将数组按从左到右顺序迭代,当处理一个新的结点 curt 时,所有在栈中的结点全部都在其左边,因此需要判断 curt 和栈中结点的关系( 是 curt 的左儿子或者左父亲)。
  • 当栈顶结点值大于当前结点值时,将当前结点设为栈顶结点的右儿子,进栈;当栈顶结点值小于当前结点值时,出栈,将其设置为当前结点的左儿子。
  • 重复以上步骤,并返回栈底元素,即为最大数(根结点)。
struct TreeNode{int val;TreeNode* left;TreeNode* right;TreeNode(int x):val(x),left(NULL),right(NULL){}};
class solution{    
public:TreeNode* maxTree(vector<int> A){if(A.size() == 0){return NULL;}stack<TreeNode*> s;for(int i = 0;i < A.size();++i){TreeNode* curN = new TreeNode(A[i]);while(!s.empty() && curN -> val > s.top() -> val){curN -> left = s.top();s.pop();}if(!s.empty()){stack.top() -> right = curN;}s.push(curN);}int len = s.size();while(len > 1){s.pop();--len;}return s.top();}};
MaxTree

 2.6 rehashing重哈希

http://www.lintcode.com/zh-cn/problem/rehashing/

思路:思路其实很简单,就是按照链表法,每个原数组中的元素按照哈希函数进行计算,压入到新的vector中,如果有冲突,就用一个链表组成单链表,使用链表的插入操作即可。

注意每次取出来的元素可能是一个链表,所以取出元素后,需要循环遍历,直到该元素为空为止。

主要是这题目的细节

        1)对比前面拷贝带有随机指针链表,克隆图这两道题,只要是这种有指针的,必须要new一个原来的对象,不然指针指向的还是原来的节点,就不是复制得到一个新节点了;

  2)刚开始的时候我没有新建一个变量,使用的是result[idx],这样结果是错的,记住数组中存的是每个单链表的表头,result[idx]是一个指针,如果不新建变量,那么随着while操作,就会指向最后一个元素,为node前面一个元素。所以这里必须新建dummy,dummy是对原数组指针的拷贝,原数组的指针仍然指向原区域。

  3)数组初始化为空可以直接全为NULL。

  4)新建new的时候,直接赋整数值即可,至于next的操作,后面else会进行处理。

ListNode* dummy = result[idx];
//这里必须要使用一个dummy,因为数组中的元素必须是链表的索引while( dummy -> next  != NULL){dummy =  dummy -> next; }
dummy -> next = new ListNode(node -> val);
/*** Definition of ListNode* class ListNode {* public:*     int val;*     ListNode *next;*     ListNode(int val) {*         this->val = val;*         this->next = NULL;*     }* }*/
class Solution {
public:/*** @param hashTable: A list of The first node of linked list* @return: A list of The first node of linked list which have twice size*/  int hashcode(int key, int capacity) {if(key < 0){return (key % capacity + capacity ) % capacity;}return key % capacity;} vector<ListNode*> rehashing(vector<ListNode*> hashTable) {// write your code hereif(hashTable.size() == 0){return {};}int size = 2 * hashTable.size();vector<ListNode*> result(size,NULL);for(auto node : hashTable){if(node == NULL){continue;}while(node != NULL){int key = node -> val;int capacity = size;int idx = hashcode(key,capacity);// ListNode* dummy = ;if(result[idx] == NULL){result[idx] = new ListNode(node -> val);}else{ListNode* dummy = result[idx];
//这里必须要使用一个dummy,因为数组中的元素必须是链表的索引while( dummy -> next  != NULL){dummy =  dummy -> next; }dummy -> next = new ListNode(node -> val);}node = node -> next;}}return result;}
};
rehashing

 2.7 LRU Cache

https://leetcode.com/problems/lru-cache/#/description

思路:

1)题目需要LRU的意思是最近使用的,本题需要自己定义一个数据类型node,可以使用class,也可以使用struct,class里面记得加上public。定义构造函数。

class Node{
public:int key;int value;Node* prev;Node* next;Node(int k,int v):key(k),value(v),prev(nullptr),next(nullptr){}
};
class数据类型
struct Node{int key;int value;Node* prev;Node* next;Node(int k,int v):key(k),value(v),prev(nullptr),next(nullptr){}
};
struct数据类型

需要使用一个hash表,以及一个自己实现的双链表(node里面以及定义了prev指针和next指针)。需要定义两个dummyNode,分别为头尾节点,因为头尾节点经常在改变,就需要使用dummy Node。这两个节点不需要放在hash表里面。(!!最近访问的节点都放在tail节点,不常使用的节点就在head节点处!!),因为两个函数都要用到,所以定义一个moveToTail函数,画图先prev,然后next反转。

get函数的设计:元素不在就返回-1,元素在的话要将元素返回还需要将元素调整到前面最新访问的地方,具体做法是首先将元素mremove,然后再将该元素move到tail节点处。

put函数的设计:

注意!!!如果已经存在这个值比如已经有(4,1),那么再插入(4,4),key一样,但是value不一样,就需要对hash进行更新就行。

如果hash表以及达到了容量限制capacity的大小,就需要先删除head -> next的元素,不仅仅是删除hash表中的元素,还需要调整head,删除head -> next节点,然后再执行hash表插入,链表的调整。

class Node{
public:int key;int value;Node* prev;Node* next;Node(int k,int v):key(k),value(v),prev(nullptr),next(nullptr){}
};
class LRUCache {
public:LRUCache(int capacity) {//构造函数this -> capacity = capacity;dummyHead -> next = dummyTail;dummyTail -> prev = dummyHead;        }void moveToTail(Node* cur){cur -> prev = dummyTail -> prev;dummyTail -> prev = cur;cur -> prev -> next = cur;cur -> next = dummyTail;}int get(int key) {if(hash.find(key) == hash.end()){return -1;}Node* cur = hash[key];//remove currentcur -> prev -> next = cur -> next;cur -> next -> prev = cur -> prev;//move to tail
        moveToTail(cur);return  cur -> value;}void put(int key, int value) {//最近使用的放在tail//如果已经存在这个值比如已经有(4,1),那么再插入(4,4),key一样,但是value不一样,就需要对hash进行更新就行if (get(key) != -1) {hash[key] -> value = value;return;}//if fullNode* insertNode = new Node(key,value);if(hash.size() == capacity){hash.erase(dummyHead -> next -> key);//remove dummyHead -> next;Node* cur = dummyHead -> next;cur -> next -> prev = cur -> prev;cur -> prev -> next = cur -> next;// hash.insert(make_pair(key,insertNode));
            }//not full
        hash.insert(make_pair(key,insertNode));moveToTail(insertNode);}
private:int capacity;Node* dummyHead = new Node(-1,-1);Node* dummyTail = new Node(-1,-1);unordered_map<int,Node*> hash;};/*** Your LRUCache object will be instantiated and called as such:* LRUCache obj = new LRUCache(capacity);* int param_1 = obj.get(key);* obj.put(key,value);*/
LRU Cache

2.8 128. Longest Consecutive Sequence最长连续序列

https://leetcode.com/problems/longest-consecutive-sequence/#/description

思路:这道题是找到一个vector中最长连续序列的长度,时间复杂度要求O(n),所以不能进行排序,因为排序操作最快也需要O(nlogn),要使用哈希表,使用unordered_set容器,对于每个元素nums[i],每访问一次就马上删除,接下来对于left =nums[i] - 1,right =nums[i] + 1,执行两个循环,看左边能达到哪个值,每查找一个值,就删除该元素,并且left--,同理右边执行相同操作,

最后该元素的长度为right - left -1.

这个时候有个很巧妙的方法:

 res = max(res,right - left - 1);
//这个思维很好,免掉了还得找最大值的n次操作

不需要在用vector存储结果,找最大值,原来的思路太麻烦,这种方法直接在运算过程中就确定了最大值。


 

关联容器总结

  • map可以执行下标操作,如果key不存在,就会自动插入该元素,查找使用find(),count()这两个函数,删除使用erase(),插入使用insert();
  • set不能使用下标操作,查找使用find(),count()这两个函数,删除使用erase(),插入使用insert();
  • 使用下标操作,如果不存在该元素,则value默认为0。find操作不会在map里面增加值,它找不到的情况下,指向末尾end,erase操作输入key就可以删除。

 

class Solution {
public:int longestConsecutive(vector<int>& nums) {if(nums.size() == 0){return 0;}unordered_set<int> hashNums;for(int i : nums){hashNums.insert(i);}int res = 0;for(int tmp : nums){hashNums.erase(tmp);int left = tmp - 1;while(hashNums.count(left)){hashNums.erase(left);--left;}int right = tmp + 1;while(hashNums.count(right)){hashNums.erase(right);++right;}res = max(res,right - left - 1);//这个思维很好,免掉了还得找最大值的n次操作
        }return res;}
};
Longest Consecutive Sequence

2.9 Subarray Sum(求出子数组和为0的数组,对应的开始和结束下标)

http://www.lintcode.com/en/problem/subarray-sum/

思路:最傻逼的方法是双循环,我开始就想到了这一种方法,然后看了看大神答案。。。。。。

简单的说就是使用一个unordered_map<sum,i>,出现两个一样的sum就表示中间区域就是和为0的区域,i表示位置,sum是求的和,看下面例子;

 For example: SUM: 0 -3 -2  0 -3 1then we got the solution is : 0 - 2

开头使用一个虚拟点(0,-1),因为开头第一个元素可能为0,可能包含在结果中{1,2,-3}。

之所以ans.push_back(hashMap.at(sum) + 1),是因为第一个开始元素是虚拟的,为-1.

 

class Solution {
public:/*** @param nums: A list of integers* @return: A list of integers includes the index of the first number *          and the index of the last number*/vector<int> subarraySum(vector<int> nums){// write your code hereint len = nums.size();vector<int> ans;unordered_map<int, int> hashMap;hashMap.insert(make_pair(0, -1));int sum = 0;for (int i = 0; i < len; i++) {sum += nums[i];if (hashMap.find(sum) != hashMap.end()) {ans.push_back(hashMap.at(sum) + 1);ans.push_back(i);return ans;}hashMap.insert(make_pair(sum, i));}return ans;}};
subarray sum

 2.10 49. Group Anagrams

https://leetcode.com/problems/group-anagrams/#/description

找到所有相同的“单词”,单词字母相同,但是顺序可以不同。

思路:使用一个hash表的map,unordered_map<string,vector<string>>,对于每个strs中的元素,进行排序后存入map中,只要排序后是一样的单词,就压入vector中,记住key是排序后的单词。

遍历关联容器使用迭代器方法,it -> first,it -> second:

class Solution {
public:vector<vector<string>> groupAnagrams(vector<string>& strs) {vector<vector<string>> result;if(strs.size() == 0){return result;}unordered_map<string,vector<string>> hashMap;//排序后一样的单词就压入对应的vector中for(int i = 0;i < strs.size();++i){string tmp = strs[i];sort(tmp.begin(),tmp.end());if(hashMap.find(tmp) != hashMap.end()){vector<string> vecStr;hashMap.insert({tmp,vecStr});}hashMap[tmp].push_back(strs[i]);}//遍历map,将每个string对应的变换词压入result中for(auto index = hashMap.begin();index != hashMap.end();++index){            result.push_back(index -> second);           }return result;}
};
Group Anagrams

 2.11  295. Find Median from Data Stream

https://leetcode.com/problems/find-median-from-data-stream/#/description

思路:

思路可以看剑指offerP288:

  使用最大堆和最小堆实现,左边是最大堆,右边是最小堆,要保证数据平均分配到两个堆中,因此两个堆中的元素数目之差不能超过1.为了实现平均分配,可以在数据的总数目是偶数时将新数据插入到最小堆中,否则插入到最大堆中。

  还要保证最大堆中的所有数据必须要小于最小堆中的数据,有时会出现最小堆中的元素比最大堆中的元素要小,这个时候应该采取以下措施:可以先将这个元素插入到最大堆中,接着把最大堆中的最大值拿出来插入到最小堆中。同理同样的方法处理最小堆中元素小于最大堆中的情况。

进行位运算是a&1,a有多少位,1就前面就要补齐多少个0,在进行位运算,不要前面a-1位都和1位运算,是和0位运算。结果只是和最后一位有关系。

1)priority_queue

  要保证最大堆中的元素数目大于等于最小堆中的元素数目。首先将元素压入到最大堆中,然后取出最大元素压入到最小堆中,因为最大堆中的元素数目会大于最小堆,所以在奇数数目的时候,result= 最大堆的弹出值。

2)heap

  基于STL中的 函数push_heap,pop_heap,以及vector来实现堆,具体可以看STL源码剖析P174,比较仿函数less<int>, greater<int>来实现最大堆和最小堆。偶数奇数的判断方法是number % 2,有double值得整数除法,一定要记得除以2.0.

class MedianFinder {
public:/** initialize your data structure here. */MedianFinder() {}void addNum(int num) {maxHeap.push(num);minHeap.push(maxHeap.top());maxHeap.pop();if(maxHeap.size() < minHeap.size()){maxHeap.push(minHeap.top());minHeap.pop();}}double findMedian() {int size= maxHeap.size() + minHeap.size();double result = 0;if(size == 0){return result;}if(size % 2 == 0){result = (maxHeap.top() + minHeap.top()) / 2.0;}else{result = maxHeap.top();}return result;}
private:priority_queue<int> maxHeap;priority_queue<int,vector<int>,greater<int>> minHeap;
};/*** Your MedianFinder object will be instantiated and called as such:* MedianFinder obj = new MedianFinder();* obj.addNum(num);* double param_2 = obj.findMedian();*/
priority_queue data stream median
class MedianFinder {
public:/** initialize your data structure here. */MedianFinder() {//minHeap,maxHeap;
    }void addNum(int num) {if( (maxHeap.size() + minHeap.size() ) % 2 == 1){//insert to maxHeap//first insert to minHeap,then find the min number ,put it to maxHeapif(minHeap.size() > 0 && num > minHeap[0]){minHeap.push_back(num);push_heap(minHeap.begin(),minHeap.end(),greater<int>());num = minHeap[0];pop_heap(minHeap.begin(),minHeap.end(),greater<int>());minHeap.pop_back();}maxHeap.push_back(num);push_heap(maxHeap.begin(),maxHeap.end(),less<int>());}else{//insert to minHeapif(maxHeap.size() > 0 && num < maxHeap[0]){maxHeap.push_back(num);push_heap(maxHeap.begin(),maxHeap.end(),less<int>());num = maxHeap[0];pop_heap(maxHeap.begin(),maxHeap.end(),less<int>());maxHeap.pop_back();}minHeap.push_back(num);push_heap(minHeap.begin(),minHeap.end(),greater<int>());//cout<< minHeap[0]<<endl;
        }}double findMedian() {double result = 0;int size = minHeap.size() + maxHeap.size();if(size == 0){return result;}if( (minHeap.size() + maxHeap.size() ) % 2 == 1){result = minHeap[0];cout<< minHeap[0]<<endl;}else{result = (minHeap[0] + maxHeap[0]) / 2.0;}return result;}
private:vector<int> minHeap;vector<int> maxHeap;
};/*** Your MedianFinder object will be instantiated and called as such:* MedianFinder obj = new MedianFinder();* obj.addNum(num);* double param_2 = obj.findMedian();*/
heap data stream median

 2.12 79. Word Search

https://leetcode.com/problems/word-search/#/description

思路:就是使用DFS的思想进行,首先在board里面找到Word的第一个字母,然后进行DFS,进行上下左右四个方向的深搜,只要有一个方向找到了结果,就返回TRUE。深搜前做了什么,深搜后一定要将状态改变回来。

时间复杂度分析:搜索每个定点,数量级为O(m*n),每个定点4条边,那么就是O(m*n*4), 然后搜索长度为len(word),所以最后time complexity为O(m*n*4^len(word))。一次搜索的复杂度是O(E+V),E是边的数量,V是顶点数量,在这个问题中他们都是O(m*n)量级的(因为一个顶点有固定上下左右四条边)。

参考:http://blog.csdn.net/linhuanmars/article/details/24336987

class Solution {
public:bool findWord(vector<vector<char>>& board, string word,int row,int col,int index)     {if(index == word.size()){return true;}if(row < 0 || row >= board.size() || col < 0 || col >= board[0].size() ||  board[row][col] != word[index]){return false;}board[row][col] = '0';bool result = findWord(board,word,row - 1,col,index + 1) ||findWord(board,word,row + 1,col,index + 1) ||findWord(board,word,row,col - 1,index + 1) ||findWord(board,word,row,col + 1,index + 1) ;board[row][col] = word[index];return result;}bool exist(vector<vector<char>>& board, string word) {if(word.size() == 0){return true;}if(board.empty() || board[0].empty()){return false;}       for(int row = 0;row < board.size();++row){for(int col = 0;col < board[row].size();++col){                if(findWord(board,word,row,col,0)){                    return true;}                 }}return false;}
};
Word search

 

转载于:https://www.cnblogs.com/dingxiaoqiang/p/7157445.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/416412.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Ribbon自带负载均衡策略比较

Ribbon自带负载均衡策略比较 策略名策略声明策略描述实现说明BestAvailableRulepublic class BestAvailableRule extends ClientConfigEnabledRoundRobinRule选择一个最小的并发请求的server逐个考察Server&#xff0c;如果Server被tripped了&#xff0c;则忽略&#xff0c;在选…

newcondition java_Java并发Condition接口

全屏java.util.concurrent.locks.Condition接口提供一个线程挂起执行的能力&#xff0c;直到给定的条件为真。 Condition对象必须绑定到Lock&#xff0c;并使用newCondition()方法获取对象。Condition类的方法以下是Condition类中可用的重要方法的列表。序号方法名称描述1publi…

前端学习(2486):$emit

1、父组件可以使用 props 把数据传给子组件。 2、子组件可以使用 $emit 触发父组件的自定义事件。 vm.$emit( event, arg ) //触发当前实例上的事件 vm.$on( event, fn );//监听event事件后运行 fn&#xff1b; 例如&#xff1a;子组件&#xff1a; <template><di…

葡萄城报表介绍:B/S 报表软件

葡萄城报表介绍&#xff1a;B/S 报表软件 B/S 报表软件定义 B/S&#xff08;Browser/Server&#xff0c;浏览器/服务器模式&#xff09;也称 B/S 结构&#xff0c;是 WEB 兴起后的一种网络结构模式。B/S 模式是由最开始的 C/S&#xff08;Client/Server&#xff0c;客户机/服务…

Python基础【day02】:元组和购物车练习的知识点

一、元组 元组其实跟列表差不多&#xff0c;也是存一组数&#xff0c;只不是它一旦创建&#xff0c;便不能再修改&#xff0c;所以又叫只读列表 用途&#xff1a;一般情况下用于自己写的程序能存下数据&#xff0c;但是又希望这些数据不会被改变&#xff0c;比如&#xff1a;数…

python库封装_使用SIP对C库进行Python封装

Python中使用C/C模块有许多工具&#xff0c;大名鼎鼎的有SWIG(英文意思为&#xff1a;豪饮)、SIP(英文意思为&#xff1a;啜饮&#xff0c;小口的喝)&#xff0c;还有 boost.python等。其中SIP是从SWIG发展而来&#xff0c;专为Python调用C/C模块使用的(看SIP的命名就能看出来&…

python最简易入门_零基础入门python,用最简单的方式即可入门python,没有那么复杂...

python已经开始被越来越多的人喜欢&#xff0c;其中有很多是从未学习过编程的人&#xff0c;那么&#xff0c;如果是从零开始学python的话&#xff0c;会很难吗&#xff1f;其实从零开始学python并不会很难&#xff0c;最简单的方法&#xff0c;往往最有效果&#xff0c;无论你…

hibernate07--关联映射

单向的一对多关联 创建对应的实体类以及映射文件 package cn.bdqn.bean; /*** * author 小豆腐*街道对应的实体类**单向的多对一关联*/ public class Street {private Integer id;private String name;//多个街道 属于 一个区县private District district; //对应的区县p…

java 常用流_Java流类图结构: 流的概念和作用流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数...

Java流类图结构&#xff1a;流的概念和作用流是一组有顺序的&#xff0c;有起点和终点的字节集合&#xff0c;是对数据传输的总称或抽象。即数据在两设备间的传输称为流&#xff0c;流的本质是数据传输&#xff0c;根据数据传输特性将流抽象为各种类&#xff0c;方便更直观的进…

Java编写五线谱上的音符_干货| 认识五线谱上的音符!

原标题&#xff1a;干货| 认识五线谱上的音符&#xff01;前几周&#xff0c;给友友们分享了节奏学习小技巧……学的好不好可以自我检测一下&#xff1a;如果你最近说话都是这样&#xff1a;最近 啊 | 本渣 被刷 | 屏 - |大家 都 | 玩起 节奏 |不就 追热 | 点 么 |谁 . 不 | 会…

java实现抽奖游戏_Java实现游戏抽奖算法

常用抽奖算法对比基础的游戏抽奖算法通常要求实现在指定奖品的集合中&#xff0c;每个奖品根据对对应概率进行抽取。个人了解的主要有以下几中抽奖算法&#xff1a;随机数一一对应算法思想这种算法思想最为简单。将n个奖品编号0 - N-1&#xff0c;其中各类奖品的概率通过其数量…