The following is the implementing in "Algorithms in C". The table initiation is skipped since it's not that difficult anyway.

int mischarsearch(char *p, char *a)
{
 int i,j,t, M=strlen(p), N=strlen(a);
 initskip(p);
 for (i=M-1, j=M-1; j>0; i--, j--)
 // both starts from the right most letter
 {
  while (a[i] != p[j])
  {
   t=skip[index(a[i])];
   i+= (M-j>t)?M-j:t;   //use the rightmost one; this acutally doesn't matter since it depends on how you design your implementing
   if (i>=N)  return N;
   j=M-1;                  // reset the pointer to the right most
  }
 }

 return i;
}

The BM algorithm doesn't fit for binary string very well, but we can group bits to make "characters". However, there are some consideration:

if we take b bits, then we need a table of 2^b entries, thus b should be small so the tale is not too large. Then there are M-b+1 different b-bit sections in the pattern, so we want M-b+1 to be significantly less than 2^b. For example, if we take b about lg(4M), then the table will be more than 3/4 filled with M entries (?). Also b must be less than M/2, otherwise the pattern could be missed if we split between two b-bit sections.

On pp.289 in "Algorithms in C", hash based string searching is mentioned (Rabin-Karp).

Acutally, it is very similar to the solution on my 1st phone interview with Google. The initial idea is to create a hash value for each word (or each M-characters) in the text. While this is not feasible if the text is too huge, we just need to compute the hash value of the pattern and compare it with each M-characters in the text (computation is done in real-time) [ damn, i invented this within less than 10 mins in the google phone interveiw although I never read this algorithm before. still got rejected......maybe i didn't make my idea clear)

Detailed algorithms is on pp.289

KMP and BM takes O(N+M). For RK, the worst case would be O(NM), but usually in practice it relies on N+M steps.

 Other solutions could be binary tree, Patricia (B-tree). It's probably worthy to read Markov chain.