面试准备：剑指offer 刷题时候的笔记

刷题trick

bool duplicate(int numbers[], int length, int* duplication) {

int *copy = new int[length]();//copy一一对应

int count=0;//dup计数器

for(int i=0;i<length;i++){

if(copy[numbers[i]]==-1){

duplication[count++] = numbers[i];

//cout<<duplication[0];

return true;

}

else copy[numbers[i]]=-1;

}

return false;

}

动态申请数组空间的题int *copy = new int[length]();

涉及到指针传参的，使用指针指向数组的对应位置即可；指针和数值不要用混了

vector相关：

1. 头文件

#include<vector>

2. vector声明及初始化

vector<int> vec; //声明一个int型向量vector<int> vec(5); //声明一个初始大小为5的int向量vector<int> vec(10, 1); //声明一个初始大小为10且值都是1的向量vector<int> vec(tmp); //声明并用tmp向量初始化vec向量vector<int> tmp(vec.begin(), vec.begin() + 3); //用向量vec的第0个到第2个值初始化tmpint arr[5] = {1, 2, 3, 4, 5}; vector<int> vec(arr, arr + 5); //将arr数组的元素用于初始化vec向量//说明：当然不包括arr[4]元素，末尾指针都是指结束元素的下一个元素，//这个主要是为了和vec.end()指针统一。vector<int> vec(&arr[1], &arr[4]); //将arr[1]~arr[4]范围内的元素作为vec的初始值

3. vector基本操作

(1). 容量

• 向量大小： vec.size();
• 向量最大容量： vec.max_size();
• 更改向量大小： vec.resize();
• 向量真实大小： vec.capacity();
• 向量判空： vec.empty();
• 减少向量大小到满足元素所占存储空间的大小： vec.shrink_to_fit(); //shrink_to_fit

(2). 修改

• 多个元素赋值： vec.assign(); //类似于初始化时用数组进行赋值
• 末尾添加元素： vec.push_back();
• 末尾删除元素： vec.pop_back();
• 任意位置插入元素： vec.insert();
• 任意位置删除元素： vec.erase();
• 交换两个向量的元素： vec.swap();
• 清空向量元素： vec.clear();

(3)迭代器

• 开始指针：vec.begin();
• 末尾指针：vec.end(); //指向最后一个元素的下一个位置
• 指向常量的开始指针： vec.cbegin(); //意思就是不能通过这个指针来修改所指的内容，但还是可以通过其他方式修改的，而且指针也是可以移动的。
• 指向常量的末尾指针： vec.cend();

(4)元素的访问

• 下标访问： vec[1]; //并不会检查是否越界
• at方法访问： vec.at(1); //以上两者的区别就是at会检查是否越界，是则抛出out of range异常
• 访问第一个元素： vec.front();
• 访问最后一个元素： vec.back();
• 返回一个指针： int* p = vec.data(); //可行的原因在于vector在内存中就是一个连续存储的数组，所以可以返回一个指针指向这个数组。这是是C++11的特性。

(4)算法

• 遍历元素

vector<int>::iterator it;for (it = vec.begin(); it != vec.end(); it++) cout << *it << endl;//或者for (size_t i = 0; i < vec.size(); i++) { cout << vec.at(i) << endl;}

• 元素翻转

#include <algorithm>reverse(vec.begin(), vec.end());

• 元素排序

#include <algorithm>sort(vec.begin(), vec.end()); //采用的是从小到大的排序//如果想从大到小排序，可以采用上面反转函数，也可以采用下面方法:bool Comp(const int& a, const int& b) { return a > b;}sort(vec.begin(), vec.end(), Comp);

常用的STL库：

vector（不定长数组/向量）：

#include  <vector>

vector<int> vec;

vector[0];//使用下标访问元素；

vec.front();//取vec中的第一个元素；

vec.back();//取vec中的最末一个元素；

vec.push_back(x);//在向量末尾加入元素x；

vec.pop_back();//删除末尾元素，同时向量空间减少1；

vec.insert(vec.begin()+i,a);//在第i+1个元素前边插入元素a；

vec.erase(vec.begin()+i);//删除第i+1个元素；

vec.size();//取向量大小；

vec.clear();//清空向量；

reverse(vec.begin(),vec.end());//将向量翻转；

sort(vec.begin(),vec.end());//排序；

vec.resize(n,1);//改变当前向量大小为n，新增加的元素赋值为1；

vec.empty();//判断向量是否为空，为空返回1，不为空返回0；

swap(vec & v);//交换向量vec和v的值；

vec.max_size();//返回vec的最大长度；//这个是空间大小 实际大小用size()就可以的

set（集合）：

#include <set>

set<int> s;

s.clear();//清除所有元素；

s.count(x);//返回集合中元素x的数目，由于set中元素是唯一的，所以用来判断元素是否存在；

s.empty();//判断当前集合是否为空；

s.erase(x);//删除集合中元素x；

s.insert(x);//再集合中插入元素x；

s.size();//返回集合的大小；

s.find(x);//在集合中查找元素x，返回的是指向x所在位置的迭代器；

stack（堆栈）：

#include <stack>

stack<int> stk;

stk.empty();//判断栈是否为空；

stk.push();//向当前堆栈中加入元素；

stk.pop();//将最后放入的元素弹出；

stk.size();//返回堆栈的大小；

stk.top();//返回堆栈 最后放入的元素；

map（映射）：

#include <map>

map<int,int> mp;

map<pair<int,int> ,int> mpair;

mp[0]=x;//利用数组方式插入数据，0是键，x是值；

mp.at(0)=x;//利用at执行插入操作；

mp.insert(make_pair(1,x));//利用insert插入pair(键，值)数据；

mp.emplace(make_pair(1,x));//在映射中不存在主键1时执行插入操作；

mp.size();//返回mp的大小；

mp<int,int> ::iterator iter;//定义迭代器；

for(it=mp.begin(); it!=mp.end(); ++it);//映射遍历的方式，利用迭代器实现；

mp.count(1);//统计键为1的元素存在的映射数，存在返回1，不存在返回0；

mp.erase(iter);//根据迭代器删除元素；

mp.clear();//清空映射；

mp.epty();//判断映射是否为空；

mp.find(1);//根据键1查找元素，找到以后返回迭代器；

mp.rbegin(),mp.rend();//返回反向迭代器；

lower_bound(1);//返回查找的键1的下界，即闭区间，返回的是迭代器；

upper_bound(1);//返回查找的键1的上界，即开区间，返回的是迭代器；

mp.swap(m);//将mp和m进行交换；

queue（队列）：

#include <queue>

queue<int> q;

q.push(x);//入队；

q.pop();//出队；

q.front();//访问队首元素；

q.back();//访问队尾元素；

q.empty();//判断队列是否为空；

q.size();//返回队列的大小；

链接： https://www.nowcoder.com/questionTerminal/253d2c59ec3e4bc68da16833f79a38e4

来源：牛客网

我这里用到了STL中的set，set有一个特性就是不能插入相同元素，这样只需遍历原List一次就可以判断出有没有环，还有环的入口地址。s.insert(node).second这里在插入的同时也判断了插入是否成功，如果不成功表明set中已经有该元素了，该元素就是环的入口元素。

链接： https://www.nowcoder.com/questionTerminal/253d2c59ec3e4bc68da16833f79a38e4

来源：牛客网

快慢指针找环的入口 或者判断环存在

 if(pHead == null || pHead.next == null)

            return null;

        ListNode p1 = pHead;

        ListNode p2 = pHead;

        while(p2 != null && p2.next != null ){

            p1 = p1.next;

            p2 = p2.next.next;

            if(p1 == p2){

                p2 = pHead;

                while(p1 != p2){

                    p1 = p1.next;

                    p2 = p2.next;

                }

                if(p1 == p2)

                    return p1;

            }

        }

        return null;

链接： https://www.nowcoder.com/questionTerminal/fc533c45b73a41b0b44ccba763f866ef

来源：牛客网

递归删除节点

 public ListNode deleteDuplication(ListNode pHead) {

        if (pHead == null || pHead.next == null) { // 只有0个或1个结点，则返回

            return pHead;

        }

        if (pHead.val == pHead.next.val) { // 当前结点是重复结点

            ListNode pNode = pHead.next;

            while (pNode != null && pNode.val == pHead.val) {

                // 跳过值与当前结点相同的全部结点,找到第一个与当前结点不同的结点

                pNode = pNode.next;

            }

            return deleteDuplication(pNode); // 从第一个与当前结点不同的结点开始递归

        } else { // 当前结点不是重复结点

            pHead.next = deleteDuplication(pHead.next); // 保留当前结点，从下一个结点开始递归

            return pHead;

        }

    }

链接： https://www.nowcoder.com/questionTerminal/c6c7742f5ba7442aada113136ddea0c3

来源：牛客网

斐波那契数列 动态规划来做

    int Fibonacci(int n) {

        int f = 0, g = 1;

        while(n--) {

            g += f;

            f = g - f;

        }

        return f;

    }

链接： https://www.nowcoder.com/questionTerminal/1277c681251b4372bdef344468e4f26e

来源：牛客网

链接： https://www.nowcoder.com/questionTerminal/1277c681251b4372bdef344468e4f26e

来源：牛客网

class Solution {

public:

    int StrToInt(string str) {

        if(str.empty())

            return 0;

        int symbol = 1;

        if(str[0] == '-'){//处理负号

            symbol = -1;

            str[0] = '0'; //这里是‘0’ 不是0

        }else if(str[0] == '+'){//处理正号

            symbol = 1;

            str[0] = '0';

        }

        int sum = 0;

        for(int i=0;i<str.size();++i){

            if(str[i] < '0' || str[i] > '9'){

                sum = 0;

                break;

            }

              

            sum = sum *10 + str[i] - '0';

             

        }

        return symbol * sum;

         

    }

};