一套编程题 编程题 31-40

31. 写一个函数找出一个整数数组中，第二大的数.
const int MINNUMBER = -32767 ;
int find_sec_max( int data[] , int count)
{
    int maxnumber = data[0] ;
    int sec_max = MINNUMBER ;
    for ( int i = 1 ; i < count ; i++)
    {
        if ( data[i] > maxnumber )
        {
            sec_max = maxnumber ;
            maxnumber = data[i] ;
        }
        else
        {
            if ( data[i] > sec_max )
            sec_max = data[i] ;
        }
     }
     return sec_max ;
}

32. 如何判断一个单链表是有环的？（注意不能用标志位，最多只能用两个额外指针）
struct node { char val; node* next;}
bool check(const node* head) {} //return false : 无环；true: 有环
一种O（n）的办法就是（搞两个指针，一个每次递增一步，一个每次递增两步，如果有环的话两者必然重合，反之亦然）：
bool check(const node* head)
{
    if(head==NULL) return false;
    node *low=head, *fast=head->next;
    while(fast!=NULL && fast->next!=NULL)
    {
        low=low->next;
        fast=fast->next->next;
        if(low==fast) return true;
    }
    return false;
}

33.不使用库函数，编写函数int strcmp(char  *source, char *dest)相等返回0，不等返回-1
int StrCmp(char  *source, char *dest)
{
		assert(source !=NULL);
		assert(dest!=NULL);
		while(*source= =*dest&&*source&&*dest)
		{
			source++;
			dest++;
		}
		return (*source!=*dest)?-1:0;
}

34.写一个函数，实现将一个字符串中的’\t’替换成四个’*’， ’\t’个数不定。如char *p=”ht\thdsf\t\ttt\tfds dfsw\t ew\t”,替换后p=”ht****hdsf********tt****fds dfsw**** ew****”。
char *Replace(char *Sorce)
{
		char *pTemp=Sorce;
		int iCount=0;
		int iSizeOfSorce=0;

		while(*pTemp!='\0')
		{
			if('\t'==*pTemp)
				iCount++;
			pTemp++;
		}
		iSizeOfSorce=pTemp-Sorce;

		char *pNewStr=new char[iSizeOfSorce+3*iCount*sizeof(char)+1];
		char *pTempNewStr=pNewStr;

		pTemp=Sorce;
		while(*pTemp!='\0')
		{
			if('\t'==*pTemp)
			{
				for(int iLoop=0; iLoop<4; iLoop++)
				{
					*pTempNewStr='*';
					pTempNewStr++;
				}
				pTemp++;
			}
			else
			{
				*pTempNewStr=*pTemp;
				pTemp++;
				pTempNewStr++;
			}
		}
		*pTempNewStr='\0';

		return pNewStr;
}

35．写一函数实现将一个字符串中的数字字符全部去掉。
void RemoveNum(char strSrc[])
{
		char *p=strSrc;
		char *q;
		while(*p!='\0')
		{
			if(*p>='0'&&*p<='9')
			{
				q=p;
				while(*q!='\0')
				{
					*q=*(q+1);
					q++;
				}
			}
			else
			{
				p++;
			}	
		}
}

36、链表节点结构如下：
struct STUDENT
{
	long num;
	float score;
	STUDENT *pNext;
};
编写实现将两棵有序（按学号从小到大）的链表合并的函数，要求合并后的链表有序（按学号从小到大）
STUDENT *EmergeList(STUDENT *pHead1,STUDENT *pHead2)
{
    		//取小者为表头
    		STUDENT * pHead;
		STUDENT *p1;
		STUDENT *p2;
		STUDENT *pCur;
		STUDENT *pTemp;

   		if (pHead1->num<= pHead2->num)
    		{
        		pHead = pHead1; 
			p2 = pHead2;
			p1=pHead1->pNext;
    		}
   		 else
    		{
        		pHead = pHead2; 
			p1 = pHead1;
			p2=pHead2->pNext;
    		}
		pCur=pHead;
		while(p1!=NULL&&p2!=NULL)
		{
			if(p2->num<p1->num)
			{
				pCur->pNext=p2;
				p2=p2->pNext;
				pCur=pCur->pNext;
			}
			else if(p2->num>p1->num)
			{
				pCur->pNext=p1;
				p1=p1->pNext;
				pCur=pCur->pNext;
			}
			else if(p2->num==p1->num)
			{
				pCur->pNext=p1;
				p1=p1->pNext;
				pCur=pCur->pNext;
				pTemp= p2;
				p2=p2->pNext;
				delete pTemp;
				pTemp = NULL;
			}
		}
		if(NULL==p1)
		{
			pCur->pNext=p2;
		}
		else if(NULL==p2)
		{
			pCur->pNext=p1;
		}
   
    		return pHead;
}

37. 写一个函数，完成内存之间的拷贝。[考虑问题是否全面]
void* mymemcpy( 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+cout ) 能考虑到这种情况就行了
       {
           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( void )
{
       char str[] = "0123456789";
       mymemcpy( str+1, str+0, 9 );
       cout << str << endl;
       system( "Pause" );
       return 0;
}


38.写一个函数，将其中的\t都转换成4个空格。
该函数命名为convert,参数的意义为：*strDest目的字符串,*strSrc源字符串,length源字符串的长度
函数实现为：
    char* convert(char *strDest, const char *strSrc,int length)
    {
        char * cp = strDest;
        int i=0;
        while(*strSrc && i)
        {
            if (*strSrc=='\t') //将\t转换成4个空格
            {
                for(int j=0;j<4;j++)
                *cp++=' ';
            }
            else //否则直接拷贝 
                *cp++=*strSrc;
                strSrc++;
                i++;
            }
            return strDest;
    }

39.实现双向链表删除一个节点P，在节点P后插入一个节点，写出这两个函数;
    假设线性表的双向链表存储结构
    typedef struct DulNode{
        struct DulNode *prior; //前驱指针
        ElemType data; //数据
        struct DulNode *next; //后继指针
    }DulNode,*DuLinkList;
    删除操作
    Status ListDelete_DuL(DuLinkList &L,int i,ElemType &e)
    {
        if(!(p=GetElemP_DuL(L,i)))
            return ERROR;
        e=p->data;
        p->prior->next=p->next;
        p->next->prior=p->pror;
        free(p);
       return OK;
    }
    插入操作
    Status ListInsert_DuL(DuLinkList &L,int i,ElemType &e)
    {
        if(!(p=GetElemP_DuL(L,i)))
            return ERROR;
        if(!(s=(DuLinkList)malloc(sizeof(DuLNode)))) 
            return ERROR;

        s->data=e;
        s->prior=p->prior;
        p->prior->next=s;
        s->next=p;
        p->prior=s;
        return OK;
    }

40、请用标准C语言实现下列标准库函数，设计中不得使用其他库函数。
char *strstr(char *str1,char *str2);
在字符串str1中，寻找字串str2，若找到返回找到的位置，否则返回NULL。
char * strstr ( const char * str1, const char * str2 )
{
    char *cp = (char *) str1;
    char *s1, *s2;
    if ( !*str2 )
        return((char *)str1);
    while (*cp)
    {
        s1 = cp;
        s2 = (char *) str2;
        while ( *s1 && *s2 && !(*s1-*s2) )
            s1++, s2++;
        if (!*s2)
            return(cp);
        cp++;
    }
    return(NULL);
}