几个小算法

介绍几个小算法：数制转换、数据交换、最大公约数、N次方快速算法、KMP算法。这几个算法在相关数据结构和算法书上都有介绍，这里给出C语言实现例子，供大家参考。（刘爱贵 / Aiguille.LIU）

1、数制转换算法
十进制数N转换为d进制数，根据公式 N = (N div d) * d + N mod d实现 ，堆栈的典型应用。C语言实现如下：

#include "./stack.h"
#include <stdlib.h>

void conversion(int x, int d)
{
  SqStack s;
  SElemType e;

  InitStack(&s);
  while (x) {
    Push(&s, x%d);
    x = x/d;
  }

  while(!StackEmpty(&s)) {
     Pop(&s, &e);
     printf("%d",e);
  }
  printf("/n");
}

int main(int argc, char *argv[])
{
  int x ,d ;
  x = atoi(argv[1]);
  d = atoi(argv[2]);
  conversion(x, d);
}

2、数值交换算法
三种方法：(1)使用临时变量 (2)不使用中间变量，仅使用加法运算 (3)不使用中间变量，使用异或XOR操作。

#include <iostream.h>

template <typename T>
void swap_var(T &a, T &b)
{
  T tmp;
  tmp = a;
  a = b;
  b = tmp;
}

template <typename T>
void swap_add(T &a, T &b)
{
  a = a - b;
  b = a + b;
  a = b - a;
}

template <typename T>
void swap_xor(T &a, T &b)
{
  a = a ^ b;
  b = b ^ a;
  a = a ^ b;
}

int main(int argc, char *argv[])
{
  int a, b;
  a = atoi(argv[1]);
  b = atoi(argv[2]);

  swap_var(a, b);
  cout<<"swap_var: a="<<a<<", b="<<b<<endl;

  swap_add(a, b);
  cout<<"swap_add: a="<<a<<", b="<<b<<endl;

  swap_xor(a, b);
  cout<<"swap_xor: a="<<a<<", b="<<b<<endl;
}

3、最大公约数算法
EUCLID算法：gcd(m, n) = gcd(n, m mod n)。

long euclid(long m, long n)
{
  long r;

  while (n != 0) {
    r = m % n;
    m = n;
    n = r;
  }

  return m;
}

int main(int argc, char *argv[])
{
  long m, n;

  m = atol(argv[1]);
  n = atol(argv[2]);
  printf("gcd(%d,%d)=%d/n", m, n, euclid(m, n));
}

4、N次方快速算法
基本思想：把指数转化为二进制，然后使用Scaling Method，时间复杂度为O(log p)。

#include <stdlib.h>

unsigned power(unsigned n, unsigned p)
{
  unsigned k = 1;

  while (p>1) {
    if(0 != (p & 1))
      k *= n;
    n *= n;
    p /= 2;
  }

  return n*k;
}

int main(int argc, char *argv[])
{
  int n, p;
  n = atoi(argv[1]);
  p = atoi(argv[2]);
  printf("power(%d,%d)=%d/n", n, p, power(n,p));
}

5、KMP串匹配算法
　　串的模式匹配是串处理系统中的最重要操作之一，普通匹配算法的时间复杂度为O(m*n)。然而，KMP算法的算法时间复杂度为O(m+n)，其主要改进是：当出现比较不等时，不需回溯指针，而是利用已经得到的部分匹配的结果将模式向后滑动尽可能远的距离。
　　KMP算法的本质是基于有限自动机理论，它简化了有限自动机的构造，只考虑当前节点匹配是否成功，即两个分支的走向，成功则j++，失败则转到next[i] 的节点继续。

#include <iostream.h>

int* get_nextval(const char *s, int &len)
{
    len = strlen(s);
    int *next = new int[len];
    int i = 0, j = -1;
    next[0] = -1;
    while(i<len-1) {
        if (j == -1 || s[i] == s[j]) {
            ++i;
            ++j;
            if (s[i] != s[j]) {
                next[i] = j;
            } else {
                next[i] = next[j];
            }
        } else {
            j = next[j];
        }
    }
    return next;
}

int KMP(const char *s, const char *t)
{
    int slen,tlen;
    int i = 0, j = 0;
    int *next = get_nextval(t, tlen);
    slen = strlen(s);
    while(i<slen && j<tlen) {
        if(j == -1 || s[i] == t[j]) {
            ++i;
            ++j;
        } else {
            j = next[j];
        }
    }
    delete[] next;
    if(j >= tlen)
        return i - tlen;
    return -1;
}

int main(int argc, char *argv[])
{
    char s[128], t[128];
    if (argc < 3) {
        cout<<"Usage: kmp <string> <substr>"<<endl;
        exit(-1);
    } else {
        sprintf(s, "%s", argv[1]);
        sprintf(t, "%s", argv[2]);
        int pos1 = KMP(s,t);
        int pos2 = strstr(s,t) - s;
        cout<<"KMP:"<<pos1<<endl;
        cout<<"strstr:"<<pos2<<endl;
    }
    return 0;
}