将一个单链表逆序

　　struct list_node

　　{

　　list_node(int a,list_node* b):data(a),next(b) //这个为了测试方便

　　{}

　　int data;

　　list_node* next;

　　};

　　void reserve(list_node* phead)

　　{

　　list_node* p = phead->next;

　　if(p == NULL || p->next == NULL) return; //只有头节点或一个节点

　　list_node* p1=p->next;

　　p->next=NULL;

　　while(p1!=NULL)

　　{

　　p = p1->next;

　　p1->next = phead->next;

　　phead->next = p1;

　　p1 = p;

　　}

　　}

　　测试程序：

　　list lt;

　　lt.phead = new list_node(0,0);

　　lt.phead->next = new list_node(1,0);

　　lt.phead->next->next = new list_node(2,0);

　　lt.phead->next->next->next = new list_node(3,0);

　　lt.reserve();

　　list_node * p = lt.phead;

　　while(p)

　　{

　　coutnext;

　　}

　　循环链表的节点对换和删除。

　　//双向循环

　　list_node* earse(list_node* node)

　　{

　　// if(node == rear) return node->next; //对于头节点可判断也可不判断。最好加上

　　list_node* next = node->next;

　　next->prev = node->prev;

　　node->prev->next = next;

　　delete node;

　　retrun next;

　　}

　　//单项循环

　　list_node* earse(list_node* node)

　　{

　　// if(node == rear) return node->next; //对于头节点可判断也可不判断。最好加上

　　list_node* p = rear;

　　while(p->next != node) p=p->next;

　　p->next = node->next;

　　delete node;

　　retrun p->next;

　　}

　　将一个数字字符串转换为数字."1234" -->1234

　　int atoii(char* s)

　　{

　　assert(s!=NULL);

　　int num = 0;

　　int temp;

　　while(*s>'0' && *s<'9')

　　{

　　num *= 10;

　　num += *s-'0';

　　s++;

　　}

　　return num;

　　}

　　出现次数相当频繁

　　.实现任意长度的整数相加或者相乘功能。

　　void bigadd(char* num,char* str,int len)

　　{

　　for(int i=len;i>0;i--)

　　{

　　num[i] += str[i];

　　int j = i;

　　while(num[j]>=10)

　　{

　　num[j--] -= 10;

　　num[j] += 1;

　　}

　　}

　　}

　　.写函数完成内存的拷贝

　　void* memcpy( void *dst, const void *src, unsigned int len )

　　{

　　register char *d;

　　register char *s;

　　if (len == 0)

　　return dst;

　　if ( dst > src ) //考虑覆盖情况

　　{

　　d = (char *)dst + len - 1;

　　s = (char *)src + len - 1;

　　while ( len >= 4 ) //循环展开，提高执行效率

　　{

　　*d-- = *s--;

　　*d-- = *s--;

　　*d-- = *s--;

　　*d-- = *s--;

　　len -= 4;

　　}

　　while ( len-- )

　　{

　　*d-- = *s--;

　　}

　　}

　　else if ( dst < src )

　　{

　　d = (char *)dst;

　　s = (char *)src;

　　while ( len >= 4 )

　　{

　　*d++ = *s++;

　　*d++ = *s++;

　　*d++ = *s++;

　　*d++ = *s++;

　　len -= 4;

　　}

　　while ( len-- )

　　{

　　*d++ = *s++;

　　}

　　}

　　return dst;

　　}

　　出现次数相当频繁

　　编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：

　　class String

　　{

　　public:

　　String(const char *str = NULL); // 普通构造函数

　　String(const String &other); // 拷贝构造函数

　　~ String(void); // 析构函数

　　String & operate =(const String &other); // 赋值函数

　　private:

　　char *m_data; // 用于保存字符串

　　};

　　解答：

　　//普通构造函数

　　String::String(const char *str)

　　{

　　if(str==NULL)

　　{

　　m_data = new char[1]; // 得分点：对空字符串自动申请存放结束标志'\0'的空

　　//加分点：对m_data加NULL 判断

　　*m_data = '\0';

　　}

　　else

　　{

　　int length = strlen(str);

　　m_data = new char[length+1]; // 若能加 NULL 判断则更好

　　strcpy(m_data, str);

　　}

　　}

　　// String的析构函数

　　String::~String(void)

　　{

　　delete [] m_data; // 或delete m_data;

　　}

　　//拷贝构造函数

　　String::String(const String &other) 　　　// 得分点：输入参数为const型

　　{

　　int length = strlen(other.m_data);

　　m_data = new char[length+1]; 　　　　//加分点：对m_data加NULL 判断

　　strcpy(m_data, other.m_data);

　　}

　　//赋值函数

　　String & String::operate =(const String &other) // 得分点：输入参数为const型

　　{

　　if(this == &other) 　　//得分点：检查自赋值

　　return *this;

　　delete [] m_data; 　　　　//得分点：释放原有的内存资源

　　int length = strlen( other.m_data );

　　m_data = new char[length+1]; 　//加分点：对m_data加NULL 判断

　　strcpy( m_data, other.m_data );

　　return *this; 　　　　　　　　//得分点：返回本对象的引用

　　}

　　剖析：

　　能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上!

　　在这个类中包括了指针类成员变量m_data，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective　C++》中特别强调的条款。

　　实现strcpy

　　char * strcpy( char *strDest, const char *strSrc )

　　{

　　assert( (strDest != NULL) && (strSrc != NULL) );

　　char *address = strDest;

　　while( (*strDest++ = * strSrc++) != ‘\0’ );

　　return address;

　　}

　　编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh”

　　函数头是这样的：

　　//pStr是指向以'\0'结尾的字符串的指针

　　//steps是要求移动的n

　　void LoopMove ( char * pStr, int steps )

　　{

　　//请填充...

　　}

　　解答：

　　正确解答1：

　　void LoopMove ( char *pStr, int steps )

　　{

　　int n = strlen( pStr ) - steps;

　　char tmp[MAX_LEN];

　　strcpy ( tmp, pStr + n );

　　strcpy ( tmp + steps, pStr);

　　*( tmp + strlen ( pStr ) ) = '\0';

　　strcpy( pStr, tmp );

　　}

　　正确解答2：

　　void LoopMove ( char *pStr, int steps )

　　{

　　int n = strlen( pStr ) - steps;

　　char tmp[MAX_LEN];

　　memcpy( tmp, pStr + n, steps );

　　memcpy(pStr + steps, pStr, n );

　　memcpy(pStr, tmp, steps );

　　}