题目1 孩子们的游戏(圆圈中最后剩下的数)[题目链接](https://www.nowcoder.com/practice/f78a359491e64a50bce2d89cff857eb6?tpId=13&tqId=11199&tPage=3&rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
思路1 :模拟，很容易想到用循环链表模拟，选择何种形式来实现循环链表的功能呢？最开始想的是用数组来模拟循环链表，用一个数组来记录数字是否出局，若出局则跳过这个数字。 看到一个比较巧妙的思路，可以用一个队列来模拟循环链表，利用队列先进先出的特点，前面报数非为m的数依次加入队列，相当于一个滑动窗口，当报数为m-1时，直接出栈。
代码1 ： 数组模拟(代码略复杂，下次回来改)
class Solution {
public:
int LastRemaining_Solution(int n, int m)
{
if( n<=0 || m<=0)
return -1 ;
if (n == 1)
return 0;
int exit = 0 ;
int Count = 0, index=0;
bool isExit[n] ;
for(int i=0; i<n;i++)
isExit[i] = false ;
while(exit <n-1)
{
if(index == n)
index = 0 ;
//cout << "Count is " << Count << endl ;
//cout <<"index is " << index << endl ;
if(Count == m-1)
{
//cout <<"exit " << index << endl ;
isExit[index] = true ;
exit ++ ;
index ++ ;
if(index == n)
index = 0 ;
while(isExit[index] == true)
{
index ++ ;
if(index == n)
index = 0;
}
Count = 0;
}
else
{
index ++ ;
if(index == n)
index = 0 ;
while(isExit[index] == true)
{
index ++ ;
if(index == n)
index = 0;
}
Count ++ ;
}
}
for(int i=0; i<n; i++)
if(isExit[i] == false)
return i ;
}
};
代码2（队列模拟）
class Solution {
public:
int LastRemaining_Solution(int n, int m)
{
if(n <=0 || m <=0)
return -1 ;
if(n == 1)
return 0 ;
queue <int> tmp ;
for(int i=0; i<n ;i++)
tmp.push(i) ;
while(tmp.size() > 1)
{
for(int i=0; i<m-1; i++)
{
int front = tmp.front() ;
tmp.pop() ;
tmp.push(front) ;
}
tmp.pop() ;
}
return tmp.front() ;
}
};
思路2 ：找规律（具体数学中学过，待补）
题目2 扑克牌顺子[题目](https://www.nowcoder.com/practice/762836f4d43d43ca9deb273b3de8e1f4?tpId=13&tqId=11198&rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
题意：判断5张牌，是否组成顺子（大小王用0，表示，A表示0，J表示11）。
思路1：判断是否为顺子：（1） 长度为5 （2）除0外没有重复数字（3）max -min <5.推广到一般情况顺子长度为k, max -min <k。
思路2：（1）除0外没有重复数字 （2）排序后，用num[i]-num[i-1]-1记录缺几张牌，计算0的个数（可变牌数），若可变牌>=缺的牌，则可组成顺子。
代码1
class Solution {
public:
bool IsContinuous( vector<int> numbers ) {
int size = numbers.size() ;
if(size != 5)
return false ;
int Count[14] ={0} ;
int Max = -1, Min=14 ;
for(int i=0; i<size; i++)
{
Count[numbers[i]]++ ;
if(numbers[i] == 0)
continue ;
if(Count[numbers[i]] > 1)
return false ;
if(numbers[i] > 13 || numbers[i] < 0)
return false ;
if(numbers[i] > Max)
Max = numbers[i] ;
if(numbers[i] < Min)
Min = numbers[i] ;
}
if(Max - Min < 5)
return true ;
return false ;
}
};
代码2
class Solution {
public:
bool IsContinuous( vector<int> numbers ) {
int size = numbers.size() ;
if(size <=0)
return false ;
sort(numbers.begin(), numbers.end()) ;
int Count=0, lost=0, index;
for(int i=0; i<size; i++)
{
if(numbers[i] == 0)
{
Count ++ ;
}
if(numbers[i] >0)
{
index = i ;
break ;
}
}
for(int i=index+1; i< size; i++)
{
if(numbers[i] == numbers[i-1])
return false ;
else
lost += numbers[i]-numbers[i-1]-1 ;
}
if(Count >= lost)
return true ;
return false ;
}
};
题目3 翻转单词顺序列 [题目](https://www.nowcoder.com/practice/3194a4f4cf814f63919d0790578d51f3?tpId=13&tqId=11197&rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking)
题意：将单词序列翻转，如：“I am a student.”翻转后为“student. a am I”。
思路1 ：(1)用指针p1扫描原字符串，并记录每个单词长度len，遇到空格时停止；(2)p2指向新字符串尾部;(3)p1复制给p2,p1向后走len步，p2向后走len步(4) p1+len回到空格处，将空格复制到新字符串中 。repeat上述过程，直到字符串结束。
思路2： 单指针从前往后扫描，巧妙利用string的连接操作。
代码1 ：
class Solution {
public:
string ReverseSentence(string str) {
int length = str.length() ;
if(length <=1)
return str ;
string res=str ;
int pstr=0, pres=length-1,pstart=0;
int len = 0 ;
while(str[pstr] != ' ' && pstr < length)
{
pstr ++ ;
len ++ ;
if(str[pstr] ==' ')
{
pstart = pstr - len ;
pstr -=1 ;
while(pstr>=pstart)
{
res[pres--]=str[pstr--];
}
pstr += len+1 ;
res[pres--] = str[pstr++] ;
len = 0 ;
}
if(pstr == length-1)
{
pstart = pstr - len ;
while(pstr>=pstart && pres >=0)
{
res[pres--]=str[pstr--];
}
break ;
}
}
return res ;
}
};
代码2：
class Solution {
public:
string ReverseSentence(string str) {
int length = str.length() ;
if(length <= 1)
return str ;
string res="", tmp="" ;
for(int i=0; i<length; i++)
{
if(str[i]==' ')
{
res =" "+tmp+res ;
tmp="";
}
else tmp += str[i] ;
}
if(tmp.size()) res = tmp + res;
return res ;
}
};
题目4 左旋转字符串 题目链接
题意：str = XY 求输出YX
思路1 ：直接利用字符串特性，取出X,Y，组合成YX
思路2：假设字符串abcdef，n=3，设X=abc，Y=def，所以字符串可以表示成XY，如题干，问如何求得YX。假设X的翻转为X，XT=cba，同理YT=fed，那么YX = (XTYT)T，三次翻转后可得结果。
代码1：
class Solution {
public:
string LeftRotateString(string str, int n) {
int length = str.length() ;
if(length <= 1)
return str ;
n = n%length ;
string tmp = str.substr(0,n);
string tmp2 =str.substr(n, length-n);
return tmp2+tmp;
}
};
代码2：
class Solution {
public:
void fun(string &s,int start,int end)
{
char temp;
while(start<end)
{
temp=s[start];
s[start]=s[end];
s[end]=temp;
start++;
end--;
}
}
string LeftRotateString(string str, int n) {
int len=str.length();
if(0==len || 0==n)
return str;
string &temp=str;
fun(temp,0,n-1);
fun(temp,n,len-1);
fun(temp,0,len-1);
return str;
}
};
题目5 和为S的两个数字题目
题意：递增数列，求两个数字和为S，若有多组解，求使得乘积最小的那组。
思路：左右指针法，用两个指针从两头向中间逼近，a+b=s，a,b相差越大，a*b越小。
代码：
class Solution {
public:
vector<int> FindNumbersWithSum(vector<int> array,int sum) {
vector<int> res ;
int size = array.size() ;
int plow = 0, phigh = size -1 ;
while(plow <= phigh)
{
int s= array[plow] + array[phigh] ;
if(s < sum)
{
plow ++ ;
}
if(s > sum)
{
phigh -- ;
}
if(s == sum)
{
res.push_back(array[plow]) ;
res.push_back(array[phigh]) ;
return res ;
}
}
return res ;
}
};
题目6 和为S的连续正数序列题目
题意：输出求和为S的连续正数序列，序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序
思路 ：双指针法，两个指针分别放在数组的第一个数字和第二个数字处，比较数字的和来移动指针，cur = (plow + phigh)*(phigh-plow+1)/2 ，cur>s, high 向左移，cur <s plow右移（递增数列的性质），cur=s, 得到一组解，plow右移（或者high 左移)继续找另一组解。 因为是等差数列，所以可以直接用公式求和。
推广到一般情况： 正数数组，求正数子序列使得 和为s。可以用前缀和数组来计算，plow 到phigh之间的数字和可以表示为 sum[phigh]-sum[plow-1]。同样地用双指针，只要前缀和数组满足递增数列就可以cur>s, high 向左移，cur <s plow右移（递增数列的性质），cur=s, 得到一组解，plow右移（或者high 左移)继续找另一组解移动指针了。如果前缀和数组满足递增数列，就只能暴力遍历o(n2)了
代码
class Solution {
public:
vector<vector<int> > FindContinuousSequence(int sum) {
vector<vector<int> > res ;
int plow =1, phigh = 2 ;
while(plow < phigh)
{
int cur = (plow + phigh)*(phigh-plow+1)/2 ;
if(cur == sum)
{
vector<int > array ;
for(int i=plow; i<=phigh; i++)
{
array.push_back(i) ;
}
res.push_back(array) ;
array.clear() ;
plow ++ ;
}
if(cur < sum)
phigh ++ ;
if(cur > sum)
plow ++ ;
}
return res ;
}
};
题目7 数组中只出现一次的两个数字题目
题意： 数组中只有两个数字只出现一次，剩下的都出现两次，找到那两个数字。
思路： 初看这题的时候，想到了异或操作， 任何数和0异或结果都是自身，相同的数异或为0。利用这个特性，如果数组中只有一个数字，那么可以找到那个数字。现在有两个这样的数字该怎么办呢？分组（分两组分别找），设只出现一次的数字是a和b,先把所有数字异或一遍，得到结果a xor b。a xor b二进制为1的位表明 a,b 在该位一个为0，一个为1. 利用这个性质把数字分为两组（相同的数字肯定在一组），a,b肯定被分在不同组，然后组内异或就可以得到结果了。
代码
class Solution {
public:
int findFirst1(int num)
{
int bit = 1;
while((num & 1) == 0 && bit < 32) //记得加括号，运算符优先级 & 比==优先级低
{
bit ++ ;
num = num >> 1 ;
}
return bit ;
}
bool isBit1(int num, int bit)
{
for(int i=1; i<bit; i++)
num = num >> 1 ;
return (num & 1) == 1 ;
}
void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {
int size = data.size() ;
if(size == 2)
{
num1 = &data[0] ;
num2 = &data[1] ;
}
int res = 0 ;
for (int i=0; i<size; i++)
{
res ^= data[i] ;
}
int bit = findFirst1(res) ;
int n1 = 0, n2 = 0;
for (int i=0; i< size; i++)
{
if (isBit1(data[i], bit))
{
n1 = n1^data[i];
}
else
n2 = n2^data[i] ;
}
*num1 =n1 , *num2 =n2 ;
}
};
题目 8 平衡二叉树
题意：判断一棵树是不是平衡二叉树
思路： 递归判断树的深度差是否为1， skills 深度大于0表示正常的深度， <0表示不平衡。
代码：
class Solution {
public:
int getDepth(TreeNode *root, int depth)
{
if (depth < 0 )
return -1 ;
if (root == nullptr)
return depth ;
int leftDepth = getDepth(root->left, depth+1);
int rightDepth = getDepth(root->right,depth+1 ) ;
int diff = leftDepth - rightDepth ;
if (diff >1 || diff <-1)
return -1 ;
else return max(leftDepth, rightDepth) ;
}
bool IsBalanced_Solution(TreeNode* pRoot) {
int depth = getDepth(pRoot, 0) ;
if (depth < 0)
return false ;
else
return true ;
}
};
题目 9 二叉树的深度
代码：
class Solution {
public:
int getDepth(TreeNode *root, int depth)
{
if(root == nullptr)
return depth;
int leftDepth = getDepth(root->left, depth+1) ;
int rightDepth = getDepth(root->right, depth+1) ;
return max(leftDepth, rightDepth);
}
int TreeDepth(TreeNode* pRoot)
{
return getDepth(pRoot, 0) ;
}
};
题目10 数字在排序数组中出现的次数
思路：看见数组有序就想到 二分查找， 比较巧妙的思路是 k是整数，搜索k+0.5和k-0.5应该插入的位置，两者相减就得到了。
代码：
class Solution {
public:
int GetNumberOfK(vector<int> data ,int k) {
return biSearch(data, k+0.5) - biSearch(data, k-0.5) ;
}
private:
int biSearch(const vector<int> & data, double num){
int s = 0, e = data.size()-1;
while(s <= e){
int mid = (e - s)/2 + s;
if(data[mid] < num)
s = mid + 1;
else if(data[mid] > num)
e = mid - 1;
}
return s;
}
};
题目11 两个链表的第一个公共节点
思路：最开始的时候连题意都没有弄明白。先弄懂题意，两个链表若有公共节点的话，会表现像一个Y字，问题是两个链表长度不一样，若链表长度一样直接一一比较直到两个指针相同。skills :让长的链表先走 k步（k为两链表长度之差），然后两个链表一起走。快慢指针在链表操作中很常见，求链表的倒数第k个节点，也是先让一个指针走k步，然后另一个指针从头和当前指针一起走，当前指针走到尾节点的时候，头指针正好指向倒数第k个节点。
代码
class Solution {
public:
int GetListLength(ListNode * head)
{
int length = 0 ;
while(head)
{
length ++ ;
head = head->next ;
}
return length ;
}
ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
int len1 = GetListLength(pHead1) ;
int len2 = GetListLength(pHead2) ;
int diff , flag;
if (len1 > len2)
{
diff = len1 - len2 ;
flag =1 ;
}
else {
diff = len2 - len1 ;
flag = 2 ;
}
if (flag == 1)
{
for (int i=1; i<= diff; i++)
pHead1 = pHead1->next ;
}
if (flag == 2)
{
for (int i=1; i <=diff; i++)
pHead2 = pHead2->next ;
}
while (pHead1 != nullptr && pHead2 != nullptr && pHead1 != pHead2)
{
pHead1 = pHead1->next ;
pHead2 = pHead2->next ;
}
return pHead1 ;
}
};
题目 12 数组中的逆序对题目
思路：能想到归并排序这题就出来啦，记得归并的时候从后到前，从前到后会有问题。（如：1 2 7 8、4 5 9 10归并的时候从右到左，8 可以轻易判断4，5都比8小，但是从 左到右的时候， 4，5已经归并进去了，9，10大于8，这样子计数是有问题的）。主代码中不要写太多递归，容易栈溢出
代码
class Solution {
public:
int InversePairs(vector<int> data) {
if(data.size()<2) return 0;
vector<int> copy;
for(int i=0;i<data.size();i++){
copy.push_back(data[i]);
}
long long count=InversePairsCore(data,copy,0,data.size()-1);
copy.clear();
return count%1000000007;
}
long long InversePairsCore(vector<int> &data,vector<int> ©,int begin,int end){
if(begin==end){
copy[begin]=data[begin];
return 0;
}
int L=(end-begin)/2;
long long left=InversePairsCore(copy,data,begin,begin+L);
long long right=InversePairsCore(copy,data,begin+L+1,end);
int i=begin+L;
int j=end,inxcopy=end;
long long count=0;
while(i>=begin && j>=begin+L+1){
if(data[i]>data[j]){
copy[inxcopy--]=data[i--];
count+=j-begin-L;
}else copy[inxcopy--]=data[j--];
}
//for(i=begin;i<=end;i++) copy[i]=data[i];
for(;i>=begin;i--) copy[inxcopy--]=data[i];
for(;j>=begin+L+1;j--) copy[inxcopy--]=data[j];
return left+right+count;
}
};
题目13 第一个只出现一次的字母
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.
思路： hash 表，桶排序。
代码：
class Solution {
public:
int FirstNotRepeatingChar(string str) {
int len = str.length() ;
if(len <= 0)
return -1 ;
int res[100] ;
for(int i=0; i<100; i++)
res[i] = 0;
for(int i=0; i< len; i++)
{
res[str[i] -'A'] ++ ;
}
for(int i=0; i< len; i++)
{
if(res[str[i] -'A'] == 1)
return i ;
}
return -1;
}
};
题目14 丑数
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
思路：最开始拿到这个题目的时候，第一反应是找规律（希望能发现数字间的规律）结果发现没有规律，不要直接陷入找规律中。有些规律可能不是以数字的形式呈现，可以多考虑堆栈队列等数据结构。
丑数是质因子只有2、3、5的数，也就是说每个丑数是由原来的丑数乘以2、3、5得到的，1乘以2、3、5得到2，3，5 依次乘以2，3，5得到4，6，10 ，6 ，9，15，10，15，25。这样得到的序列不是有序的且有重复。可以用3个队列来维护*2，*3，*5的结果。
1）丑数数组： 1
乘以2的队列：2
乘以3的队列：3
乘以5的队列：5
选择三个队列头最小的数2加入丑数数组，同时将该最小的数乘以2,3,5放入三个队列；
（2）丑数数组：1,2
乘以2的队列：4
乘以3的队列：3，6
乘以5的队列：5，10
选择三个队列头最小的数3加入丑数数组，同时将该最小的数乘以2,3,5放入三个队列；
（3）丑数数组：1,2,3
乘以2的队列：4,6
乘以3的队列：6,9
乘以5的队列：5,10,15
选择三个队列头里最小的数4加入丑数数组，同时将该最小的数乘以2,3,5放入三个队列；
（4）丑数数组：1,2,3,4
乘以2的队列：6，8
乘以3的队列：6,9,12
乘以5的队列：5,10,15,20
选择三个队列头里最小的数5加入丑数数组，同时将该最小的数乘以2,3,5放入三个队列；
1.为什么分三个队列？
丑数数组里的数一定是有序的，因为我们是从丑数数组里的数乘以2,3,5选出的最小数，一定比以前未乘以2,3,5大，同时对于三个队列内部，按先后顺序乘以2,3,5分别放入，所以同一个队列内部也是有序的；
2.为什么比较三个队列头部最小的数放入丑数数组？
因为三个队列是有序的，所以取出三个头中最小的，等同于找到了三个队列所有数中最小的。
实现思路：
我们没有必要维护三个队列，只需要记录三个指针显示到达哪一步；
代码：
class Solution {
public:
int GetUglyNumber_Solution(int index) {
if (index < 7)
return index ;
vector<int> res(index) ;
res[0] = 1 ;
int p2=0, p3=0, p5=0 ;
for(int i=1; i< index; i++)
{
res[i] = min(res[p2]*2, min(res[p3]*3, res[p5]*5)) ;
if(res[p2]*2 == res[i]) p2++ ;
if(res[p3]*3 == res[i]) p3++ ;
if(res[p5]*5 == res[i]) p5++ ;
}
return res[index -1] ;
}
};
1143
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
