c++后台开发面试常见知识点总结（六）算法手写

• 链表倒转  leetcode-206
• 连续子数组最大和问题(和最大的连续子序列的和)   leetcode-53
• 输出字符串中最长的回文子串长度？  leetcode-5
• 一个字符串,求最长无重复子串的长度？  leetcode-3
• 最长递增子序列  leetcode-300
• 反转一个字符串。。。。。。（手写代码） leetcode-344
• 数组中存在一个大于n/2次的数，如何以最优方法查找它？LeetCode 169 \ 229
• 一个字符串中{}  [ ]  ()匹配问题     LeetCode  20
• 一个数组，只有一个数字出现奇数次，其余数字出现偶数次 LeetCode  136
• 给定一个ip地址，编码使得ip和32位整数呈双射关系   LeetCode  93
• 求一个数组逆序对的个数  LeetCode  629
• 1个32位整数，计算二进制格式下有多少个1  LeetCode  191
• 最小生成树与并查集  leetcode684，685， 721

• 比较两二叉树是否相同（手写代码）LeetCode  100
• 手写判断大小端的代码
• 单链表找倒数第n个节点   LeetCode  19
• 把一颗二叉树原地变成一个双向链表？  114
• 判断一个无符号的整数是不是2的n次方？ 231
• int atoi(char *str)？ 8
• 栈的getmin()操作 O（1） 155
• 用栈实现队列，用队列实现栈？232  225
• 实现strstr函数  28
• 整数a和b，求a的b次方的最后三位数
• 算法题：将字符串转换成人民币大写（半小时后发邮箱）
• 如何删除map中的奇数节点
• 恢复翻转数组
• 二分法
• 排序
• 手写String
• memcpy函数的实现
• strcpy函数的实现
• BST的第K小的节点  230
• 判断链表是否有环，如果有，返回环的入口节点；求环的长度   141
• 求一个数组逆序对的个数    629
• 翻转数组和恢复翻转数组
• 删除单链表中间节点
• 判断两个单链表是否相交
• r行c列的0,1数组，找到最大的全为1的正方形？
• 连续子数组最大和问题(和最大的连续子序列的和)
• excel中，标志列的如AA,AZZ ,BS，求这些列到底是第几列
• 二叉树两个节点的最近公共祖先
• 去掉字符串中的空格字符
• 删除字符串开始和结尾处的空格，并将中间的多个连续的空格合并成一个
• char *s1, const char *s2，删除s1中s2出现过的字符
• 单链表判环
• 判断一个数是不是回文数
• 求一个集合的所有子集，递归实现，非递归实现
• 旋转有序数组的二分查找
• 删除数组中的重复元素
• 实现一个计算器计算简单的表达式字符串
• memcopy和memove

• 微信小程序团队一共有 n 名成员，决定出去秋游，在海边遇到出租摩托艇的杰克马
• 给定一个二叉树，节点值为0-9， LeetCode 129
• 写一个二叉树翻转，然后写个测试
• trcpy安全性，如何实现安全，strnpy,写一下并测试，
• 写sql语句(A表存储有每个电话号码当月通话记录，表B是电话号码集合，求表B每个号码通话次数)
• 如何设计一个好的字符串hash函数
• 两字符串最长公共子串， 最长公共子序列
• 打印二叉树每层最右边的节点 层序遍历 LeetCode 199
• 顺时针回形打印矩阵的元素 LeetCode 54
• 判断在一个矩阵中是否存在一条包含某字符串所有字符的路径 LeetCode 79
• 3sum 数组中三数之和为0的所有三元组 leetcode 15
• 判断一个字符串是不是两个有序的字符串交错组成的。 Leetcode 97
• 编程题：递增数组中找两个数和为某个固定值。设计测试用例 Leetcode 1
• 给你一个数组和数组元素的个数，求平均值。
• 两个非常大的数相加 Leetcode 415
• 手写下单例模式？

• 链表倒转

从尾到头打印链表（使用栈或者使用递归）

链表倒转

typedef struct ListNode
{
int data;
ListNode *next;
};

ListNode* reverseList1(ListNode *head)

{

if (head == NULL)

return head;

ListNode* dummy = new ListNode;

dummy->data = -1;

dummy->next = head;

ListNode *Cur = dummy->next;

ListNode *tmp = Cur->next;

while (tmp != NULL) {

Cur->next = tmp->next;

tmp->next = dummy->next;

dummy->next = tmp;

tmp = Cur->next;

}

Cur->next = NULL;

return dummy->next;

}

• 连续子数组最大和问题(和最大的连续子序列的和)

• 输出字符串中最长的回文子串长度？

https://blog.csdn.net/h_xy_zwb/article/details/64124271

DP:O(n^2)

string
longestPalindrome(string s) {

int len=s.size();

vector<vector<int>>
flag(len,vector<int>(len,0));

int maxres=0,idx=0;

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

for(int
j=0,k=i;j<len&&k<len;j++,k++){

if(k==j) flag[j][k]=1;

else
if(s[k]==s[j]&&j+1==k) flag[j][k]=2;

else
if(s[k]==s[j]&&flag[j+1][k-1]>0) flag[j][k]=flag[j+1][k-1]+2;

else flag[j][k]=0;

if(flag[j][k]>maxres){

maxres=flag[j][k];

idx=j;

}

}

}

return s.substr(idx,maxres);

}

一个字符串,求最长无重复子串的长度？

最长递增子序列：

思想：在求以a_i为末元素的最长递增子序列时，找到所有序号在L前面且小于a_i的元素a_j，即j<i且a_j<a_i。如果这样的元素存在，那么对所有a_j,都有一个以a_j为末元素的最长递增子序列的长度f(j)，把其中最大的f(j)选出来，那么f(i)就等于最大的f(j)加上1，即以a_i为末元素的最长递增子序列，等于以使f(j)最大的那个a_j为末元素的递增子序列最末再加上a_i；如果这样的元素不存在，那么a_i自身构成一个长度为1的以a_i为末元素的递增子序列。

• 手写下单例模式？

• class singleton{
• protected:
• singleton(){}
• private:
• static
  singleton* p;
• public:
• static
  singleton* getInstance();
• }
• singleton* singleton::p = new singleton();
• singleton* singleton::getInstance(){
• return
  p;
• }

• 写个string类
• 反转一个字符串。。。。。。（手写代码）

剑指58

.对于string类型的：使用algorithm中的reverse函数，reverse(s.begin(),s.end());

对于用char定义的字符串：使用string.h中的strrev函数，char s[]="123456";//不能是string类型；strrev(s);

实现：设置两个指针，一头一尾，往中间移动；

• 数组存中在一个大于n/2次的数，如何以最优方法查找它？
  • int MoreThanHalfNum(int *arr, int len)
  • 2 {
  • 3     int result = arr[0];
  • 4     int count = 1;
  • 5
  • 6     for(int i = 1; i < len; ++i)
  • 7     {
  • 8         if(arr[i] == result)
  • 9             count ++;
  • 10         else if(count == 0)
  • 11         {
  • 12             result = arr[i];
  • 13             count = 1;
  • 14         }
  • 15         else
  • 16             count --;
  • 17     }
  • 18     return result;
  • 19 }

一个字符串中{}  [ ]  ()匹配问题

bool isValid(string s) {

std::stack<char> st;

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

{

char ch = s.at(i);

if(ch == '(' || ch == '[' || ch == '{')

st.push(ch);

else if(st.size() > 0 && ((ch == ')' && st.top() == '(') || (ch == ']' && st.top() == '[') || (ch == '}' && st.top() == '{')))

st.pop();

else

return false;

}

return st.size() == 0;

}

• 一个数组，只有一个数字出现奇数次，其余数字出现偶数次，如何得到这个数字？如果出现奇数次的数字有2个呢？

可以用位运算实现，如果将所有所有数字相异或，则最后的结果肯定是那两个只出现一次的数字异或的结果，所以根据异或的结果1所在的最低位，把数字分成两半，每一半里都还有只出现一次的数据和成对出现的数据
这样继续对每一半相异或则可以分别求出两个只出现一次的数字

• 给定一个ip地址，编码使得ip和32位整数呈双射关系

int IpToInt(string s)

{  
int ret=0;  int num=0;

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

{

if(s[i]!='.')
 {num=num*10+(s[i]-'0');}

else

{

cout<<num<<endl;

ret=ret<<8;

ret+=num;

cout<<ret<<endl;

num=0;

}

}

ret=ret<<8;

ret+=num;

return
ret;

}

• 求一个数组逆序对的个数

基于归并排序的思想统计逆序对：先把数组分割成子数组，再子数组合并的过程中统计逆序对的数目。统计逆序对时，先统计子数组内部的逆序对的数目，再统计相邻子数组的逆序对数目。

• 1个32位整数，计算二进制格式下有多少个1，不通过循环怎么做

通过n与n-1相& 清楚n最右边的1；

int BitCount(int n){

int c=0;//计数器

while(n){

n&=(n-1);

++c;

}

return c;

}

• 算法 最小生成树

Prim+ Kruskal算法

https://www.cnblogs.com/GHzz/p/9148279.html

• 比较两二叉树是否相同（手写代码）。现在我才明白，大概是在考我用递归怎么遍历树，我当时写的居然是以按层遍历的方式去遍历树，

递归

手写判断大小端的代码

https://blog.csdn.net/kit_9875507/article/details/44264663

大小端的本质就是不同的存储方式

大端模式：字数据的高字节存储在低地址中，而字数据的低字节则存放在高地址中。

小端模式：字数据的高字节存储在高地址中，而字数据的低字节则存放在低地址中。

根据这个特性，假设我们初始化了一个int变量i为0x12345678，其地址为0x100，根据定义在小端模式下
0x100一个字节内的值为0x78，类推0x101=>0x56，0x102=>0x34，0x103=0x12，根据这个编程如下

1. int checkSystem(void)
2. {
3. int i = 0x12345678;
4. char *c = &i;
5. return ((c[0] == 0x78) && (c[1] == 0x56) && (c[2] == 0x34) && (c[3] == 0x12));
6. }

int main(void)

{

if(checkSystem())

printf("little
endian\n");

else

printf("big
endian\n");

return 0;

}

单链表找倒数第n个节点，说所有你能想到的方法。

方法一：遍历链表，记录链表的长度total，再次遍历链表，第total - N - 1个节点就是查找结果，需要遍历两次链表

方法二：使用两个指针，通过移动指针，遍历一次链表，p指针首先移动n-1步，然后p和q同时移动，直到p.next == null，此时q所指向的节点就是所求

 

怎么把一颗二叉树原地变成一个双向链表？

转换成有序双向链表：https://www.cnblogs.com/wanglei5205/p/8780086.html

 

怎么判断一个无符号的整数是不是2的n次方？

思路：一个整数如果是2的整数次方，那么它的二进制表示中有且只有一位是1，而其他所有位都是0。把这个整数与这个整数减去1之后进行与运算，那么这个整数当中唯一的

1会变为0，这个整数也变为0；

• int atoi(char *str)？

• //atoi
• enum ={Invalid = 0, Valid};
• bool errno = Invalid;
• int atoi(const
  char * str) 
• {
• long long num = 0; //point1:可能溢出，所以用long long存
• errno = Invalid;//初始设输入为不合法输入
• if (str!=nullptr && *str != '\0')
  //point2：//考虑了空串和空指针
• {
• bool minus = false;
• if (*str == '+')
• {
• ++str;
• }
• else if (*str == '-')
• {
• ++str;
• minus = true;
• }
• if (*str!='\0') //只有符号，Invalid
• atoiCore(str, minus, num);
• }
• return (int)num; //已经检查过溢出，保证了num在int范围内
• }
• void
  atoiCore(const char *str, bool minus, long long &num)
• {
• while ('\0' != *str)
• {
• if (*str >= '0' && *str
  <= '9')
• {
• num = num*10 + (*str - '0');
• ++str;
• if ((!minus && num >
  0x7FFFFFFF)||(minus && (-num) < (signed int)0x80000000))//输入溢出
• {
• errno = Invalid;
• num = 0;
• return;
• }
• }
• else  
  //输入非法字符
• {
• errno = Invalid;
• num = 0;
• return;
• }
• }
• if (minus)
• num = -num;
• errno = Valid;  //标志输入合法
• }

• 栈的getmin()操作 O（1）

template <typename T> class
NewStack

{

private :

std::stack<T> stack_data;

std::stack<T> stack_support;

public:

NewStack();

~NewStack();

void push( T value)

{

stack_data.push (value);

if (stack_support.size()==0 || stack_support.top()>value)

stack_support.push(value);

else:

stack_support.push
(stack_support.top());

}

void pop()

{    if (stack_data.size()>0 &&
stack_support.size()>0)

{

stack_data.pop;

stack_support.pop;

}

}

T min()

{

if (stack_data.size()>0 && stack_support.size()>0)

{

return stack_support.top();

}

}

• 用栈实现队列，用队列实现栈？

使用队列实现栈:

class MyStack {

public:

MyStack() {

}

void
push(int x) {

queue<int> temp; //建立一个辅助队列

while(q.empty() == false){ //将队列q中所有元素存入辅助队列中

temp.push(q.front());

q.pop();

}

q.push(x); //向队列中压入元素，放在队首

while(temp.empty() == false){ //逐个将辅助队列中的元素送回队列q中

q.push(temp.front());

temp.pop();

}

}

int
pop() {

int a = q.front(); //将队列首元素返回

q.pop();  //删除队首

return a;

}

int
top() {

return q.front();  //返回队首

}

bool
empty() {

return q.empty();

}

private:

queue<int> q;

};

用栈实现队列

class MyQueue {

public:

MyQueue() {

}

void
push(int x) { //将元素放到栈底

stack<int> temp;

while(s.empty() == false){

temp.push(s.top());

s.pop();

}

s.push(x);

while(temp.empty() == false){

s.push(temp.top());

temp.pop();

}

}

int
pop() {

int a = s.top();

s.pop();

return a;

}

int
peek() {

return s.top();

}

bool
empty() {

return s.empty();

}

private:

stack<int> s, temp;

};

实现strstr函数

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回  -1。

整数a和b，求a的b次方的最后三位数

.

• 算法题：将字符串转换成人民币大写（半小时后发邮箱）

https://blog.csdn.net/forlove_you/article/details/51248978

• 如何删除map中的奇数节点

遍历删除，考虑迭代器失效问题

1. for(ITER
   iter=mapTest.begin();iter!=mapTest.end();++iter)

{ if（iter指向的元素是奇数）

mapTest.erase(iter);

} //错误，erase会让迭代器会失效！

1. for(ITER iter=mapTest.begin();iter!=mapTest.end();)

{ if（iter指向的元素是奇数）

mapTest.erase(iter++);//正确，iter值传递之后，再++；

}

1. for(ITER
   iter=mapTest.begin();iter!=mapTest.end();)

{ if（iter指向的元素是奇数）
iter=mapTest.erase(iter);//
erase() 成员函数返回下一个元素的迭代器

}

 

翻转数组和恢复翻转数组

找分界点：找分界点可以用一个指针来，遍历找到第一个下降的点，如果没有找到，说明数组已经是排好的。

二分法：

普通

int binary_search(int*arr,int l,int h,int key){

while (l <= h){

int m = l + (h - l)
/ 2;

if (arr[m] == key)

return m;

else if (arr[m] >
key)

h = m - 1;

else l = m + 1;

}

return -1;

}

lower_bound

int binary_search(int*arr, int l, int h, int key){//找到第一个插入的位置

while (l <h){

int m = l + (h - l)
/ 2;

if (arr[m] >=
key)

return h=m;

else l = m + 1;

}

}

排序

插入排序

void insert_sort(int* arr, int l, int h) {

for (int i = l + 1; i <=
h; ++i)

for (int j = i; j
> 0; --j){

if (arr[j]
< arr[j - 1]){

iter_swap(&arr[j],
&arr[j-1]);

}

}

}

快速排序

int partition(int* arry, int l, int h){

int pivot = arry[h];

while (true){

while (arry[l] <
pivot) ++l;

while (arry[h] > pivot)
--h;

if (!(l < h))
return l;

iter_swap(&arry[l],
&arry[h]);

++l;

--h;

}

}

void quick_sort(int* arr, int l, int h) {

if (l >= h) return;

int m = partition(arr, l,
h);

quick_sort(arr, l, m-1);

quick_sort(arr, m , h);

}

堆排序

void percDown(int* arr, int l, int h, int k) {

int child, tmp;

for (tmp = arr[k]; (k - l) *
2 + l + 1 <= h; k = child) {

child = (k - l) * 2
+ l + 1;

if (child + 1 <=
h && arr[child] < arr[child + 1]) ++child;

if (arr[child] >
tmp) arr[k] = arr[child];

else break;

}

arr[k] = tmp;

}

void heap_sort(int* arr, int l, int h) {

for (int i = l + (h - l) /
2; i >= l; --i) {

percDown(arr, l, h,
i);

}

for (int i = h; i >= l;
--i) {

int tmp = arr[l];

arr[l] = arr[i];

arr[i] = tmp;

percDown(arr, l, i -
1, l);

}

}

归并排序

void merge_sort(int* arr, int l, int h) {

if (l == h) return;

int m = l + (h - l) / 2;

merge_sort(arr, l, m);

merge_sort(arr, m + 1, h);

int * tmp = new int[h - l +
1];

int i = l, j = m + 1, k = 0;

while (i <= m &&
j <= h) {

if (arr[i] <= arr[j]) tmp[k++] = arr[i++];

else tmp[k++] =
arr[j++];

}

while (i <= m) tmp[k++] =
arr[i++];

while (j <= h) tmp[k++] =
arr[j++];

for (int i = l; i <= h;
++i) {

arr[i] = tmp[i - l];

}

delete []tmp;

}

冒泡排序

void bubble_sort(int* arr, int l, int h) {

for (int i = l; i <= h;
++i) {

for (int j = l; j
<= h - i + l - 1; ++j) {

if (arr[j]
> arr[j + 1]) {

int
tmp = arr[j];

arr[j]
= arr[j + 1];

arr[j
+ 1] = tmp;

}

}

}

}

选择排序

void select_sort(int* arr, int l, int h) {

for (int i = l; i <= h;
++i) {

int id = i;

for (int j = i + 1;
j <= h; ++j) {

if (arr[j]
< arr[id]) {

id
= j;

}

}

int tmp = arr[i];

arr[i] = arr[id];

arr[id] = tmp;

}

}

手写String

class String{

public: 
String(const char *str = NULL); //普通构造函数

String(const String &other);  //拷贝构造函数

String & operator=(String
&other) ; //赋值函数

~String(void); //析构函数

private:  char* m_str;

};

//普通构造函数

String::String(const char* str){

if(str==NULL) //如果str为NULL，存空字符串{

m_str = new
char[1]; //分配一个字节

*m_str = ‘\0′; //赋一个’\0′

}else{

str = new
char[strlen(str) + 1];//分配空间容纳str内容

strcpy(m_str, str); //复制str到私有成员m_str中

}

}

//析构函数

String::~String(){

if(m_str!=NULL) //如果m_str不为NULL，释放堆内存{

delete [] m_str;

m_str = NULL;

}

}

//拷贝构造函数

String::String(const String &other){

m_str = new
char[strlen(other.m_str)+1]; //分配空间容纳str内容

strcpy(m_str, other.m_str); //复制other.m_str到私有成员m_str中

}

//赋值运算符函数

String & String::operator=(String
&other){

if(this == &other) //若对象与other是同一个对象，直接返回本{

return *this

}

delete [] m_str; //否则，先释放当前对象堆内存

m_str = new
char[strlen(other.m_str)+1]; //分配空间容纳str内容

strcpy(m_str, other.m_str); //复制other.m_str到私有成员m_str中

return *this；

}

memcpy函数的实现

void *memcpy(void *dest, const
void *src, size_t count) {

char *tmp = dest;

const char *s = src;

while (count--)

*tmp++ = *s++;

return dest;

}

strcpy函数的实现

char *strcpy(char *dst,const
char *src) {

assert(dst != NULL
&& src != NULL);

char *ret = dst;

while((* dst++ = * src++) != '\0') ;

return ret;

}

BST的第K小的节点

http://www.cnblogs.com/grandyang/p/4620012.html

判断链表是否有环，如果有，返回环的入口节点；求环的长度

思路：采用两个指针walker和runner，walker每次移动一步而runner每次移动两步。当walker和runner第一次相遇时，证明链表有环 ；然后采用两个指针，一个从表头出发，一个从相遇点出发，一次都只移动一步，当二者相等时便是环入口的位置；

ListNode
*detectCycle(ListNode *head) {

auto walker = head;

auto runner = head;

while(runner &&
runner->next)//设置快慢指针，并找到相遇点

{

walker = walker->next;

runner = runner->next->next;

if(walker == runner)

break;

}

if(!runner || !runner->next) //单链表无环

return nullptr;

auto headWalker = head;//从头节点出发

auto crossWalker = walker; //从相遇点出发

while(headWalker != crossWalker)

{

headWalker = headWalker->next;

crossWalker = crossWalker->next;

}

return headWalker; //环的入口点

}

• 求一个数组逆序对的个数

基于归并排序的思想统计逆序对：先把数组分割成子数组，再子数组合并的过程中统计逆序对的数目。统计逆序对时，先统计子数组内部的逆序对的数目，再统计相邻子数组的逆序对数目。

翻转数组和恢复翻转数组

找分界点：找分界点可以用一个指针来，遍历找到第一个下降的点，如果没有找到，说明数组已经是排好的。

给定链表头指针，中间结点的指针，如何删除单链表中间节点

快慢指针找中间值，

https://blog.csdn.net/cherrybomb1111/article/details/79803972

判断两个单链表是否相交，相交则找出两个链表的第一个公共子节点

思路1：分别遍历两个链表，得到分别对应的长度。然后求长度的差值，把较长的那个链表向后移动这个差值的个数，然后一一比较即可。

思路2：让两个指针分别从两条链表的开头开始往后遍历，当其中一条遍历到末尾时，我们将其跳到另一个条链表的开头继续遍历，一直遍历到两个指针相等为止。相等只有两种情况，一种情况是在交点处相遇，另一种情况是在各自的末尾的空节点处相等。，

为什么一定会相等呢，因为两个指针走过的路程相同，是两个链表的长度之和，所以一定会相等。

ListNode *getIntersectionNode(ListNode
*headA, ListNode *headB) {

if (!headA || !headB) return NULL;

ListNode *a = headA, *b = headB;

while (a != b) {

a = a ? a->next : headB;

b = b ? b->next : headA;

}

return a;

}

r行c列的0,1数组，找到最大的全为1的正方形？

https://blog.csdn.net/nk_test/article/details/48901853

• 连续子数组最大和问题(和最大的连续子序列的和)
  • excel中，标志列的如AA,AZZ ,BS，求这些列到底是第几列。26进制转换问题：
  • Int transfer(const string&
    s){
  • int res=0;
  • for(int
    i=0;i<s.length();i++){
  • result=(result*26+(s[i]-'a'+1));
  • }
  • return res;
  • }

二叉树两个节点的最近公共祖先，没答出来

https://www.cnblogs.com/grandyang/p/4641968.html

去掉字符串中的空格字符

https://blog.csdn.net/qian2213762498/article/details/81705647

void
trim(string &s)

{

int index = 0;

if( !s.empty())

{

while( (index = s.find(' ',index)) != string::npos)

{

s.erase(index,1);

}

}

}

删除字符串开始和结尾处的空格，并将中间的多个连续的空格合并成一个。

void
FormatString(char str[], int len)

{

if(str
== NULL || len <= 0)

return;

int i = 0, j = 0;

while(str[i]
== ' ')//开头的空格

i++;

while(str[i]
!= '\0')

{

if(str[i]
== ' ' && (str[i+1] == ' ' || str[i+1] == '\0'))

{

//中间或者结尾的空格

i++;

continue;

}

str[j++]
= str[i++];

}

str[j]
= '\0';

}

char *s1, const char *s2，删除s1中s2出现过的字符

思路：用一个256大小的数组，每个表示字符的状态，把s2读一遍，把每个字母对应的数字变为1表示存在，然后遍历s1，把状态为1的删掉

https://blog.csdn.net/m0_38099899/article/details/81231886

单链表判环

设两个指针，一个每次走一步的慢指针和一个每次走两步的快指针，如果链表里有环的话，两个指针最终肯定会相遇。

是不是：bool hasCycle(ListNode *head) {

ListNode *slow = head, *fast = head;

while (fast && fast->next) {

slow = slow->next;

fast = fast->next->next;

if (slow == fast) return true;

}

return false;

}

找环入口：ListNode *detectCycle(ListNode *head) {

ListNode *slow = head, *fast = head;

while (fast && fast->next) {

slow = slow->next;

fast = fast->next->next;

if (slow == fast) break;

}

if (!fast || !fast->next) return
NULL;

slow = head;

while (slow != fast) {

slow = slow->next;

fast = fast->next;

}

return fast;

}

判断一个数是不是回文数

bool
isPalindrome(int x) {

if (x < 0 || (x % 10 == 0 &&
x != 0)) return false;

int revertNum = 0;

while (x > revertNum) {

revertNum = revertNum * 10 + x %
10;

x /= 10;

}

return x == revertNum || x == revertNum
/ 10;

}

http://www.cnblogs.com/grandyang/p/4125510.html

求一个集合的所有子集，递归实现，非递归实现

http://www.cnblogs.com/grandyang/p/4309345.html

vector<vector<int>
> subsets(vector<int> &S) {

vector<vector<int> >
res(1);

sort(S.begin(), S.end());

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

int size = res.size();

for (int j = 0; j < size; ++j) {

res.push_back(res[j]);

res.back().push_back(S[i]);

}

}

return res;

}

旋转有序数组的二分查找  http://www.cnblogs.com/grandyang/p/4325648.html

无重复数字：int search(vector<int>gt;& nums, int target) {

int left = 0, right = nums.size() - 1;

while (left <= right) {

int mid = left + (right - left) /
2;

if (nums[mid] == target) return
mid;

else if (nums[mid] <
nums[right]) {

if (nums[mid] < target
&& nums[right] >= target) left = mid + 1;

else right = mid - 1;

} else {

if (nums[left] <= target
&& nums[mid] > target) right = mid - 1;

else left = mid + 1;

}

}

return -1;

}

有重复数字：http://www.cnblogs.com/grandyang/p/4325840.html

bool search(int A[], int n, int target) {

if (n == 0)
return false;

int left = 0,
right = n - 1;

while (left
<= right) {

int mid =
(left + right) / 2;

if (A[mid]
== target) return true;

else if
(A[mid] < A[right]) {

if
(A[mid] < target && A[right] >= target) left = mid + 1;

else
right = mid - 1;

} else if
(A[mid] > A[right]){

if
(A[left] <= target && A[mid] > target) right = mid - 1;

else
left = mid + 1;

} else
--right;

}

return false;

}

删除数组中的重复元素

有序数组中去除重复项  http://www.cnblogs.com/grandyang/p/4329128.html

int
removeDuplicates(vector<int>& nums) {

if (nums.empty()) return 0;

int j = 0, n = nums.size();

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

if (nums[i] != nums[j]) nums[++j] =
nums[i];

}

return j + 1;

}

实现一个计算器计算简单的表达式字符串

+-： http://www.cnblogs.com/grandyang/p/4570699.html

+-*/:  http://www.cnblogs.com/grandyang/p/4601208.html

+-*/():  http://www.cnblogs.com/grandyang/p/8873471.html

memcopy和memove的区别？memcopy和memove的实现？

https://blog.csdn.net/li_ning_/article/details/51418400

都是拷贝一定长度的内存的内容，区别是当内存发生局部重叠的时候，memmove保证拷贝的结果是正确的，memcpy不保证拷贝的结果的正确。

memcpy函数的实现

void *memcpy(void *dest, const
void *src, size_t count) {

char *tmp = dest;

const char *s = src;

while (count--)

*tmp++ = *s++;

return dest;

}

给定一个二叉树，节点值为0-9，从根节点到叶子结点组成一个数，求二叉树所有组成的数的和

https://blog.csdn.net/i_am_bird/article/details/78173454

 

Rand()的范围是多少，要是生成大于范围的的随机数怎么实现

srand(time(0)); rand(); 0~32767

 

写一个二叉树翻转，然后写个测试(为了写这个测试我还白送一个二叉树层次遍历emmm)

https://blog.csdn.net/qq_29762941/article/details/80909342

测试：反转两次，再和原来的二叉树比较是否相同

手写堆排序，然后分析下建堆时间复杂度(从n/2开始向上建堆的话是O(n))

https://blog.csdn.net/yuzhihui_no1/article/details/44258297

 

strcpy安全性，如何实现安全，strnpy,写一下并测试，

https://blog.csdn.net/ZH___xin/article/details/51985562

 

写sql语句(A表存储有每个电话号码当月通话记录，表B是电话号码集合，求表B每个号码通话次数)，大概就是比较简单的连表查询，加count

select B.telno, count(B.telno)

from A right join B

where A.telno = B.telno

group by B.telno

 

假设上面题中A B两个表存在文件，怎么编程统计？ 我答的使用hashmap存储电话和次数，时间复杂度呢？
只需要扫描两个文件各一遍O(n+m)

两字符串最长公共子串， 最长公共子序列

https://blog.csdn.net/u012426298/article/details/82796660

打印二叉树每层最右边的节点 层序遍历 LeetCode 199

http://www.cnblogs.com/grandyang/p/4392254.html

 

手写代码 回形矩阵

顺时针回形打印矩阵的元素LeetCode 54

http://www.cnblogs.com/grandyang/p/4362675.html

判断在一个矩阵中是否存在一条包含某字符串所有字符的路径

https://blog.csdn.net/qq_21997625/article/details/84640353

 

3sum 数组中三数之和为0的所有三元组 leetcode 15

微信的附近的人这个功能，如果让你实现，你准备怎么做，

地理位置网格分块，存块ID，然后四叉搜索。你的经纬度换算成网格ID，同网格的人撸出来，临近网格的人撸出来，搞定。把地理位置分块，怎么把经纬度转化成网格 ID 呢。本质上就是hash

客户端固定时间发送经纬度（x,y）到服务器s，服务器存储每个登陆的用户的经纬度到表t中，表t按照经纬度分表，将地图分成一个个的小格子。当用户点击“附近的人”时，对用户（x,y）进行计算，最多一次查询其中的4个格子（子表），计算两点间距离获取结果（有点像桶排序）。性能上可以将表t替换为内存结构，容灾即可。
从实际的微信提供的功能来看，附近的人并不太多，估计是其对地图划分的格子很小。

MongoDB的LBS功能实现附近的人

https://www.nowcoder.com/discuss/165952?type=0&order=0&pos=414&page=1

微信小程序团队一共有 n 名成员，决定出去秋游，在海边遇到出租摩托艇的杰克马，马先生手上有 m
辆待出租的摩托艇，价格分别是 b1 、b2 ... bm;

由于习惯了微信支付，团队中每个人身上的现金都有限，分别是 a1 a2 ... an，对了，一起出门的老板还带有 S 元的团队经费，这个经费是每个人都可以使用的

那么考虑以下两个场景

场景1

团队成员都很有爱，都愿意借钱给其他同事，那么这时候团队最多能租到多少摩托艇

//贪心法；把所有的钱收集起来，按摩托艇的价格从低到高租借摩托艇

intisAll(int a[n], int b[m], intS){

                int sum=0;

                for(int i=0;i<n；++i)

                    sum+=a[i];

                sum+=S;

        sort(a,a+n);

        inti
= 0;

        while(sum
- m[i] > 0) {

            sum
-= m[i];

            i++;

        }

        returni;

    }

场景2

团队成员都十分小气，是不愿意借钱给别人的,那么请考虑以下两个问题

//问题一 老板是否能想到一个策略，使得所有人都能租到摩托艇？

//贪心法；钱少的人租借便宜的摩托艇，补贴

public
static boolean isAll(int[] n, int[] m, int S){

        if
(n.length > m.length) { return false; }

        Arrays.sort(n);
Arrays.sort(m);

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

            int
need = n[i] - m[i];

            if
(need < 0)

            S
+= need;

        }

        return
S >= 0;

    }

//问题二 请问给出一个策略

// - 使得整个团队租到最多的摩托艇

// - 在租到最多摩托艇的情况下，整体的支出尽量的少

//二分法+贪心

private static int n[];

    private
static int m[];

    private
static int S;

    public
static int[] isAll(int[] n, int[] m, int S){

        Arrays.sort(n);

        Arrays.sort(m);

        Main.n
= n; Main.m = m; Main.S = S;

        int
l =0, r = m.length; //摩托艇的数量

        while
(l < r)

        {

            int
mid = l + r + 1 >> 1;

            if
(can(mid)) { l = mid; }

            else
{ r = mid - 1; }

        }

        int
ans = 0;

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

            ans
+= m[i];

        }

        return
new int[] {l, ans};

    }

   private
static boolean can(int count) {

        int
tmpS = S;

        for
(int i = count-1,j = n.length-1; i>=0; i--, j--) {//让最多钱的人买最贵的摩托艇

            if
(n[j] < m[i]) {

                tmpS
-= (m[i] - n[j]);

            }

            if
(tmpS < 0) { return false; }

        }

        return
true;

    }

判断一个字符串是不是两个有序的字符串交错组成的。 Leetcode
97

编程题：递增数组中找两个数和为某个固定值。设计测试用例 Leetcode 1

给你一个数组和数组元素的个数，求平均值。

int avg(int x, int y)

{

return (x & y) + ((x ^ y) >> 1);

}

两个非常大的数相加 Leetcode 415