笔试题练习（七）

1,链表的常见操作

struct Node  
{  
    int value;  
    struct Node* next;  
}root;  
 
//已知链表的头结点head，写一个函数把这个链表逆序  
Node * ReverseList(Node *head)   
{//链表逆序  
    assert(head != NULL);  
    if (head->next == NULL)  
    {//只有头节点  
        return head;  
    }  
    Node* pPre = head->next;  
    Node* pCur = pPre->next,pTmp;  
    if (pCur == NULL)  
    {//只有一个节点  
        return head;  
    }  
    while (pCur != NULL)  
    {  
        pTmp = pCur->next;//记录下一个  
        head->next = pCur;  
        pCur->next = pPre;  
        pPre = pCur;  
        pCur = pTmp;  
    }  
    return head;  
}  
 
Node * Merge(Node *head1 , Node *head2)  
{//已知两个链表head1 和head2 各自有序升序排列，请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同）  
 
    Node* head = NULL;  
    Node *p1 = head1->next;  
    Node *p2 = head2->next;  
    Node* pCur = head;  
    while (p1 != NULL && p2 != NULL)  
    {  
        if (p1->value < p2->value)  
        {  
            pCur ->next = p1;  
            pCur = p1;  
            p1 = p1->next;  
        }  
        else 
        {  
            pCur->next = p2;  
            pCur = p2;  
            p2 = p2->next;  
        }  
    }  
    if (p1 != NULL)  
    {//第一个有剩余  
        pCur->next = p1;  
    }  
    if (p2 != NULL)  
    {  
        pCur->next = p2;  
    }  
    return head;  
}  
Node * MergeRecursive(Node *head1 , Node *head2)  
{//已知两个链表head1 和head2 各自升序排列，请把它们合并成一个链表依然有序，这次要求用递归方法进行。  
    if ( head1 == NULL )  
        return head2;  
    if ( head2 == NULL)  
        return head1;  
    Node *head = NULL;  
    if ( head1->data < head2->data )  
    {  
        head = head1;  
        head->next = MergeRecursive(head1->next,head2);  
    }  
    else 
    {  
        head = head2;  
        head->next = MergeRecursive(head1,head2->next);  
    }  
    return head;  
} 

2,动态分配二维数组

int **alloArrays(unsigned int nrows,unsigned int ncolumns)  
{      
    unsigned int i;  
    int **array = (int **)malloc(nrows * sizeof(int *));  
    for(i = 0; i < nrows; i++)  
        array[i] = (int *)malloc(ncolumns * sizeof(int));  
    return array;  
}  
 
int** allocArrays2(int rows, int columns)  
{  
    int** array = new int* [rows];  
    int i,j;  
    for (i = 0;i< rows; ++i)  
    {  
        array[i] = new int[columns];  
    }  
    for (i = 0; i < rows; ++i)  
    {  
        for (j =0; j < columns;++j)  
        {  
            array[i][j] = i*j;  
        }  
    }  
    return array;  
} 

3.字符串简单操作

/************************************************************************/ 
/* Author: phinecos Date:2009-06-2                                                                     */ 
/************************************************************************/ 
#include <iostream>  
using namespace std;  
 
int strcmp_p (const char *s1, const char *s2)  
{   
    int ret;  
    while ((ret = *(unsigned char *) s1++ - *(unsigned char *) s2++) == 0);  
    return ret;  
}  
 
int  memcmp_p(const char *s1, const char *s2, size_t n)  
{    
    int ret = 0;  
    while (n-- && (ret = *(unsigned char *) s1++ - *(unsigned char *) s2++) == 0);  
    return ret;  
}  
 
void* memcpy_p( void *dest, const void *src, size_t count )  
{  
    char* pDest = static_cast<char*>(dest);  
    const char* pSrc = static_cast<const char*>(src);  
 
    if ((pDest > pSrc) && (pDest < (pSrc+count)))  
    {//源地址和目标地址内存重叠  
        for (size_t i = count -1 ; i != -1; --i)  
            pDest[i] = pSrc[i];  
    }  
    else 
    {  
        for (size_t i = 0; i < count; ++i)  
            pDest[i] = pSrc[i];  
    }  
    return dest;  
}  
 
int main()  
{  
    char str[] = "0123456789";  
    char str2[] = "0";  
    cout << memcmp_p(str,str2,3) << endl;  
    memcpy_p( str+1, str+0, 9 );  
    cout << str << endl;  
    memcpy_p( str, str+5, 5 );  
    cout << str << endl;  
    return 0;  
} 

 4，统计一个字符串中所有字符出现的次数

#include <iostream>  
#include <map>  
using namespace std;  
 
static map<char,int> countMap;  
static int countArray[128];  
 
void doCount(const char* str)  
{  
    while (*str)  
    {  
        countMap[*str++]++;  
    }  
}  
void doCount2(const char* str)  
{  
    while (*str)  
    {  
        countArray[*str++]++;  
    }  
}  
int main()  
{  
    char str[] = "fasdfdsfdferwefaasdf";  
    //使用map  
    doCount(str);  
    map<char,int>::iterator iter;  
    for (iter = countMap.begin(); iter != countMap.end(); ++iter)  
    {  
        cout << iter->first << " : " << iter->second << endl;  
    }  
    //不用map,直接数组  
    doCount2(str);  
    for (int i = 0; i < 128; ++i)  
    {  
        if (countArray[i]>0)  
        {  
            printf("%c\t%d\n",i,countArray[i]);  
        }  
    }  
    return 0;  
} 

 5. 在字符串中找出连续最长的数字串的长度

 
int FindMaxIntStr(char *outputstr,char *intputstr)  
{  
    char *in = intputstr,*out = outputstr, *temp, *final;  
    int count = 0, maxlen = 0;  
 
    while( *in != '\0' )  
    {  
        if( *in >= '0' && *in <= '9' )  
        {  
            for(temp = in; *in >= '0'&& *in <= '9'; in++ )  
                count++;  
            if( maxlen < count )  
            {  
                maxlen = count;  
                final = temp; // temp保存了当前连续最长字串的首地址，final是总的最长  
                *(final+count) = '\0'; //  给字符串赋上结束符  
            }  
            count = 0; // 不管当前累计的最长数字是否大于前面最长的，都应该清除count，以便下次计数  
        }  
        //到此处时*in肯定不是数字  
        in++;  
    }  
    // 上述比较过程只保存了最长字串在输入数组中对应的地址，避免了反复拷贝到输出数组的过程  
    for(int i = 0; i < maxlen; i++)     // 将最终的最长字串保存到输出数组  
    {  
        *out++ = *final++;  
    }  
    *out = '\0';  
    return maxlen;  
} 

6，最大公共子串

int maxCommonStr(char *s1, char *s2, char **r1, char **r2)  
{//求最大公共子串  
    int len1 = strlen(s1);  
    int len2 = strlen(s2);  
    int maxlen = 0;  
    int i,j;  
 
    for(i = 0; i < len1; i++)  
    {  
        for(j = 0; j < len2; j++)  
        {  
            if(s1[i] == s2[j])        //找到了第一个相等的  
            {  
                int as = i, bs = j, count = 1; // 保存第一个相等的首地址  
                while(as + 1 < len1 && bs + 1 < len2 && s1[++as] == s2[++bs])     //查找最大相等长度  
                    count++;  
                if(count > maxlen)  //如果大于最大长度则更新  
                {  
                    maxlen = count;  
                    *r1 = s1 + i;  
                    *r2 = s2 + j;  
                }  
            }  
        }  
    }  
}