笔试题练习（七）

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;
                }
            }
        }
    }
}