题目:编写一个单词逆序输出的算法,例如输入"SEE YOU IN ANOTHER LIFE",要求输出"LIFE ANOTHER IN YOU SEE"。
解答:
解法一:只需扫描一遍:
#include
void ReverseWord(constchar* src, char* dest)
{
assert(src != NULL && dest != NULL);
constchar* head = src; //记住头指针
while(*src++);
int count = 0;
for(src -= 2;;src--) //从尾到头遍历
{
if(src == head) //到头部额,退出循环
{
do
{
*dest++ = *src++;
} while(count--);
break;
}
if(*src == ' ') //遇到空格
{
constchar* temp = src + 1;
while(count--)
{
*dest++ = *temp++;
}
*dest++ = ' ';
count = 0;
}
else
{
count++; //计算每个单词的长度
}
}
*dest = '\0';
}
int main()
{
constchar* str = "SEE YOU IN ANOTHER LIFE";
char *dest = newchar[strlen(str) + 1];
ReverseWord(str, dest);
std::cout字符串,将第一个字符和最后一个字符交换,第二个和倒数第二个交换,依次循环。接着进行第二次遍历,对每个单词反转一次,这样每个单词就恢复成原有顺序,得到题目要求的功能了:
#include
char* ReverseWord(constchar* str)
{
assert(str != NULL);
int len = strlen(str);
char* restr = newchar[len + 1];
strcpy(restr, str);
//第一次扫描,头尾反转
for(int i=0, j=len-1; i字符串,一个这个字符串的子串,将第一个字符串反转,但保留子串的顺序不变。例如:
输入:第一个字符串:"See you in another life"
子串:"in"
输出:"efil rehtona in uoy eeS"
解答:一般的方法是先扫描一遍第一个字符串,用stack把它反转,同时记录下子串出现的位置;然后再扫描一遍反转后的字符串,扫描过程中将原来子串再反转,其他的不变,这样就得到答案了。
那么只扫描一遍怎么办呢?只需在扫描的过程中将子串反序压入堆栈;扫描完之后,将堆栈中字符弹出,这样子串就还是原来的顺序了。实现代码如下:
#include
#include
#include
constchar* reverse(constchar* s1, constchar* token)
{
assert(s1 && token);
std::stack stackOne;
constchar* ptoken = token;
constchar* head = s1;
constchar* rear = s1;
while(*head != '\0')
{ while(*head != '\0' && *ptoken == *head) { ptoken++; head++; } if(*ptoken == '\0') //包含字符串token
{
constchar* p;
for(p=head-1; p>=rear; p--) //从尾到头将token存入堆栈
{
stackOne.push(*p);
}
ptoken = token;
rear = head;
}
else//不是分割的字符串
{
stackOne.push(*rear);
head = ++rear;
ptoken = token;
}
}
char* ret = newchar[strlen(s1)+1];
int i = 0;
while(!stackOne.empty()) //非空
{
ret[i++] = stackOne.top();
stackOne.pop();
}
ret[i] = '\0';
return ret;
}
int main()
{
std::cout<<"See you in another life"<<std::endl;
std::cout<<reverse("See you in another life", "in")<<std::endl;
system("pause");
return 0;
}
解答:
解法一:只需扫描一遍:
#include
void ReverseWord(constchar* src, char* dest)
{
assert(src != NULL && dest != NULL);
constchar* head = src; //记住头指针
while(*src++);
int count = 0;
for(src -= 2;;src--) //从尾到头遍历
{
if(src == head) //到头部额,退出循环
{
do
{
*dest++ = *src++;
} while(count--);
break;
}
if(*src == ' ') //遇到空格
{
constchar* temp = src + 1;
while(count--)
{
*dest++ = *temp++;
}
*dest++ = ' ';
count = 0;
}
else
{
count++; //计算每个单词的长度
}
}
*dest = '\0';
}
int main()
{
constchar* str = "SEE YOU IN ANOTHER LIFE";
char *dest = newchar[strlen(str) + 1];
ReverseWord(str, dest);
std::cout字符串,将第一个字符和最后一个字符交换,第二个和倒数第二个交换,依次循环。接着进行第二次遍历,对每个单词反转一次,这样每个单词就恢复成原有顺序,得到题目要求的功能了:
#include
char* ReverseWord(constchar* str)
{
assert(str != NULL);
int len = strlen(str);
char* restr = newchar[len + 1];
strcpy(restr, str);
//第一次扫描,头尾反转
for(int i=0, j=len-1; i字符串,一个这个字符串的子串,将第一个字符串反转,但保留子串的顺序不变。例如:
输入:第一个字符串:"See you in another life"
子串:"in"
输出:"efil rehtona in uoy eeS"
解答:一般的方法是先扫描一遍第一个字符串,用stack把它反转,同时记录下子串出现的位置;然后再扫描一遍反转后的字符串,扫描过程中将原来子串再反转,其他的不变,这样就得到答案了。
那么只扫描一遍怎么办呢?只需在扫描的过程中将子串反序压入堆栈;扫描完之后,将堆栈中字符弹出,这样子串就还是原来的顺序了。实现代码如下:
#include
#include
#include
constchar* reverse(constchar* s1, constchar* token)
{
assert(s1 && token);
std::stack stackOne;
constchar* ptoken = token;
constchar* head = s1;
constchar* rear = s1;
while(*head != '\0')
{ while(*head != '\0' && *ptoken == *head) { ptoken++; head++; } if(*ptoken == '\0') //包含字符串token
{
constchar* p;
for(p=head-1; p>=rear; p--) //从尾到头将token存入堆栈
{
stackOne.push(*p);
}
ptoken = token;
rear = head;
}
else//不是分割的字符串
{
stackOne.push(*rear);
head = ++rear;
ptoken = token;
}
}
char* ret = newchar[strlen(s1)+1];
int i = 0;
while(!stackOne.empty()) //非空
{
ret[i++] = stackOne.top();
stackOne.pop();
}
ret[i] = '\0';
return ret;
}
int main()
{
std::cout<<"See you in another life"<<std::endl;
std::cout<<reverse("See you in another life", "in")<<std::endl;
system("pause");
return 0;
}