练习

1、两个已排序数组合并以后的中位数

int getMedin(int A[],int m,int B[],int n)  {      int p1=0;      int p2=0;      int mid=p1;      int flag=0;      for(int i=0;i<(m+n)/2;)      {          while(p1<m&&p2<n&&i<(m+n)/2&&!flag)          {              if(B[p2]<A[mid])              {                  ++p2;++i;              }              else              {                  mid=p2;                  flag=1;                  ++p1;                  ++i;              }          }          while(p1<m&&p2<n&&i<(m+n)/2&&flag)          {              if(A[p1]<B[mid])              {                  ++p1;++i;              }              else              {                  mid=p1;                  flag=0;                  ++p2;                  ++i;              }          }          while((p1==m||p2==n)&&i<(m+n)/2)          {              ++mid;              ++i;          }      }      if(flag)          return B[mid];      return A[mid];    }  

2、已知两个链表各自有序，写一个程序使他们合并起来依然有序

struct node  {      int _data;      node* _next;  };    void merge(node *head1,node *head2,node *head3)  {      node *pl1=head1->_next;      node *pl2=head2->_next;      node *pl3;      head3=head1;      head3->_next=NULL;      free(head2);      pl3=head3;      while(pl1!=NULL&&pl2!=NULL)      {          if(pl1->_data<=pl2->_data)          {              pl3->_next=pl1;              pl1=pl1->_next;              pl3=pl3->_next;          }          else          {              pl3->_next=pl2;              pl2=pl2->_next;              pl3=pl3->_next;          }             }      pl3->_next=NULL;      if(pl1!=NULL)          pl3->_next=pl1;      if(pl2!=NULL)          pl3->_next=pl2;  } 

如果想得到相反的序列就用头插法

3、字符串匹配查找

#include<iostream>  using namespace std;    //str1指向带查找字符串，str2指向待匹配字符串  char *strfind(const char *str1,const char *str2)  {      const char *ptr1=str1;      const char *ptr2=str2;      const char *result=(char *)0;      while(*ptr1!='\0')  //查找字符串没有结束      {          if(*ptr1==*ptr2)          {              result=ptr1;              while(*ptr2!='\0')              {                  if((*ptr1!='\0')&&(*ptr1==*ptr2))                  {                      ptr1++;                      ptr2++;                  }                  else                      break;              }              if(*ptr2=='\0')                  return (char *)result;              else if(*ptr1!='\0')              {                  ptr2=str2;                  ptr1=result+1;                  result=(char *)0;              }              else              {                  break;              }          }          ptr1++;      }      return (char*)0;  }    int main()  {      char s1[]="abcdefghijk";      char s2[]="def";      char *ptr=strfind(s1,s2);      cout<<*ptr<<endl;      return 0;  }  

这是一道风行的笔试题，其实代码比较简单，就是里面的逻辑关系要考虑清楚，不能漏掉任何一种情况

4、反转字符串，保持子串相对位置不变

思路：先将字符串里面的子串反转，然后再将整个字符串反转

void reverse(char *str,int m,int n)  {      if(!str)  //字符串为空直接退出          exit(0);      if(m==n)//子串只有一个元素不用交换          return;      for(int i=m,j=n;i<j;i++,j--)  //交换元素      {          char temp=str[i];          str[i]=str[j];          str[j]=temp;      }  }    int main()  {      char str[]="a bc def gh ijk";      int len=strlen(str);      int m=0,n=0;      for(int i=0;i<len;i++)      {          if(str[i]==' ')          {              n=i-1;              reverse(str,m,n); //交换子串              m=i+1;              n=i+1;          }      }      reverse(str,0,len-1);//交换整个数组      for(int i=0;i!=len;i++)          cout<<str[i]<<" ";      cout<<endl;      return 0;  }  

5、给定一数组a[N]，我们希望构造数组b [N]，其中b[j]=a[0]*a[1]…a[N-1] / a[j]，在构造过程中，不允许使用除法

#include<iostream>  using namespace std;    void printfn(int a[],int n)  {      for(int i=0;i<n;i++)          cout<<a[i]<<" ";      cout<<endl;  }  int main()  {      const int MAX=5;      int a[MAX]={1,2,3,4,5};      int b[MAX];      b[0]=1;      for(int i=1;i<MAX;i++)      {          b[i]=b[i-1]*a[i-1];      }      /*        b[0]=1;        b[1]=a[0];        b[2]=a[0]*a[1];        b[3]=a[0]*a[1]*a[2];        b[4]=a[0]*a[1]*a[2]*a[3];        */      for(int i=MAX-1;i>0;i--)      {          b[i]*=b[0];          b[0]*=a[i];                }      /*         b[4]=b[4]=a[0]*a[1]*a[2]*a[3];                 b[0]=a[4];          b[3]=b[3]*a[4]=a[0]*a[1]*a[2]*a[4];            b[0]=a[4]*a[3];          b[2]=b[2]*a[2]=a[0]*a[1]*a[3]*a[4];            b[0]=a[4]*a[3]*a[2];         b[1]=b[1]*b[4]=a[0]*a[2]*a[3]*a[4];            b[0]=a[4]*a[3]*a[2]*a[1];         */      printfn(a,5);      printfn(b,5);      return 0;  }  

6、如下为类型MyString的声明，请为该类型添加赋值运算符函数

class CMyString{public:CMyString(char* pdata=NULL);CMyString(const CMyString& str);CMyString& operator=(const CMyString& str);~CMyString(void);private:char* m_data;};

 写出的代码要关注以下几点

1、是否把返回值声明为该类型的引用，只有返回一个引用才允许连续赋值。

2、是否传入的参数是常量引用

3、是否释放实例本身已有的内存

4、是否判断传入的参数和当前的实例是不是同一个实例

综合一下可以写出

CMyString& CMyString::operator=(const CMyString &str){if(this==&str)return *this ;delete []m_data;  m_data=NULL;m_data=new char[strlen(str.m_data)+1];strcpy(m_data,str.m_data);return *this;}

但是这并不是很完善的代码

参照effective C++中的条款11

如果new char导致异常，CMyString最终会持有一个指针指向一块被删除的char[]，这样的指针有害，你无法安全的删除它们，甚至无法安全的读取它们，唯一能对它们做的安全事情是付出许多调试找出错误的根源。

为了避免异常，对代码做出以下的修改

CMyString& CMyString::operator=(const CMyString &str){if(this!=&str){CMyString strTemp(str);char *ptemp=strTemp.m_data;strTemp.m_data=m_data;m_data=ptemp;}return *this;}

先创建一个临时实例strTemp，接着把strTemp.m_data和自身实例的m_data作交换。由于strTemp是一个局部变量，当程序运行到if外面时就会自动调用析构函数，相当于用析构函数释放之前实例的内存。