常见的算法题

1. 字符串逆序，最简单的方法，就是反过来读。

// 字符串逆序
char* Reverse(char* p)
{
    char* t=p;
    while(*t++)
        ;
    t-=2;
    //char* s = new char[sizeof(char)*(t-p+2)];
    char* s=(char*) malloc(sizeof(char)*(t-p+2));
    char* r=s;
    while(t>=p)
    {
        *s++=*t--;
    }
    *s='\0';
    return r;
}

2. 字符串逆序还有一种方法是，前后交换。

//原地逆序
char* Reverse_b(char* p)
{
    char* t=p;
    char* r=p;
    while(*t++)
        ;
    t-=2;

    while(t>r)
    {
        char c=*r;
        *r++=*t;
        *t--=c;
    }

    return p;
}

3. 快速排序是冒泡排序的改进，取一个参考值，经过一遍遍历，大于这个参考值的数在右边，小于参考值的数在左边。

 

//快速排序
int* QuickSort(int* p,int l, int r)
{
    int m=p[l];
    int n=l;
    int t;
    int i=l;
    int j=r;

    if(r>l)
    {
        while(j>i)
        {
            while (m<=p[j]&&j>i) j--;
            if(j>i)
            {
                p[n]=p[j];
                p[j]=m;
                n=j;
            }

            while (p[i]<=m&&j>i)i++;
            if(j>i)
            {
                p[n]=p[i];
                p[i]=m;
                n=i;
            }
        }
        QuickSort(p,l,n);
        QuickSort(p,n+1,r);
    }

    return p;
}

 

//求最小公倍数
// 最小公倍数=两个数相乘/最大公约数
// 假设b=x%y, 如果一个数能被x,y整除，那么一定可以被b,y 整除，这样一次类推，知道余数为零。

int LCM(int x,int y)
{
    int m=x,n=y;

    if(m>0&&n>0)
    {
        int b= m%n;
        while(b)
        {
            m=n;
            n=b;
            b=m%n;
        }

        return x*y/n;
    }

    return 0;
}

 

本文出自 “涓涓浮�V” 博客，谢绝转载！