师兄面试总结编程部分解答之一

首先感谢朱宏师兄给出的总结，是一些典型的内容。

最近将编程部分看了一遍，并给出了解答，整体内容可能会比较长，可能会分为两到三篇文章里介绍。

一、字符串
1、逆序（百度面试题，要求最小的时间复杂度，个人觉得应该是方法1了）
（1） 双指针头尾互换
（2） 递归互换
（3） STL入栈出栈

void reverse(char *str)
{
	int len = strlen(str);
	//双指针头尾互换
	char tmp;
	int start = 0;
	int end = len - 1;
	while(start < end)
	{
		tmp = *(str + start);
		*(str + start) = *(str + end);
		*(str + end) = tmp;
		start++;
		end--;
	}
}

2、回文
（1）一个字符串，补充后面的字符组成回文字符串

//对原始字符串继续补充成回文
char *palindromes(char* str)
{
	int len = strlen(str);
	char* str2 = new char[len*2];//创建新的数组，用来对元素进行存放
	for(int i = 0; i < len; i++)
	{
		*(str2 + i) = *(str + i);
	}
	for(int i = 0; i < len; i++)
	{
		*(str2 + len + i) = *(str + (len - 1 - i));
	}
	*(str2 + 2*len) = '\0';
	return str2;
}

（2）在一个字符串中，找出最长的回文字符串

//找出一个字符串中最长的回文串，符合回文特征的字符子串
//aba & abba均为回文串，这个要首先明确的的一点
void findLongest(char* str)
{
	//给出的思路1，是在字符之间插入'#'以统一奇数串和偶数串，均为奇数串
	//利用现有最长子串为依据，由回文串的对称性，可以减少不必要的计算，
	//具体分析，对称点的最长子串已知，则当前最长子串的最小长度也就可以确定，对称性
	int len = strlen(str);
	const int lenNew = 2 * len + 1;
	char* str2 = new char[lenNew];
	int* p = new int[lenNew];
	int max = 0;
	int id = 0;
	for(int i = 0; i < len; ++i)
	{
		*(str2 + 2 * i) = '#';
		*(str2 + 2 * i + 1) = *(str + i);
	}
	*(str2 + 2 * len) = '#';
	//完成插入操作

	//进行统计过程
	//p[i] 存储以i位置为中心的最长回文子串长度
	//max存储当前最优结果，id存储单签最优结果对应的下标
	for(int i = 1; i < lenNew; ++i)
	{
		if (max > i)
			p[i] = p[2 * id - i] > max - i ? max - i: p[2 * id - i];//由于关于id对称，已判断的回文部分不需要再次判断，
		else
			p[i] = 1;

		for(;str2[i - p[i]] == str2[i + p[i]]; p[i]++)
			;
		p[i]--;

		if(p[i] > max)
		{
			max = p[i];
			id = i;
		}
	}
	printf("the longest one is %d \n",max);
}

（3）一个字符串中，最多有一个字符出现了奇数次，别的字符都出现了偶数次，要求将这个字符串变成回文字符串（要求最少的交换次数，不能开辟新的存储空间）（百度面试题）

//将原有字符串转换成回文串
//给出的测试字符串最多有一个出现奇数次，其他均出现偶数次，在不开辟新的存储空间的前提下，如何实现
//且交换次数尽可能少
void producePralindroms(char* str)
{
	//连续交换，从前向后遍历，并与前面的内容进行比较，如果存在相同则交换到与之对称位置处
	//交换的前提条件是对应位置的元素不同，否则，保持原位置继续向后遍历，直至结束
	//缺陷，不能够将唯一的奇数元素放到中间位置
	//改进,依然是从前向后遍历，在遍历位置，向后遍历到对称位置处，期间存在相同元素，则置换到对称位置，同时跳出内层遍历
	//不存在相同元素，则将该元素置换到中间位置，并进行下一轮遍历（新一轮遍历起始位置不变）
	int len = strlen(str);
	for(int i = 0; i < (len / 2); i++)
	{
		char cur = *(str + i);
		bool change = false;
		for(int j = i + 1; j < len - i; j++)
		{
			if(*(str + j) == cur )
			{
				//交换
				if(j != len - i - 1)
				{
					char tmp = *(str + j);
					*(str + j) = *(str + len - i - 1);
					*(str + len - i - 1) = tmp;
				}
				change = true;
				break;
			}
		}
		if(!change)//只有在存在奇数个数元素时，才可能出现这个情况
		{
			*(str + i) = *(str + len / 2);
			*(str + len / 2) = cur;
			--i;
		}

	}
	printf("%s\n",str);
}

3、左/右移动K位
（有时间复杂度的限制，要用三次交换法（剑指offer 221页）

//向左或向右移动k位
//利用翻手法则，三次变换即可
//对[start，end]区间进行翻转操作
void reverse(char* start, char* end)
{
	//最直接的头尾互换即可
	while(start < end)
	{
		char tmp = *start;
		*start = *end;
		*end = tmp;
		start++;
		end--;
	}
}
void shiftK(char* str,int k)
{
	int len = strlen(str);
	char* start = str;
	char* middle = str + len - k;
	char* end = str + len - 1;
	reverse(start,middle - 1);
	reverse(middle, end);
	reverse(start,end);
	printf("%s\n",str);
}

4、itoa
atoi
strcpy
strcat等源代码

char* myitoa(int num, char* str,int radix)
{
	char index[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	char* ptr = str;
	bool isNegative = false;
	if (num < 0)
	{
		num = -1 * num;
		isNegative = true;
	}
	while(num >= radix)
	{
		*ptr++ = index[num % radix];
		num = num / radix;
	}
	if(num)
	{
		*ptr++ = index[num];
	}
	if(isNegative)
	{
		*ptr++ = '-';
	}
	*ptr='\0';
	ptr--;
	//当前ptr指向内容为num的倒序存在，需要将其进行逆序
	char* start = str;
	char* end = ptr;
	while(start < end)
	{
		char tmp = *start;
		*start = *end;
		*end = tmp;
		start++;
		end--;
	}
	printf("%s\n",str);
	return str;
}
//将string转化为整型输出
int myatoi(const char* str)
{
	const char* ptr = str;
	int num = 0;
	bool isNegative = false;
	if(*ptr == '-')
	{
		ptr++;
		isNegative = true;
	}
	while(*ptr != '\0')
	{
		int tmp = *ptr++ - '0';
		num = num * 10 + tmp;
		
	}
	if(isNegative)
	{
		num = num * -1;
	}
	printf("%d\n",num);
	return num;
}
char* myStrcpy(char* dest, char* src)
{
	if(NULL == dest || NULL == src)
		return NULL;
	
	char* ret = dest;
	while((*dest++ = *src++) != '\0')
		;
	return ret;
}