计算机复试上机C/C++算法积累

 

C/C++字符串处理

strncpy(a,b,5);

a[5]='\0';

 

char a[10];

memset(a,'#',sizeof(a));

a[10]='\0';

 

C：

char st[100];

1. 字符串长度

   strlen(st);

2. 字符串比较

   strcmp(st1,st2);

   strncmp(st1,st2,n);   把st1,st2的前n个进行比较。

3. 附加

   strcat(st1,st2);

   strncat(st1,st2,n);   n表示连接上st2的前n个给st1，在最后不要加'\0'。

4. 替换

   strcpy(st1,st2);

   strncpy(st1,st2,n); n表示复制st2的前n个给st1，在最后要加'\0'。

5. 查找

   where = strchr(st,ch)   ch为要找的字符。

   where = strspn(st1,st2); 查找字符串。

   where = strstr(st1,st2);

 

C++：

#include <string>

string str;

1. 字符串长度

   len = str.length();

   len = str.size();

2. 字符串比较

   可以直接比较

   也可以:

   str1.compare(str2);

   str1.compare(pos1,len1,str2,pos2,len2); 值为负，0 ，正。

   nops 长度到完。

3. 附加

   str1 += str2;  或

   str1.append(str2);

   str1.append(str2.pos2,len2);

4. 字符串提取

   str2 = str1.substr();

   str2 = str1.substr(pos1);

   str2 = str1.substr(pos1,len1);

   string a=s.substr(0,4);       //获得字符串s中从第0位开始的长度为4的字符串

5. 字符串搜索

   where = str1.find(str2);

   where = str1.find(str2,pos1); pos1是从str1的第几位开始。

   where = str1.rfind(str2); 从后往前搜。

6. 插入字符串

   不是赋值语句。

   str1.insert(pos1,str2);

   str1.insert(pos1,str2,pos2,len2);

   str1.insert(pos1,numchar,char);    numchar是插入次数，char是要插入的字符。

7. 替换字符串

   str1.replace(pos1,str2);

   str1.replace(pos1,str2,pos2,len2);

8. 删除字符串

   str.erase(pos,len)

   str.clear();

9. 交换字符串

   swap(str1,str2);

10. C --> C++

   char *cstr = "Hello";

   string str1;

   cstr = cstr;

   string str2(cstr);

 

关于sprintf应用：将数打印到字符串中

char s[ ];

int a;

double b;

sprintf(s,"%d",a);

sprintf(s,”%.2lf”,b); //将b精确到小数点后两位，并打印到s中

 

字符串左循环移位

string a, c;

lena=a.length();

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

{

       c=a.substr(i);    //从位置i开始复制字符串到末尾，向左循环

       c.append(a,0,i);  //把字符串a，从位置0开始复制i个到字符串c

    cout<<c<<endl;

}

 

 

小数点后几位输出

C:

double ans;

print("%.2lf\n",ans);

 

%lf double   %f float  %d int  %ld long  %c char

 

C++:

#include <iomanip>

double ans

cout<<fixed<<showpoint<<setprecision(2)<<ans<<endl;

 

格式对齐，C++默认是右对齐

cout.width(20);

cout<<s<<endl;  //结果是右对齐

 

cout.width(20);

cout.setf(ios_base::left);

cout<<s<<endl;  //结果是左对齐

 

C输入输出

int a , b;

scanf(“%d%d”,&a,&b);

printf(“%d%d”,&a,&b);

 

math函数库

#include <math.h>

求平方根   double c=sqrt(a);

x的y次得用函数  pow(x,y)，x为double，y为int

开方 开x的y次方  pow(x,1/y)

 

关于map容器

#pragma warning(disable:4786)

#include <map>

 

map<string,int> m;

string a="hello";

如果m[a]没赋值，那么m[a]=0;

 

map<string,string> m;

如果m[a]没赋值，那么m[a]="";

 

判断素数

1.从2一直到sqrt(x)判断法

bool jude(int x)

{

    if(x==1 || x==0) return false;

    double m=sqrt((double)x);

    for(int i=2;i<=m;i++)

        if(x%i==0) return false;

    return true;

}

 

 

2.筛法判断素数

bool isprime[1000000+5]

memset(isprime,true,sizeof(isprime));

isprime[0]=isprime[1]=false;

for(i=2;i<1000000+5;i++)

{

    if(isprime[i]==true)

    {

        temp=2*i;

        while(temp<1000000+5)

        {

            isprime[temp]=false;

            temp+=i;

        }

    }

}

 

 

sort( )函数用法

#include <algorithm>

 

bool cmp(int a,int b)

{

     return a>b;

}

int a[10];

sort(a,a+10,cmp);

 

stable_sort(a,a+10,cmp);

//稳定排序方法 对于数组中出现的任意a[i],a[j](i<j),其中a[i]==a[j]，在进行排序以后a[i]一定出现在a[j]之前，则认为该排序是稳定的。

 

 

stack和queue

1.About stack

#include <stack>

stack<int> s;

s.push(a);

while(!s.empty)

{

    cout<<s.top();

    s.pop();

}

 

int size=s.size();

 

 

2.About queue

#include <queue>

queue<string> Q;

 

Q.push(s);

while(!Q.empty())

{

    cout<<Q.front();

    Q.pop();

}

 

cout << "The first element is " << Q.front()

     << " and the last element is " << Q.back() << endl;

 

int size=Q.size();

 

 

priority_queue

#include <queue>

empty() true if the priority queue has no elements

pop() removes the top element of a priority queue

push() adds an element to the end of the priority queue

size() returns the number of items in the priority queue

top() returns the top element of the priority queue

 

priority_queue< Node,vector<Node>,greater<Node> > Q;

 

//greater 从小到大排列

about the overrading of greater，you must write，重载时greater用operator>

bool operator>(Node a)

{

    return a.x > b.x;

}

 

//less从大到小排列

priority_queue<Node> Q;

priority_queue<Node,vector<Node>>Q;

这两种方式都可以

默认的是less函数比较 从大到小 ,重载less时要用 operator<

 

千万不要忘了初始化

尤其对于循环输入数据的题

对于stack queue

都要考虑到 empty()的问题

stack or queue 空了，就不能再用s.top() or q.top() 这样会出错。

每次新循环，都要将stack or queue 腾空

 

并查集找根

1.不改变集合元素值

int findr(int x)

{

    int r=x;

    while(u[r]!=r)

    r=u[r];

    return r;

}

 

 

2.改变并查集元素值，使每个元素都直接指向根,为以后查找提供方便

int findr(int r)

{

    if(u[r]==r) return r;

    u[r]=findr(u[r]);

    return u[r];

}

 

 

深度优先（DFS）搜索

//从x点开始搜索矩阵g[][]，并用visit[]标记

void DFS(int x)

{

    visit[x]=1;

    for(int j=1;j<=n;j++)

        if(visit[j]==0 && g[x][j]==1)

            DFS(j);

}

 

Dijkstra寻找单源最短路径

关于dijkstra如果有多个起点，或多个终点，可以再加两个点，一个连接所有起点，另一个链接所有终点，并设两点间值为零。

 

#define max INT_MAX

int g[200+2][200+2];

int dis[200+2],pre[200+2];

bool set[200+2]; 

//模板函数

int dijkstra(int x,int y,int citynum)

{

    int i,j;

    for(i=1;i<=citynum;i++)

    {

        dis[i]=g[x][i];

        set[i]=false;

if(dis[i]==INT_MAX) pre[i]=0;

        else pre[i]=s;

    }

    dis[x]=0;set[x]=true;

    for(i=1;i<citynum;i++)

    {

        int temp=max;

        int u=x;

        for(j=1;j<=citynum;j++)

            if(!set[j] && dis[j]<temp)

            {

                u=j;

                temp=dis[j];

            }

        set[u]=true;

        for(j=1;j<=citynum;j++)

            if(!set[j] && g[u][j]<max)

            {

                int newdis=dis[u]+g[u][j];

                if(newdis<dis[j])

{

dis[j]=newdis;

pre[j]=u;

}

            }

    }

    return dis[y];

}