实现代码如下：

参考自：http://yangchuanhuahpu.blog.163.com/blog/static/18631884020125272205862/

#include<stdio.h>
#include<string.h>
#define N 10000
int main()
{
    char a[N];
    int i,j,n,t,p,max,t1;
    scanf("%d",&t1);
    while(t1--)
    {
    max = 0;
    scanf("%s",a);
    n=strlen(a);
    for(i=0;i<n;i++)
    {
        for(j=i+1;j<n;j++)
        {
            t=0;
            while(a[i+t]==a[j+t]&&(j+t)<n)
                t++;
            if(t>max)
            {
                max=t;
                p=i;
            }
            else if(t == max) //如果有长度一样的最长重复子串，那么比较它们的字典序
            {
                if(a[i]<a[p])
                {
                    max = t;
                    p = i;
                }
            }
        }
    }
    for(i=p;i<p+max;i++)
        printf("%c",a[i]);
    printf("\n");
    }
    return 0;
}

如果程序至多可以处理MAXN个字符，这些字符被存储在数组c中：

 在读取输入时，首先初始化a,这样，每个元素就都指向输入字符串中的相应字符：

这样，元素a[0]指向整个字符串，下一个元素指向以第二个字符开始的数组的后缀，等等。如若输入字符串为"banana",该数组将表示这些后缀：
a[0]:banana

a[1]:anana

a[2]:nana

a[3]:ana

a[4]:na

a[5]:a

由于数组a中的指针分别指向字符串中的每个后缀，所以将数组a命名为"后缀数组"

第二，对后缀数组进行快速排序，以将后缀相近的（变位词）子串集中在一起

qsort(a, n, sizeof(char*), pstrcmp)后

a[0]:a

a[1]:ana

a[2]:anana

a[3]:banana

a[4]:na

a[5]:nana

第三，使用以下comlen函数对数组进行扫描比较邻接元素，以找出最长重复的字符串：

由于少了内层循环，只是多了一次排序，因此该算法的运行时间为O(n logn). （nlogn比n大，取nlogn）

实现代码如下：

//对每种情况都要考虑清楚

#include <cctype>
#include <iostream>
#include <string>
#include <stack>
#include <map>

using namespace std;

int getPrecedence(const char optr) //给各个操作符定义优先级顺序，利用map容器
{
    map<char, int> precedTable;
    precedTable['#'] = 0;
    precedTable[')'] = 1;
    precedTable['+'] = 2;
    precedTable['-'] = 2;
    precedTable['*'] = 3;
    precedTable['/'] = 3;
    precedTable['('] = 10;
    return precedTable[optr];
}

int calculate(int a, char optr, int b)
{
    switch (optr) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/': return a / b;
        default: return 0;
    }
}

int evaluate(const string& expr)
{
    stack<int> opnd;  
    stack<char> optr;   
    char last_ch = '\0'; //每次检查字符时的前一个字符
    for (size_t i = 0; i != expr.size(); ++i) {  
        const char ch = expr[i];
        if (isspace(ch)) { //如果是空格，即跳过
            continue;
        } else if (isdigit(ch)) { //如果是数字，则压入操作数栈
            opnd.push(ch - '0');
        } else {
            if ((ch == '-'  || ch == '+') && (last_ch == '\0' || last_ch == '(')) //遇到 '+'、'-'，则压入0进操作数栈
                opnd.push(0);    //如 7-1，遇'-'则压入0进栈，，'-'则进操作符栈，遇到下一个数1，计算0-1得-1
            if (optr.empty() || ch == '(' || (optr.top() == '(' && ch != ')') || getPrecedence(ch) > getPrecedence(optr.top())) {
                optr.push(ch);
            } 
            else 
            {
                while (!optr.empty() && optr.top() != '(' && getPrecedence(ch) <= getPrecedence(optr.top())) 
                {
                    int b = opnd.top(); opnd.pop();
                    int a = opnd.top(); opnd.pop();
                    opnd.push(calculate(a, optr.top(), b));
                    optr.pop();
                }
                if (ch == ')')
                    optr.pop();    
                else
                    optr.push(ch);
            }
        }
        last_ch = ch;
    }
    while (!optr.empty()) {
        int b = opnd.top(); opnd.pop();
        int a = opnd.top(); opnd.pop();
        opnd.push(calculate(a, optr.top(), b));
        optr.pop();
    }
    int result = opnd.top(); opnd.pop();
    return result;
}

int main()
{
    int n;
    cin >> n;
    while (n-- > 0) {
        string expr;
        cin>>expr;
        cout << evaluate(expr) << endl;
    }
    return 0;
}

#include<iostream>
#include<cstring>
#include<stack>
using namespace std;
int main()
{
    int t,len;
    stack<char> mystack;
    cin>>t;
    while(t--)
    {
        int ok=0;
        char str[100];
        cin>>str;
        len=strlen(str);
        for(int i=0;i<len;i++)
        {
           switch(str[i])
           {
              case '(':
              case '[':
              case '{':
                  mystack.push(str[i]);
                  break;
              case ')':
                  if(mystack.top() == '(')
                  {
                      mystack.pop();
                      ok=1;
                  }
                  break;
              case ']':
                  if(mystack.top() == '[')
                  {
                      mystack.pop();
                      ok=1;
                  }
                  break;
              case '}':
                  if(mystack.top() == '{')
                  {
                      mystack.pop();
                      ok=1;
                  }
                  break;
              default: break;
           }
        }
        if(ok && mystack.empty())
            cout<<"ok"<<endl;
        else
            cout<<"error"<<endl;
    }

    return 0;
}
           

    for(i=0;i<N;i++)

{

a[i].x = randFloat(); a[i].y = randFloat(); 

}

p=head;
while(p->next !=NULL)
{
    q=p->next;
    p->next=q->next;
    free(q);
}
free(head);

#include<stdio.h>
#include<string.h>
int main()
{
    char str[]="0123456789";
    char sstr[80]={0}; //使用一数组储存移动后的字符串
    char *p;
    int c,j;
    static int i,n;
    p=&str[0];
    printf("input the number: \n");
    scanf("%d",&n); //输入要左移的前n个字符，即将这n个字符移动到最后面
    c=n;
    while( c-- && p++ ); //找到没有移动过的剩下的全部字符，把它们储存在数组sstr 中

        for(i=0;i<strlen(str)-n;i++)
        {
            sstr[i]= *p;
            p++;
        }
        p=&str[0];  //指针指向第一个字符
        for(j=i;j<strlen(str);j++) //将要移动的字符一个一个地“接”到数组sstr后面
        {
            sstr[j]= *p;
            p++;
        }
        sstr[j]='\0'; //最后字符串结尾用'\0'
        printf("%s",sstr);  
        return 0;
}