面试经验

1.华为南京研究所

查找最长的回文串：

参考：1.JAVA实现查找最长回文串
2.时间复杂度为O（n）的马拉车算法

深拷贝与浅拷贝的区别

浅拷贝：对指针进行拷贝，但不会重新分配内存存储拷贝的指针，因此两个指针指向同一个地址，C++中如果不定义类的复制构造函数，就会调用类的默认复制构造函数，而类的复制构造函数是浅拷贝。

深拷贝：会重新分配内存，然后将所需拷贝的指针赋给该内存上的新指针，拷贝完成后，两个指针分别指向不同的地址空间，内容相同。

使用浅拷贝：构造函数将会被调用一次，析构函数会被调用两次；
使用深拷贝：构造函数将会被调用两次，析构函数会被调用两次；

线程同步：

C++实现线程同步的四种方法
C++中线程的交互方式

2.联发科技

2.1符号类型不会影响基本数据类型的字节长度

数据类型	长度字节	整数表示范围及浮点数绝对值的精度范围
bool	1	false,true
char	1	-2^7(-128) ~ 2^7-1(127)
signed char	1	-2^7(-128) ~ 2^7-1(127)
unsigned char	1	0~255
short(signed short)	2	-2^15(-32 768) ~ 2^15-1(32 767)
unsigned short	2	0-65535
int(signed int)	4	-2^31(-2 147 483 648) ~ 2^31-1(2 147 483 647)
unsigned int	4	0 ~ 2^32-1(4 294 967 295)
long(signed long)	4	-2^31(-2 147 483 648) ~ 2^31-1(2 147 483 647)
unsigned long	4	0 ~ 2^32-1(4 294 967 295)
float	4	-/+3.4e38（精确到6位小数）
double	8	-/+1.7e308（精确到15位小数）
long double	8	-/+1.7e308（精确到15位小数）

2.2 结构体所占的内存字节数

结构体所占的内存字节数

按字节编址（规律）：
1.从0位置开始存储；
2.short类型数据要求从偶数地址开始存储；
3.int数据要求对齐在4字节地址边界；
4.变量存储起始位置是该变量大小的整数倍；
5.结构体总的大小是其最大元素的整数倍，不足的后面补齐；
6.结构体变量的首地址能够被其最宽基本数据类型成员的大小整除；

指针变量所占的字节数
指针变量不同于一般变量，存的是变量的地址，在同一系统下地址长度都是相同的，所以不同类型的指针长度都一样。

32位的操作系统的寻址空间是0-2的32次方，即0x00000000~0xFFFFFFFF，指针长度为4个字节；
64位的操作系统的寻址空间是0-2的64次方，即0x0000000000000000~0xFFFFFFFFFFFFFFFF，指针长度为8个字节
所以，不管是char*, int*, float*，还是自定类型的指针，所有类型的指针变量在32位系统上都是4字节， 64位系统上都是8字节*

2.3将aaaabbbbcccc按照如下格式打印出来

aaaa
bbbb
cccc

#include<iostream>
#include<stdlib.h>
#include<string>
using namespace std;

void sort(string s)
{
	//int i= s.size();
	char temp;
	temp = s[0];
	for (int i = 0; i < s.size(); i++)
	{
		if (temp == s[i])
		{
			cout << s[i];
		}
		else
		{   cout << endl;
			temp = s[i];
			cout << s[i];
		}
	}
}

int main(void)
{
	string s;

	cout << "请输入索要排序的字符:";
	cin >> s;
	sort(s);

	system("pause");
	
}

2.4**任意输入一串字符，将相同的字符在同一行打印出来，不同的字符串在不同行显示出来（此处是自己发挥的，没有考虑时间复杂度然后完成的，有好的办法可以一起来交流啊）

如输入： asdasdasdaa
输出 ： dd
ss
aaaa**

#include<iostream>
#include<stdlib.h>
#include<string>
#include<vector>
using namespace std;

void sort(string s)
{
	vector<char> temp;
	//获取字符串中不同不重复的字符，并存入到temp中
	for (int i=0;find(temp.begin(), temp.end(), s[i]) == temp.end();i++)
	{
		temp.push_back(s[i]);	
	}
	//temp.size()+i是为了消除temp.pop_back()导致，循环次数减少
	for (int i = 0; i < temp.size()+i; i++)
	{
		char ch = temp.back();
		temp.pop_back();
		for (int j = 0; j < s.size(); j++)
		{   
			if (ch == s[j])
			{
				cout << s[j];
			}
		}
		cout << endl;
	}
}

int main(void)
{
	string s;
	cout << "请输入索要排序的字符:";
	cin >> s;
	sort(s);
	system("pause");
	return 0;
}

vector对象的几个重要操作，举例说明如下：

（1）a.assign(b.begin(), b.begin()+3); //b为向量，将b的0~2个元素构成的向量赋给a
（2）a.assign(4,2); //是a只含4个元素，且每个元素为2
（3）a.back(); //返回a的最后一个元素
（4）a.front(); //返回a的第一个元素
（5）a[i]; //返回a的第i个元素，当且仅当a[i]存在2013-12-07
（6）a.clear(); //清空a中的元素
（7）a.empty(); //判断a是否为空，空则返回ture,不空则返回false
（8）a.pop_back(); //删除a向量的最后一个元素
（9）a.erase(a.begin()+1,a.begin()+3); //删除a中第1个（从第0个算起）到第2个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+         3（不包括它）
（10）a.push_back(5); //在a的最后一个向量后插入一个元素，其值为5
（11）a.insert(a.begin()+1,5); //在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
（12）a.insert(a.begin()+1,3,5); //在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5
（13）a.insert(a.begin()+1,b+3,b+6); //b为数组，在a的第1个元素（从第0个算起）的位置插入b的第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8         ，插入元素后为1,4,5,9,2,3,4,5,9,8
（14）a.size(); //返回a中元素的个数；
（15）a.capacity(); //返回a在内存中总共可以容纳的元素个数
（16）a.resize(10); //将a的现有元素个数调至10个，多则删，少则补，其值随机
（17）a.resize(10,2); //将a的现有元素个数调至10个，多则删，少则补，其值为2
（18）a.reserve(100); //将a的容量（capacity）扩充至100，也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才         显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能） 
（19）a.swap(b); //b为向量，将a中的元素和b中的元素进行整体性交换
（20）a==b; //b为向量，向量的比较操作还有!=,>=,<=,>,<

3. 123的全排列

输入：“123”
输出：
123 132
213 231
312 321

void swap(char& a,char&b)
{
	char temp = a;
	a=b;
	b=temp;
}
void permutation(char* pStr,char* pPosition)
{

	if(*pPosition=='\0' )
	{
		cout<<pStr<<endl
	}
	else
	{
		for(char* pChar = *pPosition;*pChar!='\0';pChar++)
		{
		//依次和后面的字符交换
			swap(*pChar,*pPosition);
			permutation(pChar,pPosition+1);
			//换回来
			swap(*pChar,*pPosition);
		}
	}
}
//用STL输出全排列
//必须保证数组顺序
do
{
	cout<<test[0]<<test[1]<<test[2]<<endl
}while(next_permutation(test,test+3));

//prev_permutation();

4 TODO:1,2,3…n满足aabb是其中某个数的完全平方

#include<math.h>
int main(void)
{
for(int a=1;a<10;a++)
{
for(int b=0;b<10;b++)
{
int n =a1100+b11
double m = sprt(n);
if((m-(int)m)<0.0000000001)
{
cout<<n<<endl;
}
}
}
}
//方法2

int high,low;
for(int index=1；；index++ )
{
	int n = index*index;
	if(n<1000) continue;//继续下一次的循环
	if(n>9999) break;//退出循环
	high = n/100;//4569/100=45
	low = n%100;//45695100=69
	if(high/10==high% 10 &&low/10==low%10)
	{
		cout<<n<<endl;
	}
}