100题

最新推荐文章于 2021-11-17 09:45:54 发布

empyrealwd

最新推荐文章于 2021-11-17 09:45:54 发布

阅读量758

点赞数

文章标签： numbers permutation input delete matrix null

本文链接：https://blog.csdn.net/empyrealwd/article/details/6424973

版权

http://zhedahht.blog.163.com/blog/static/25411174200712895228171/

用c++写带min（）的stack。

http://zhedahht.blog.163.com/blog/static/254111742007219147591/

求子数组的最大和

http://zhedahht.blog.163.com/blog/static/254111742007228357325/

在二元树中找出和为某一值的所有路径

http://zhedahht.blog.163.com/blog/static/2541117420072432136859/

查找最小的k个元素（可以用快排思想，也可以用set和multiset来实现），STL中map和multiset是红黑树实现的。看代码

http://zhedahht.blog.163.com/blog/static/25411174200725319627/

判断整数序列是不是二元查找树的后序遍历结果

bool verify(int * array, int beg, int end){ if (beg==end){ return true; } int j = 0; for(int i=beg;i<end;i++){ if(array[i]>array[end]){ j = i; break; } } for(int i = j;i<end;i++){ if(array[i]<array[end]){ return false; } } bool lhalf = true; lhalf = verify(array, beg, j-1); bool rhalf = true; rhalf = verify(array, j, end-1); return lhalf&&rhalf; }

判断指针是否是空指针是很好的习惯。

在排序数组中查找和为给定值的两个数字：

1. 用hash表

2. 窗口，先最小，再找最大的合适的值（从最大往小扫描），再两个同时右移

http://zhedahht.blog.163.com/blog/static/25411174200722191722430/

第一个只出现一次的字符（写程序）

自己构造hash表，char类型的有一个字节（8位），一共有256种情况。

class myhash{ private: int table[256]; public: myhash(){ memset(table,0,sizeof(table)); } int retnum(int c); void increase(int c); }; int myhash::retnum(int c){ return table[c]; } void myhash::increase(int c){ ++table[c]; }

http://zhedahht.blog.163.com/blog/static/25411174200722710364233/

含有指针成员的类的拷贝（深度拷贝和指向该类指针数量）

Fibonacci序列o(n)的时间复杂度求法：从最低往上加（写程序）

参考：http://zhedahht.blog.163.com/blog/static/25411174200722991933440/

http://zhedahht.blog.163.com/blog/static/2541117420073293950662/

用两个栈实现队列（写程序）

以下这段程序是编译同不过的，因为构造函数不能传递实例（值）。会造成堆栈溢出。

class A{ private: int a; public: A(int a){ this->a = a; } A(A other){ a = other.a; } void print(){ cout<<a<<endl; } };

A a = 10;这中初始化是正确的，会自动调用A(10)构造函数。

变量初始化是按定义顺序出事话的，和初始化列表中的顺序无关，所以输出的是随机变量和0.

输出8.因为pPoint为NULL，也就是0，求z的起始地址，就是sizeof(x)+sizeof(y)

运行Print2()时会崩溃，因为访问m_value需要this指针，而此时为NULL

输出1，1,4. 因为调用虚函数的时候会产生一个指向虚函数表的指针。

逆转单链表：

函数最好有返回值，简单且不容易出错。

http://zhedahht.blog.163.com/blog/static/2541117420073471124487/

class Node{ public: int m_value; Node * next; }; Node * createList(){ int input; Node * head = NULL; if(cin>>input){ head = new Node; head->m_value = input; head->next = NULL; head->next = createList(); } return head; } Node * reverseList(Node * head){ if (!head || !head->next) { return head; } Node *p1,*p2; p1 = head; p2 = p1->next; head->next = NULL; while(p2!=NULL){ p1 = p2; p2 = p2->next; p1->next = head; head = p1; } return head; }

最长公共子串

递归的思想：

c[i][j]用来存放长度为i和j的两个子串的最长公共子串的长度，如果i==0||j==0则c[i][j]=0，否则c[i][j] = c[i-1][j]>c[i][j-1]?c[i-1][j]:c[i][j-1];

求lcs和输出其序列的代码：

int lcs(char * input1, char * input2, int len1, int len2){ for(int i=1;i<=len1;i++){ for(int j=1;j<=len2;j++){ if(input1[i-1]==input2[j-1]) dp[i][j] = dp[i-1][j-1] + 1; else if(dp[i-1][j]>=dp[i][j-1]) dp[i][j] = dp[i-1][j]; else dp[i][j] = dp[i][j-1]; } } return dp[len1][len2]; } void route(char * input1, char * input2, int dp[100][100], int len1, int len2){ if(len1==0 || len2==0) return; if(input1[len1-1] == input2[len2-1]){ route(input1,input2,dp,len1-1,len2-1); cout<<input1[len1-1]; }else if(dp[len1-1][len2]>=dp[len1][len2-1]){ route(input1,input2,dp,len1-1,len2); }else route(input1,input2,dp,len1,len2-1); }

代码需要注意：

输出序列的函数要同时有两个序列

if(dp[i-1][j]>=dp[i][j-1])加“=”和不加遍历的序列不一样，但是都是lcs

32位机器int中，0xffffffff是-1，ox80000000是最小负数-2147483648。

求int数字中有多少个1：

/// // Get how many 1s in an integer's binary expression /// int numberof1(int n){ unsigned int tag = 1; int numof1 = 0; while(tag){ if(tag&n) ++numof1; tag = tag<<1; } return numof1; }

从1到一个正整数的自然数序列中出现过多少次1

21345，

考虑1~1345和1346~21345。
1346~21345一共有20000个数，所以在最高位就出现过20000次，如果最高位是1则为后面尾数+1
后面用2（最高位）依次递归下去。得到结果最终要加上1~1345的递归结果。

1~n中1出现的次数

http://zhedahht.blog.163.com/blog/static/25411174200732494452636/

和为n的连续整数序列

http://zhedahht.blog.163.com/blog/static/25411174200732711051101/

二叉树深度

http://zhedahht.blog.163.com/blog/static/25411174200732975328975/

字符串的排列组合

http://zhedahht.blog.163.com/blog/static/254111742007499363479/

排列代码：

void permutation(char * array, char * begin){ if(!array) return; if (*begin=='/0') { printf("%s/n",array); } for(char * pch = begin; * pch!='/0'; pch++){ char temp = *pch; *pch = *begin; *begin = temp; permutation(array,begin+1); temp = *pch; *pch = *begin; *begin = temp; } } void permutation(char * array){ permutation(array, array); }

数组重新排序

http://zhedahht.blog.163.com/blog/static/25411174200741295930898/

重点：判断是否是偶数用&而不是用%（效率高）；函数解耦，应用函数指针。

赋值运算符重载函数

http://zhedahht.blog.163.com/blog/static/25411174200741543224391/

class CMyString { public: CMyString(char* pData = NULL); CMyString(const CMyString& str); ~CMyString(void); private: char* m_pData; }; CMyString& CMyString::operator =(const CMyString &str) { if(this == &str) return *this; delete []m_pData; m_pData = NULL; m_pData = new char[strlen(str.m_pData) + 1]; strcpy(m_pData, str.m_pData); return *this; } CMyString& CMyString::operator =(const CMyString &str) { if(this != &str) { CMyString strTemp(str); char* pTemp = strTemp.m_pData; strTemp.m_pData = m_pData; m_pData = pTemp; } return *this; }

从尾到头输出链表（栈或者递归）

构建c++不能继承的类

关键：友元，虚继承，静态方法

class FinalClass1 { public: static FinalClass1* GetInstance() { return new FinalClass1; } static void DeleteInstance( FinalClass1* pInstance) { delete pInstance; pInstance = 0; } private: FinalClass1() {} ~FinalClass1() {} }; template <typename T> class MakeFinal { friend T; private: MakeFinal() {} ~MakeFinal() {} }; class FinalClass2 : virtual public MakeFinal<FinalClass2> { public: FinalClass2() {} ~FinalClass2() {} }; class Try : public FinalClass2 { public: Try() {} ~Try() {} }; Try temp; 由于类FinalClass2是从类MakeFinal<FinalClass2>虚继承过来的，在调用Try的构造函数的时候，会直接跳过FinalClass2而直接调用MakeFinal<FinalClass2>的构造函数。非常遗憾的是，Try不是MakeFinal<FinalClass2>的友元，因此不能调用其私有的构造函数。

已知头结点指针和待删除结点指针情况下，用o(1)时间删除链表节点

void DeleteNode(ListNode* pListHead, ListNode* pToBeDeleted) { if(!pListHead || !pToBeDeleted) return; // if pToBeDeleted is not the last node in the list if(pToBeDeleted->m_pNext != NULL) { // copy data from the node next to pToBeDeleted ListNode* pNext = pToBeDeleted->m_pNext; pToBeDeleted->m_nKey = pNext->m_nKey; pToBeDeleted->m_pNext = pNext->m_pNext; // delete the node next to the pToBeDeleted delete pNext; pNext = NULL; } // if pToBeDeleted is the last node in the list else { // get the node prior to pToBeDeleted ListNode* pNode = pListHead; while(pNode->m_pNext != pToBeDeleted) { pNode = pNode->m_pNext; } // deleted pToBeDeleted pNode->m_pNext = NULL; delete pToBeDeleted; pToBeDeleted = NULL; } }

上面的代码基于两个假设：（1）给定的结点的确在链表中；（2）给定的要删除的结点不是链表的头结点。不考虑第一个假设对代码的鲁棒性是有影响的。至于第二个假设，当整个列表只有一个结点时，代码会有问题。但这个假设不算很过分，因为在有些链表的实现中，会创建一个虚拟的链表头，并不是一个实际的链表结点。这样要删除的结点就不可能是链表的头结点了。当然，在面试中，我们可以把这些假设和面试官交流。这样，面试官还是会觉得我们考虑问题很周到的。

找出数组中只出现一次数数字（很巧妙）

http://zhedahht.blog.163.com/blog/static/2541117420071128950682/

题目：一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。

找出两个链表第一个公共结点

http://zhedahht.blog.163.com/blog/static/254111742008053169567/

两个思路：1.遍历两个，得到两个长度，l1和l2，使长链表先走|l1-l2|，两个一块走判断地址是否相同。2.用set记录每个地址，遍历第二个链表的时候进行判断。

在字符串中删除特定字符

http://zhedahht.blog.163.com/blog/static/25411174200801931426484/

时间复杂度o(n)

要点：两个指针，字母hash

找出从小到大的1500个丑数

http://zhedahht.blog.163.com/blog/static/2541117420094245366965/

丑数的定义：因数只是2,3或者5的数字。

两种方法：1.从1往后判断，直到1500个丑数都找到为止。2.前面的丑数*2 or *3 or *5得到第一个大于目前最大丑数的数，记住为止，递归。

输出1~n位所有的数，例如n=2 输出 0,1,2...99

http://zhedahht.blog.163.com/blog/static/2541117420094279426862/

void myprint(char * numbers){ if (!numbers) { return; } while (*numbers=='0') { ++numbers; } if (*numbers=='/0') { cout<<0<<endl; return; } while(*numbers!='/0'){ printf("%c",*numbers); numbers++; } cout<<endl; } void printnum(char * numbers, int len, int index){ if (!numbers){ return; } if(index==len){ myprint(numbers); return; } for(int i=0;i<10;i++){ numbers[index] = i + '0'; printnum(numbers,len,index+1); } } void print1ton(int n){ if (n<0) { return; } char * numbers = new char[n+1]; numbers[n] = '/0'; printnum(numbers, n,0); delete []numbers; }

颠倒栈

http://zhedahht.blog.163.com/blog/static/25411174200943182411790/

template<class T> void pushbottom(stack<T> &s, T &t){ if (s.empty()) { s.push(t); }else{ T top = s.top(); s.pop(); pushbottom(s,t); s.push(top); } } template<class T> void reverseStack(stack<T> &s){ if(!s.empty()){ T temp = s.top(); s.pop(); reverseStack(s); pushbottom(s,temp); } }

旋转数组的最小元素

http://zhedahht.blog.163.com/blog/static/25411174200952765120546/

o(logn)的时间复杂度。

输出所有筛子可能点数的可能性

1.首先得到每种可能性有多少种组合，存在数组里

2.用数组的值除以所有可能性

void recursive(int * probility, int n, int index, int sum){ if (probility == NULL){ return; } if(index==n){ probility[sum-1]++; return; } for(int i=1;i<=6;i++){ sum += i; recursive(probility,n,index+1,sum); sum-=i; } } void printdice(int n){ if(n<=0){ return; } int * probility = new int[n*6]; memset(probility,0,n*6*4); recursive(probility, n, 0, 0); for(int i=n-1;i<n*6;i++){ cout<<probility[i]<<" "; } cout<<endl; }

字符串到数字的转换

http://zhedahht.blog.163.com/blog/static/25411174200731139971/

注意：

正负号
非法输入（是否在0~9之间）
空字符串
数字溢出（是否比std::numeric_limits<int>::max()要大）

#define MAX 2147483647 //std::numeric_limits<int>::max() = 2147483647 int strtoint(char * str){ if (!str) { cout<<"NULL pointer"<<endl; return 0; } bool negtive = false; if (*str=='-') { negtive = true; ++str; } unsigned int num = 0; for(char* temp = str;*temp!='/0';++temp){ if(*temp<'0' || *temp>'9'){ cout<<"invalid charactor"<<endl; return 0; } num = num*10 + *temp - '0'; if (num>MAX) { cout<<"limit exceeded."<<endl; return 0; } } int result = num; if (negtive) { return -result; }else{ return result; } }

数字的整数次幂

http://zhedahht.blog.163.com/blog/static/254111742009101563242535/

注意：

非法输入（指数和底数）
超出范围
性能（分治法）

singleton

http://zhedahht.blog.163.com/blog/static/2541117420105146828433/

构造函数为私有函数，有一个static变量来存放一个对象。也可以有一个static指针，另一个static函数来创建对象（但是在多线程中有问题）。

对称字符串最大长度

http://zhedahht.blog.163.com/blog/static/25411174201063105120425/

普通做法：o(n^3)的复杂度

改进做法：任意两个相邻字符向外扩张o(n^2)

二叉树两个结点的最低公共父节点

http://zhedahht.blog.163.com/blog/static/25411174201081263815813/

二叉排序树，普通二叉树

排序二叉树：当两个值都大于或者小于当前节点时继续查找，直到一个大于一个小于就说明找到了该节点。

普通二叉树：最低公共父节点是从根节点遍历到两棵子树的最后一个公共结点。可以分别遍历后得到两个单链表，找到最后一个公共结点。用队列（两个队列从头一起pop，如果队头不同，那么之前pop的就是最低公共父节点）比用set要高效。

复杂链表的复制

http://zhedahht.blog.163.com/blog/static/254111742010819104710337/

三种方法：1，暴力法 2.用hash表，key是节点地址，value是对应复制节点的地址 3.在后面插入相同的节点（较优）

树为另一颗树的子结构

http://zhedahht.blog.163.com/blog/static/25411174201011445550396/

1.找到对应的结点

2.判断是否有一棵树的所有结点

注意：空指针和递归结束条件

顺时针输出矩阵

http://zhedahht.blog.163.com/blog/static/254111742010111112236313/

void printmatrix(int **matrix, int width, int hight){ int a,b,c,d; a = 0; b = width - 1; c = 0; d = hight - 1; do { for(int i=a;i<b;i++){ cout<<matrix[a][i]<<" "; } for(int i=c;i<d;i++){ cout<<matrix[i][b]<<" "; } for(int i=b;i>a;i--){ cout<<matrix[d][i]<<" "; } for(int i=d;i>c;i--){ cout<<matrix[i][c]<<" "; } ++a; --b; ++c; --d; } while (a<=b && c<=d); } int main(){ int **matrix = new int*[3]; for(int i=0;i<3;i++){ matrix[i] = new int [4]; } for(int i=0;i<3;i++){ for(int j=0;j<4;j++){ matrix[i][j] = j + i*4; } } for(int i=0;i<3;i++){ for(int j=0;j<4;j++){ cout<<matrix[i][j]<<" "; } cout<<endl; } printmatrix(matrix, 4,3); system("pause"); return 0; }

题目：求和为n的连续整数序列

例如：

15=1+2+3+4+5

15=4+5+6

15=7+8

void solution(int n, int beg, int end); int main(){ int n; cin>>n; int beg = 1,end; if(n&1){ end = (n>>1)+1; }else{ end = n>>1; } solution(n, beg, end); system("pause"); return 0; } void solution(int n, int beg, int end){ bool flag = false; int beg2 = beg; int sum = beg; while(beg2<=end){ if (sum<n) { sum+=++beg2; }else{ sum-=beg++; } if (sum==n) { flag = true; for(int i=beg;i<beg2;i++){ cout<<i<<"+"; } cout<<beg2<<endl; } } if (!flag) { cout<<"None"<<endl; } }

注意：n>>1是除2的意思，除2后加1必须写成(n>>1)+1，因为n>>1+1是n>>2的意思

约瑟夫问题

number' = (number+k) mod n

其中number'是第k轮，number是第k+1轮，在第k+1轮
第一个人的编号为0，报数为1，数到k就会剔除掉
最后剩下的一个人一定是0号，报号为1，所以从后往前推，他的编号+死亡编号（从1数）模上人数n，推n-1次就是最终的胜利者编号（一共n个人）

寻找旋转数组最小元素

34512就是12345的一个旋转，最简单的算法能够o(n)时间内找到最小元素，但是可以用二分法，降到logn。

n个筛子的点数

有n个筛子，每种点数出现的概率是多少？总共的可能数量是6^n，每种点数出现的次数除以6^n即可。

求出每个点数出现的次数的思路：

两个数组：一个用来存最后结果（数组B），一个用来存六个点数出现的次数（数组A）
初始A为全1，B的前六位为全1，表示只有一个筛子
加入一个筛子，对于A数组中的第k位，其值等于k-1, k-2...k-6(当然不能小于1)位所有数值的和
每一次将数组A的六个值赋值到数组B的第i位到第i+5位，其中i为加入筛子的数量（循环次数）

二进制数中1出现的次数

方法一：用1不停左移再进行与运算

方法二：减1后与原数进行与运算，会使得最后一个1变成0。所以有多少个1就能进行多少次运算。

void solution(int n){ int *array[2]; array[0] = new int [6*n+1]; array[1] = new int [6*n+1]; int i; memset(array[0],0,4*(6*n+1)); memset(array[1],0,4*(6*n+1)); for(i=1;i<7;i++){ array[0][i] = 1; } int flag = 0; for(i = 2;i<=n;i++){//for each dice for(int j=i;j<=i*6;j++){//the number should be update: from x(number of dices) to 6*x array[1-flag][j] = 0; for(int k=1;k<j && k<=6;k++)//for each number to update: sum of x-1,x-2,...,x-6 array[1-flag][j] += array[flag][j-k]; } flag = 1-flag; } for(i=n;i<n*6+1;i++){ cout<<array[flag][i]<<" "; } cout<<endl; delete []array[0]; delete []array[1]; }

整数的n次幂

分治法；要注意对幂情况的考虑。

double powerwithint(double base, int n){ bool positive = true; if (n<0) { positive = false; n*=-1; } if (n==1) { return base; } if (n==0) { return 1; } double ret = powerwithint(base, n>>1); ret *= ret; if (n&1) { ret*=base; } if (positive) { return ret; }else return 1.0/ret; }

char * str = "abc";

cout<<sizeof(str)<<endl;会输出4而不是3

char str[10] = "abc";

cout<<sizeof(str)<<endl;会输出10而不是4

c++语法题：

class A { public: virtual void Fun(int number = 10) { std::cout << "A::Fun with number " << number; } }; class B: public A { public: virtual void Fun(int number = 20) { std::cout << "B::Fun with number " << number; } }; int main() { B b; A &a = b; a.Fun(); }

输出结果是: "B::Fun with number 10"，因为默认参数时在编译期确定的。

运行下列c代码会有什么结果：

char* GetString1() { char p[] = "Hello World"; return p; } char* GetString2() { char *p = "Hello World"; return p; } int _tmain(int argc, _TCHAR* argv[]) { printf("GetString1 returns: %s. /n", GetString1()); printf("GetString2 returns: %s. /n", GetString2()); return 0; }

GetString1 returns:后面跟的是随机的字符串

GetString2 returns：后面跟的是"Hello World"。

因为第一个是数组，在函数执行完时会自动释放空间，而第二个是常量字符串，函数结束时不会自动释放

字符组合

对于每一种情况（1个字符，2个字符，。。。，strlen个字符），每一个字母要么加入到最后的结果中，要么不加入最后的结果中。中途如果达到字符串结尾就输出，如果达到结尾了但是结果中字符的数量还没满则返回。

if(num==0){ vector<char>::iterator iter = result.begin(); while(iter!=result.end()){ cout<<*iter++; } cout<<endl; return; } if(*str=='/0') return; result.push_back(*str); combination(str+1,num-1,result); result.pop_back(); combination(str+1,num,result); } void combination(char * str){ int len = strlen(str); int num = 1; vector<char> result; for(;num<=len;++num){ combination(str, num, result); } }

数组中子串最大和

在数组中，某个子串的和为最大值，输出这个最大值。

int array[10] = {31,-41,59,26,-53,58,97,-93,-23,84}; int maxsubarray(int * array, int len){ int sum = 0; int summax = 0; for(int i=0;i<len;i++){ if (sum<0) { sum=0; } sum+=array[i]; if(sum>summax){ summax = sum; } } return summax; }

分治法：

int array[10] = {31,-41,59,26,-53,58,97,-93,-23,84}; int max(int a, int b){ return a>b?a:b; } int max(int a, int b, int c){ if (a>b) { return a>c?a:c; }else return b>c?b:c; } int maxsubarrayDC(int * array, int i, int j){ if(i>j) return 0; if(i==j){ return 0>array[i]?0:array[i]; } int lsum = 0; int lsummax = 0; int mid = (i+j)/2; for(int ii=mid;ii>=i;--ii){ lsum+=array[ii]; lsummax = lsummax>lsum?lsummax:lsum; } int rsum = 0; int rsummax = 0; for(int jj=mid+1;jj<j;++jj){ rsum+=array[jj]; rsummax = rsummax>rsum?rsummax:rsum; } return max(rsummax+lsummax, maxsubarrayDC(array,i,mid), maxsubarrayDC(array,mid+1,j)); }