c/c++ 面试常考算法

二分查找算法

int bfind(int *a,int len,int val) { int m=len/2; int l=0; int r=len; while(l!=m&&r!=m) { if(a[m]>val) { r=m; m=(l+m)/2; } if(a[m]

2.在母串中查找子串出现到次数

int find(char *str,char *s) { char *s1; char *s2 int count=0; while(str!='/0') { s1=str; s2=s; while(*s1==*s2&&(*s1!='/0')&&(*s2!='/0')) { s1++; s2++; } if(*s2=='/0') count++; str++; } return count; }

3.查找第一个匹配子串位置,如果返回的是s1长度len1表示没有找到

int find(char *s1,char *s2) { int len1=strlen(s1); int len2=strlen(s2); if(len1-len2<0) return len1; for(int i=0;i

在这里要提下KMP算法， KMP 匹配算法是由 "Knuth  Morris  Pratt"  提出的一种快速的模式匹配算法。

   1.待解决的问题：假设P为给定的子串，T是待查找的字符串，要求从T中找出与P相同的所有子串，这称为模式匹配问题。 (可以给出子串在T中的位置) (下文中提到的P和T分别为子串和目标串)

   让我们先来看个例题：

   T:   t0      t1     t2      t3 .... tm-1 ... tn-1

   P:   p0      p1     p2      p3 .....pm-1         

 

   从T的最左边开始比较，使得 TK = PK，则匹配成功。

   2.解决模式匹配问题的方案：

   A：朴素的模式匹配算法(思路简单,但不够简便，时间长，有回溯)：最简单和最直接的做法，用P中的字符依次与T中的字符进行比较，遇到不相等的字符，则可将P右移一个字符，重新进行比较，直到某次匹配成功或者到达P的最右字符移出T为止。

   如：若P="aaaba", T="aaabbaaaba", 则匹配过程如下图

                               i                                                                                         i    (指针发生回溯)

    T:     a   a   a   b   b    a   a   a   b  a                                                  T:     a     a      a     b     b    a     a     a      b     a

    P:     a   a   a   b   a                                                                                         a      a     a     b    a

                               j                                                                                          j

                 a   a   a   b   a                

                                   .....

                               a   a   a   b  a           

   从上不难分析，最坏的情况是“每次比较都在最后一个字符出现不等，每趟最多比较M次，最多比较N-M+1趟，总的比较次数最多为M*(N- M+1)” ，时间复杂性为0(M*N)。 在P右移一位时，不管上一趟比较的中间结果是什么，因此回溯是不可避免的(如：前3个aaa 不需要一位一位的移 ) 。下面我来介绍无回溯的KMP算法。

   3.KMP算法解决匹配中哪些主要问题：

   A.当字符串比较出现不等时，确定下一趟比较前，应该将P右移多少个字符； 

   B. P右移后，应该从哪个字符开始和T中刚才比较时不等的那个字符继续开始比较。

    我们通过朴素模式匹配的例子来引出问题。在第一次比较过程中失败的是P的第4个字符b，这表明P的前4个字符是成功的。模式P的第3个字符b在它的前3个 字符(aaa)中并未出现。因此，在下一次比较时候，至少要将P向后移4个字符；再看P的第一个字符与最后一个字符是相同的，因此将P右移4个字符后，再 从第一个字符比较，肯定也是不等的。综上所诉：应该将P右移5个字符，再从P的第0个字符和T的第5个字符开始比较！

 KMP算法核心：KMP算法借助于一个辅助数组next来确定当匹配过程中出现不等时，模式P右移的位置和开始比较的位置。next[i]的取值 只与模式P本身的前i+1项有关，而与目标T无关。匹配过程中遇到Pi不等于Tj时，若next[i]>=0，则应将P右移i-next[i]位个 字符，用P中的第next[i]个字符与Tj 进行比较；若：next[i]= -1，P中的任何字符都不必再与Tj比较，而应将P右移i+1个字符，从P0和Tj+1从新开始下一轮比较(可能不太好理解，自己找个例子，对着话一句一 句试试看)

 

   因此只要计算出与模式P相关的next数组，按上面的含义，就可以很容易地给出串的匹配算法。(问题就这样转化了)

    C.next的计算：以P = " 01001010100001"为例。

     i   :            0   1   2   3   4   5   6    ..... 

     P   :            0   1   0   0   1   0   1    .....

    j(next[i]) :     -1   0   0   1   1   2   3    .....

   如1：我们要算next[2]的值,有关的为P本身的前2个字符0,1。在字符串01中，寻找出“左右相同的最大字符串，此字符串所含字符的个数就为next[i]的值”而0不等于1，相同字符串不存在，所以next[i] = 0；

   如2：我们要算next[6]的值，有关的为P本身前6个字符010010 。此字符串中010 = 010左右相同的最大字符串为010，个数为3。所以next[i]=3；

   如3：我们要算next[5]的值，有关的为P本身前5个字符01001。此字符串中 01=01 左右相同的最大字符串为01，个数为2。所以next[i]=2；

 

可以参考清华大学严魏敏视频教程http://v.youku.com/v_show/id_XOTI2ODQ4MTI=.html

 

4.实现字符串反转

void reverse(char *str) { assert(str!=NUll) char *p1=str; char *p2=str-1; while(*++p2);//指向末尾，一般不让用strlen p2-=1; while(p1

5.实现单链表反转

要求用常规方法和递归的方法

(1)一般方法

typedef struct linknode { int data; struct linknode *next; }LinkNode,*Linklist LinkNode *reverse(Linklist head) { if(!head&&!head->next) return head; else { LinkNode *p1=head; LinkNOde *p2=head->next; p1->next=NULL; while(p2) { LinkNode *temp=p2->next; p2->next=p1; p1=p2; p2=temp; } return p1; } }

（2）递归的方法

LinkList reverse(Linklist head) { if(!head||!head->next) return head; Linklist newhead=reverse(head->next); head->next->next=head; head->next=NULL; return newhead; }

将一个数字字符串转换为数字."1234" -->1234int atoi(char *s) { assert(s!=NULL) int num; while(*s>'0'&&*s<'9') { num=num*10+(*s++)-'/0'; } return num; }  

判断字符串是否回文

int Isreverse(char *str) { assert(str!=NULL); int found=1; char *s=str-1; while(*++p); p-=1; while(*str==*p&&str

  排序算法

（1）快排

 

void quik_sort(int a[],int low,int high) { int i,j,piv; while(low=piv) j--; if(i=piv) i++; if(i

(2) 冒泡

/*大数沉底*/ void bub_sort(int a[]) { int i,j,swap; for(i=0;ia[j+1]&&j>=0;j--) { swap=a[j]; a[j]=a[j++]; a[j++]=swap; } } } /*小数上浮*/ void bub_sort(int a[]) { int i,j,swap,exchange; for(i=0;i=i;j--) { if(a[j+1]

(3)插入排序

void insertion_sort(int a[]) { int i,j,key; for(i=1;i=0&&a[j]>key) { a[j+1]=a[j]; j--; } a[i+1]=key; } }

(4)简单选择排序

void selet_sort(int a[]) { int i,j,m; for(i=0;i

编写string类的普通构造函数，复制构造函数，和赋值函数

class string { public: string(const char* str=NULL);//普通构造函数 string(const string &other);拷贝构造函数 ~string(void);//析构函数 string& operate=(const string &other);//赋值函数 private: char *m_data;//用于保存字符串 } string::string(const char *str) { if(str==NULL) { m_data=new char[1]; *m_data='/0'; } else { int length=strlen(str); m_data=new char[lenth+1]; strcpy(m_data,str); } } string::~string(void) { delete[] m_data; } string::string(const string &other) { int length=strlen(other.m_data); m_data=new char[length+1]; strcpy(m_data,other.m_data); } string& string::operate=(const string &other) { if(this==&other) return *this; delete[] m_data; int length=strlen(other.m_data); m_data=new char[length+1]; strcpy(m_data,other.m_data); return *this; }

编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh”
函数头是这样的：

//pStr是指向以'/0'结尾的字符串的指针
//steps是要求移动的n
void LoopMove ( char * pStr, int steps )
{
       请填充。。。。
}

int LoopMove(char *pstr,int steps) { int n=strlen(str)-steps; char temp[MAX_LEN] strcpy(temp,pstr+n); strcpy(temp+steps,pstr); *(temp+strlen(pstr))='/0'; strcpy(pstr,temp); }