软件工程师面试编程常见函数实现

【转自：http://blog.youkuaiyun.com/gflrlm/article/details/4967461】

1引用与指针区别：引用必须初始化，不可以改变值，不可指向NULL。
2 字符串比较：

int strcmp(char  *source, char *dest) 相等返回0，不等返回-1；
{  ASSERT((source!=NULL)&&(dest!=NULL));
  int i,j;  for(i=0; source[i]==dest[i]; i++)
  {   if(source[i]==’/0 && dest[i]=='/0')    return 0;  
       else    return -1;  }

  }
3 .字符串复制，遇到'/0'立即停止复制。

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

{

ASSERT(strDest != NULL && strSrc != NULL);
char *addr = strDest;
while(*strDest++=*strSrc++)
NULL; //NULL可以省略，但更有利于编译器发现错误
return addr;

}

4子串查找，返回子字符串所在位置

int strindex(char *str,char *substr)
{   int end,i,j;
   end = strlen(str) - strlen(substr);  /*计算结束位置*/
   if ( end > 0 )                 /*子字符串小于字符串*/
   {   for ( i = 0; i <= end; i++ )
         for ( j = i; str[j] == substr[j-i]; j++ ) /* 用循环比较 */
            if ( substr[j-i+1] == '/0' ) /* 子字符串字结束*/
               return i + 1;           /* 找到了子字符串*/   }
 return -1;

}
4 、memcpy()用来拷贝src前n个字节到dest所指的地址上。与strcpy()不同的是,memcpy()会完整的复制n个字节,不会因为遇到字符串结束'/0'而结束,返回指向dest的指针
void *memcpy(void* dest,const void* src, int size)
{

void* pDest = (char*)dest; 

void* pSrc = (char*)src;
ASSERT(dest != NULL && src != NULL);
/* 内存块重叠吗？如果重叠，就使用memmove */
ASSERT(pDest>=pSrc+size || pSrc>=pDest+size);
while(size-->0)   *pDest++ == *pSrc++;
return dest;

}
5、void *Memmove(void *Dest, const void*Src,int count)
{

assert(Dest!=NULL && Src!=NULL);
void* pDest = Dest;
if (Dest<Src && (char*)Dest > (char*)Src + count)//没有地址重叠
   {   while(count--)  *(char*)Dest++ = *(char*)Src++;  }
else //有地址重叠，从src的串尾开始复制
   {   Dest = (char*)Dest + count - 1;  

        Src = (char*)Src + count - 1;//指向串尾，从尾部开始复制
        while(count--)   *(char*)Dest- - = *(char*)Src- -;
    }
return Dest;

}
6、单链表插入删除节点

例：在单链表的第i个位置插入一个数据，成功插入返回1，否则返回0；

struct linklist 
    {int data； 
    struct linklist*next； 
    }； 

在节点Pre后面插入s节点
s=(Linklist*)malloc(sizeof(Linklist);
s->next=Pre->next ;   Pre->next=s;

/***************单链表插入节点********************/

int listinsert(linklist *head,int i , int data)

{

    linklist *p,*s;int j=0;

    p=head;

while(p && j++<i) { p=p-next;} //查找插入第i-1个位置

if(p==NULL ||  j>i) {cout<<"Positon Error"; return 0;}

s=(linklist*)malloc(sizeof(linklist));

assert(s!=NULL);

s->data=data; s->next=p->next; p->next=s;//在第i-1个位置后面，即指针p后面插入data

return 1;

}

/***************单链表删除节点********************/

int listdelete(linklist *head,int i)

{

    linklist *p,*q;int j=0;

    p=head;

while(p->next && j++<i) { p=p-next;} //查找第i-1个位置，待删除节点的前一个节点

if(p->next==NULL ||  j>i) {cout<<"Positon Error"; return 0;}

q=p->next; p->next=q->next;//删除节点i

return 1;

}

 

7、 翻转链表(链表逆序)：void reverselinklist(linklist *head)

{

    linklist *pre,*curr;//设置两个指针

    pre=head;curr=head->next;head-＞next=NULL;
    while(curr!=NULL) 

            {pre=curr;curr=curr->next;

              pre->next=head-＞next;head->next=pre;}//在head后面一次插入各个pre

}
8、实现有序链表上的插入
void linklist(linklist head ,elemtype data)
{

   linklist pre,curr, q; 

   pre=head; curr=head->next;
   while(curr!=NULL&&curr->data<=x) 

           {pre=curr; curr=curr->next; } //找到插入位置
   q =(linklist *)malloc(sizeof(linklist));assert(q!=NULL);

   q->data=data ; //申请节点，插入数据
   q->next=pre->next ; pre-next=q; 

 }
9、折半查找干啥用？( 用于对递增顺序表的查找)
int zheban(int *t)

{

    low=0;high=length-1;

    while(low＜=high)
          {

              mid=(low+high)/2; 

              if (table[mid].data=x)   return mid;
              else

                  {  if(x＜t[mid].data  high=mid-1; else low=mid+1;}
           }//while

    return -1;

}
10、双向链表删除节点P，P后插入节点;
答：

struct link{
  struct link *prior; //前驱 

  int data; 

  struct link *next; //后继
};

/********************双向链表删除操作***************************/

int ListDelete_DuL(struct link *head, int num)
{

   struct link *p; 
   p=head->next;
   while(p&&p->data!=num) p=p->next;//查找要删除的结点
   if(p!=NULL)
     {p->pre->next=p->next;
       p->next->pre=p->pre;
       p->pre=NULL;  p->next=NULL;
       free(p);    return 1;// 比如要查找某元素，找到就返回1，没找到返回0。判断结果的
      }
  else    return 0;
}

/********************双向链表插入操作*****************************/

int ListInsert_DuL(DuLinkList *head,int num)
{

   struct link *p,*q;
   p=head->next;
   while(p&&p->data!=num)  p=p->next; //查找插入位置
   if(p!=NULL)
   { 

      q=(struct link *)malloc(sizeof(struct link));

      ASSERT(q!=NULL);
      q->data=num;
　　q->pre=p;//插入节点
　　q->next=p->next;
　　p->next->pre=q;
　　p->next=q;   return 1;
　　}
else    return 0;  }