c语言的算法（和java区分开）

库函数

#include<iostream>


#include<cstdio>
printf

#include<algorithm>
sort（）
sort 默认为升序
sort(a+1,a+50,less< int >() ); 降序

#include<cstring>
memset(vis,false,sizeof(vis)); 用法：只能初始化成为0或者-1两个数值
fill(a+i,a+j,1)//下标从i到j-1  赋值
int way[1015][1015];
fill(way[0], way[0] + 1015 * 1015, INF);

#include<cmath>
double ans=pow(x,n);
max(a,b)
min(a,b)
使用int round(double x),传入一个浮点数据，返回一个整数，正数和负数的四舍五入
（%.2lf）编译器默认四舍五入
int ceil()向下取整
int floor()向上取整

注意的点：

double ans=7.5;
printf("%.0lf,ans) 为8
cout<<(int)ans: 为7

排序：

sort 默认为升序
sort(a+1,a+50,less< int >() ); 降序
可以为自定义结构体

sort(p,p+n,cmp);
bool cmp(peo a,peo b)
{
	if(a.s.size()==b.s.size())
	{
		return a.ave>b.ave;//降序 
	}
	return a.s.size()>b.s.size();//降序 
}

自定义结构：

1.结构体初始化
常用：

struct node
{
	int a,b;
	node(int aa,int bb):a(aa),b(bb){
	}
};
node x=node(2,3);

结构体是常用的自定义构造类型，是一种很常见的数据打包方法。结构体对象的初始化有多种方式，分为顺序初始化、指定初始化、构造函数初始化。假如有如下结构体。

struct A {
	int b;
	int c;
};

（1）顺序初始化因为书写起来较为简约，是我们最常用的初始化方式，但相对于指定初始化，无法变更数据成员初始化顺序，灵活性较差，而且表现形式不直观，不能一眼看出 struct 各个数据成员的值。

A a = {1, 2};

（2）指定初始化（Designated Initializer）实现上有两种方式，一种是通过点号加赋值符号实现，即“.fieldname=value”，另外一种是通过冒号实现，即“fieldname:value”，其中 fieldname 为结构体成员名称 。前者是 C99 标准引入的初始化方式，后者是 GCC 的扩展。遗憾的是有些编译器并不支持指定初始化，比如 Visual C++。

// 点号+赋值符号
A a = {.b = 1, .c = 2};

//冒号
A a = {b:1, c:2};

Linux 内核喜欢用 .fieldname=value 的方式进行初始化，使用指定初始化，一个明显的优点是成员初始化顺序和个数可变，并且扩展性好，比如在结构体非末尾处增加字段时，避免了传统顺序初始化带来的大量修改。

（3）构造函数初始化常见于 C++ 代码中，因为 C++ 中的 struct 可以看作 class，结构体也可以拥有构造函数，所以我们可以通过结构体的构造函数来初始化结构体对象。给定带有构造函数的结构体：

struct A {
	A(int b,int c) {
		this->b=b;//一定要用this
		this->c=c;
	};
	int b;
	int c;


}

那么结构体对象的初始化可以像类对象初始化那样：

A a(1,2);

注意： struct 如果定义了构造函数的话，就不能用大括号进行初始化了，即不能再使用指定初始化与顺序初始化了。

2.结构体赋值
变量的赋值和初始化是不一样的，初始化是在变量定义的时候完成的，是属于变量定义的一部分，赋值是在变量定义完成之后想改变变量值的时候所采取的操作。还是给定结构体 A：

struct A {
	int b;
	int c;
};

注意： 结构体变量的赋值是不能采用大括号的方式进行赋值的，例如下面的赋值是不允许的。

A a;
a={1,2};	// 错误赋值

下面列出常见结构体变量赋值的方法。

（1）使用 memset 对结构体变量进行置空操作：

// 按照编译器默认的方式进行初始化（如果 a 是全局静态存储区的变量，默认初始化为0，如果是栈上的局部变量，默认初始化为随机值）

A a; 
memset(&a,0,sizeof(a));

（2）依次给每一个结构体成员变量进行赋值：

A a; 
a.b=1;
a.c=2;

（3）使用已有的结构体变量给另一个结构体变量赋值。也就是说结构体变量之间是可以相互赋值的。

A a={1,2};
struct A a1;
a1=a; 				// 将已有的结构体变量赋给a1

初始化与赋值有着本质的区别，初始化是变量定义时的第一次赋值，赋值则是定义之后的值的变更操作，概念上不同，所以实现上也不一样。

typedef struct node
{
	int v,w;
	node(int x,int y)
	{
		v=x;w=y;
	}
	bool operator <(const node &b)const
	{
		return w>b.w;
	}
}node;

强制转换：

(ll)resp 可以 (ll)(resp) 不行，这样还是会爆数据

加入输入输出

1，直接cin cout很慢：

2，加入ios::sync_with_stdio(false)可以小幅度提升速度

3, 加入cin.tie(0); 大幅提升速度

（最常用）2,3可以同时用

	cin.tie(0);
	ios::sync_with_stdio(false);
	cin>>n;

4，使用scanf和printf 速度和3差不多，但也比3快一点

5,精度缺失：

二分时，注意使用l还是，r

JAVA中的：

1：fill函数：

void fill(int[] a, form, to, int var) 

public class Test {
    
    public static void main(String[] args) {
        
        int[] a = new int[]{1,2,3,4,5,6};
        System.out.println(Arrays.toString(a));  //{1,2,3,4,5,6}
    
        Arrays.fill(a, 0);
        System.out.println(Arrays.toString(a));  //{0,0,0,0,0,0}    
        
        int[] b = new int[]{1,2,3,4,5,6};
        Arrays.fill(b, 2, 4, 0);
        System.out.println(Arrays.toString(b));  //{1,2,0,0,5,6}
        
        Boolean[] c = {true,false};
        System.out.println(Arrays.toString(c));  //{true,false}
        Arrays.fill(c, false);
        System.out.println(Arrays.toString(c));  //{false,false}
        Arrays.fill(c, 0, 1, true);
        System.out.println(Arrays.toString(c));  //{true,false}
        
        String[] d = {"a","b","c","d","e","f"};
        System.out.println(Arrays.toString(d));  //{a,b,c,d,e,f}
        Arrays.fill(d, 1, 2, "HelloWorld");
        System.out.println(Arrays.toString(d));  //{a,HelloWorld,c,d,e,f}
        
    }
}

2: swap()

java 没有封装的swap

public static String swap(String x,int f,int r)
	{
		char temp[]=x.toCharArray();
		char t=temp[f];temp[f]=temp[r];temp[r]=t;
		x=String.valueOf(temp);
		return x;
	}