c++ 杂项

最新推荐文章于 2023-02-11 12:17:53 发布

Kylehz

最新推荐文章于 2023-02-11 12:17:53 发布

阅读量627

点赞数

本文链接：https://blog.csdn.net/zhoujiachengdhy/article/details/24696331

版权

const double pi=3.1415926535897932384626;

const double e=2.7182818284590452353602;

#include <math.h>
#include <stdio.h>
int main()
{
    printf("pi=%.12lf,e=%.12lf\n",M_PI,M_E);
    return 0;
}

ACM常用的头文件

#include <iostream>//数据输入输出流  
#include <cstring>//字符串操作函数  
#include <csstdio>//C的输入输出  
#include <cstdlib>//定义杂项函数及内存分配函数  
#include <cmath>//C中的数学函数  
#include <string>//c++中的string类 他不能用strcpy等c函数去操作  
#include <vector>//STL vetor  
#include <list>//STL list  
#include <map>// STL map  
#include <queue>// STL queue  
#include <stack>//sTL stack  
#include <bitset>//bitset可按位定义串  
//比如：bitset <1000> all;定义一个1000位的串  
#include <algorithm>//STL各种算法 比如 swap sort merge max min 比较  
#include <numeric>//常用数字操作 一般和algorithm搭配使用  
#include <functional>//STL定义运算函数（代替运算符）

各种取模

证明：(A/B)%C = (A%(BC))/B，其中B|A。

分析：设，那么，由于，那么

所以，即。

gets（s）以回车结束当gets读到字符串的时候返回s 否则返回NULL

int 范围是-2^31~2^31-1 比-2*10^9~2*10^9 略宽

#define INF (1<<31)-1 或 0x7fffffff

double 范围是 -2^63~2^63-1 比-10^19~10^19 略窄

unsigned int 0～4294967295
int 2147483648～2147483647
unsigned long 0～4294967295
long 2147483648～2147483647
long long的最大值：9223372036854775807
long long的最小值：-9223372036854775808
unsigned long long的最大值：18446744073709551615

__int64的最大值：9223372036854775807
__int64的最小值：-9223372036854775808
unsigned __int64的最大值：18446744073709551615

memset只能赋值0或-1

只有0和-1可以。或者说，只有memset 0和-1会分别初始化为0和-1。。
memset是一个一个char来set的。0相当于0x00，-1相当于0xff，1相当于0x01。
因此，
memset 0，每个元素都是0x00000000。
memset -1，每个元素都是0xffffffff。
memset 1，每个元素都是0x01010101，即16843009。

对unsigned int的数组，
memset 0，初始化为最小值0。
memset -1，初始化为最大值0xffffffff，即4294967295。

对int的数组，
memset 0，初始化为0。
memset -1，初始化为0xffffffff，即-1。
memset 0x7f，初始化为0x7f7f7f7f，即2139062143（int的最大值是0x7fffffff，即2147483647）。
memset 0x80，初始化为0x80808080，即-2139062144（int的最小值是0x80000000，即-2147483648）。

结构体初始化

struct{
//...
int a;
int *p;
}x;
memset(&x, 0, sizeof(x))
或者
memset(&x, 0, sizeof(struct A_stru))
这是结构体变量初始化为0的常见方法，需要注意x前的&号。

struct A a = {0};

z=（x>y)?x:y;
上面的语句的意思是，首先判断x与y的大小，当x大于y时，即上面的语句x>y为真的时候，则将x的值赋给z，否则将y值赋给z！

计时器及文件操作：

#include<stdio.h>
#include<time.h>
#include<iostream>
using namespace std;
int main()
{
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);

    int n;
    while(cin>>n)cout<<n<<endl;

    printf("Time used = %.3lf\n",(double)clock()/CLOCKS_PER_SEC);
    return 0;
}

#include<fstream>
#include<iostream>
using namespace std;
ifstream fin("data.in");
ofstream fout("data.out");
int main()
{
    int a,b;
    while(fin>>a>>b) fout<< a+b <<endl;
    
    return 0;
}

windows 下输入完毕后按Enter键，再按Ctrl+Z键，再按Enter键，即可结束输入。在Lunix下输入完毕后按Ctrl+D键即可结束输入

字符串比较函数strcmp是怎样比较出两个字符串的大小的？

跟字符串的长度无关的.

就是从两个字符串的头开始比.相应位的字符进行对比.实际上是比较相应位字符的ASCII码大小.

如char *s1="abc";

char *s2="bd";

执行strcmp(s1,s2),其结果是负的.

从两个字符串的头开始比,因为字符串s1中的'a'小于s2中的'b'所以s1<s2;

再如:

char *s1="abc";

char *s2="ad";

其结果也是负的,因为s1中的'b'<s2中的'd'

再如:

char *s1="abc";

char *s2="ab";

其结果就是正的.因为s1中的'c'大于s2中的'\0';因为字符串的最后一个字符是\0;

再如:

char *s1="abc";

char *s2="abcd";

其结果是负的.因为s1中的'\0'小于s2中的'd';

素数打表

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define N 1000010//最多开到1000000*int字节
int f[N];
int main()
{
    memset(f,0,sizeof(f));
    int i,j;
    f[0]=f[1]=1;
    for(i=2;i<N;i++)
    {
        if(i*i>N)break;//用i*i是必须加上这句话，否则会出差哦，用i+i时不用
        for(j=i*i;j<N;j+=i)f[j]=1;
    }
    for(i=0;i<100;i++)if(!f[i])printf("%d\n",i);
    return 0;
}

string s；

s.size();返回值的类型是unsigned int 不能和int类型数据比较

参考：http://wenku.baidu.com/link?url=OUuGjmIRLZdmshR23aY0ljvpJlePn4QCBdnrsFP3b1twpzVMBUmaCRwZSAyYRmHLMsrvZfAZVkLOoXTtauVKhNeUV5LqdMc98Cm5-meqrZW

树状数组中

n=n-lowbit(n) 无论n为几结果都是0

正确的表述是n-=lownit(n)

- 的优先级大于 &

&的优先级大于 -=

位运算

   在很多系统程序中常要求在位(bit)一级进行运算或处理。C语言提供了位运算的功能， 这使得C语言也能像汇编语言一样用来编写系统程序。

一、位运算符C语言提供了六种位运算符：

& 按位与
| 按位或
^ 按位异或
~ 取反
<< 左移
>> 右移

1. 按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。

例如：9&5可写算式如下： 00001001 (9的二进制补码)&00000101 (5的二进制补码) 00000001 (1的二进制补码)可见9&5=1。

  按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a&255 运算 ( 255 的二进制数为0000000011111111)。
main(){
int a=9,b=5,c;
c=a&b;
printf("a=%d\nb=%d\nc=%d\n",a,b,c);
}

2. 按位或运算 按位或运算符“|”是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。
例如：9|5可写算式如下： 00001001|00000101
00001101 (十进制为13)可见9|5=13
main(){
int a=9,b=5,c;
c=a|b;
printf("a=%d\nb=%d\nc=%d\n",a,b,c);
}

3. 按位异或运算 按位异或运算符“^”是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。参与运算数仍以补码出现，例如9^5可写成算式如下： 00001001^00000101 00001100 (十进制为12)
main(){
int a=9;
a=a^15;
printf("a=%d\n",a);
}

4. 求反运算 求反运算符～为单目运算符，具有右结合性。 其功能是对参与运算的数的各二进位按位求反。例如～9的运算为： ~(0000000000001001)结果为：1111111111110110

5. 左移运算 左移运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，
高位丢弃，低位补0。例如： a<<4 指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。6. 右移运算右移运算符“>>”是双目运算符。其功能是把“>> ”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。
例如：设 a=15，a>>2 表示把000001111右移为00000011(十进制3)。应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时， 最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。Turbo C和很多系统规定为补1。
main(){
unsigned a,b;
printf("input a number: ");
scanf("%d",&a);
b=a>>5;
b=b&15;
printf("a=%d\tb=%d\n",a,b);
}
请再看一例!
main(){
char a='a',b='b';
int p,c,d;
p=a;
p=(p<<8)|b;
d=p&0xff;
c=(p&0xff00)>>8;
printf("a=%d\nb=%d\nc=%d\nd=%d\n",a,b,c,d);
}

排序

快速排序：

http://blog.csdn.net/v_july_v/article/details/6116297

QUICKSORT(A, p, r)
1 if p < r
2    then q ← PARTITION(A, p, r)   //关键
3         QUICKSORT(A, p, q - 1)
4         QUICKSORT(A, q + 1, r)

数组划分
快速排序算法的关键是PARTITION过程，它对A[p..r]进行就地重排：
PARTITION(A, p, r)
1 x ← A[r]
2 i ← p - 1
3 for j ← p to r - 1
4       do if A[j] ≤ x
5             then i ← i + 1
6                  exchange A[i] <-> A[j]
7 exchange A[i + 1] <-> A[r]
8 return i + 1

ok，咱们来举一个具体而完整的例子。
来对以下数组，进行快速排序，
2 8 7 1 3 5 6 4(主元)

#include<iostream>
#include<cstdio>
using namespace std;
int PARTITION(int *A,int p,int r)
{
    int x=A[r];
    int i=p-1;
    int tmp;
    for(int j=p;j<=r-1;j++)
    {
        if(A[j]<=x){
            i=i+1;
            tmp=A[i];
            A[i]=A[j];
            A[j]=tmp;
        }
    }
    tmp=A[i+1];
    A[i+1]=A[r];
    A[r]=tmp;
    return i+1;
}
void QUICKSORT(int *A,int p,int r)
{
    if(p<r){
        int q=PARTITION(A,p,r);
       // printf("---------------------------\n");
       // for(int i=0;i<8;i++)printf("%d %d\n",i,A[i]);
        QUICKSORT(A,p,q-1);
        QUICKSORT(A,q+1,r);

    }
}
int main()
{
    int a[10]={2,4,7,1,3,5,6,8};
    QUICKSORT(a,0,7);
    for(int i=0;i<8;i++)printf("%d %d\n",i,a[i]);
}