几道笔试题的解法(四)

题目： 编写一个单词逆序输出的算法。例如：“I am a student”， 要求输出为：”student a am I”
分析：本题考查的是C语言的指针

代码如下：

第一种： //用C语言知识实现

void ReverseWord(char* str, char* outstr)
{
char* head = str;

while(*str++);

int count = 0;

for ( str -= 2; *str; str-- )
{
if (str == head)
{
do
{
*outstr++ = *str++;
}while(count--);

break;
}
if ( *str == ' ')
{
char *temp = str + 1;
while(count--)
*outstr++ = *temp++;
*outstr++ = ' ';
count = 0;
}
else
{
count++;
}
}
*outstr = 0;
}
第二种： //直接通过创建栈来实现
#include <cassert>
#include <iostream>
#include <ostream>

using namespace std;

template<class T>
class stackNode
{
public:
T data;
stackNode<T> *Next;
};

template<class T>
class Stack_Node
{
public:
Stack_Node() : first(0)
{
}
virtual ~Stack_Node()
{
stackNode<T> *p;
while (first)
{
p = first->Next;
delete first;
first = p;
}
}
bool IsEmpty() const
{
return first == 0;
}
bool IsFull() const
{
try
{
stackNode<T> *p = new stackNode<T>;
delete p;
return false;
}
catch (...)
{
return true;
}
}
T GetTop() const
{
if (IsEmpty())
{
throw out_of_range("The stack is empty！");
}
return first->data;
}
Stack_Node<T>& Push(const T& x)
{
stackNode<T> *p = new stackNode<T>;
p->data = x;
p->Next = first;
first = p;

return *this;
}

Stack_Node<T>& Pop(T& x)
{
if (IsEmpty())
{
throw out_of_range("The stack is empty");
}
x = first->data;
stackNode<T> *p = first;

first = first->Next;
delete p;
return *this;
}

int Length() const
{
int len = 0;
stackNode<T> *p = first;
while (p)
{
len++;
p = p->Next;
}
return len;
}

void Print(ostream& os) const
{
stackNode<T> *p = first;
if (IsEmpty())
{
throw out_of_range("The stack is empty！");
}
while (p)
{
os << p->data << " ";
p = p->Next;
}
}
private:
stackNode<T> *first;
};

template<class T>
ostream& operator<<(ostream& os, const Stack_Node<T>& x)
{
x.Print(os);
return os;
}

int GetLength(const char* _in)
{
int _length = 0;
while (*_in++ != '/0')
{
_length++;
}

return _length;
}

int GetSpecialCharCount(const char* _source, const char ch)
{
int _count = 0;

while (*_source++ != '/0')
{
if (*_source == ch)
{
_count++;
}
}

return _count;
}

int FindChar(const char* _source, const char ch, int _position = 0)
{
int ret = 0;
assert(_position >= 0 && _position <= GetLength(_source));

while (_source[_position] != '/0')
{
if (_source[_position] == ch)
{
ret = _position + 1;
break;
}
_position++;
}

return ret;
}

char* CutString(const char* _source, int len, int _position = 0)
{
assert(_position >= 0 && _position <= GetLength(_source));
assert(len >= 0 && len <= GetLength(_source));

char* retStr = new char[len + 1];
memset(retStr, 0, len + 1);
int i = 0;

for (; i < len; ++i)
{
retStr[i] = _source[_position];
_position++;
}

*(retStr + len) = '/0';

return retStr;
}

char* DelString(char* _source, int len)
{
assert(len >= 0 && len <= GetLength(_source));
return (_source + len);
}

int main(void)
{
Stack_Node<char*> s;

char *str = "I am a student";
char *temp = NULL;
int index = 0;
int _count = GetSpecialCharCount(str, ' ');

for (int i = 0; i <= _count ; ++i)
{
index = FindChar(str, ' ');
temp = CutString(str, index);
if (i == _count)
{
temp = str;
}
s.Push(temp);
str = DelString(str, index);
}

cout << s << '/n';
}