指针，引用，函数的三种传递方式

void f(int a[],int b[][5]){  //如果要传递二维数组必须指定列数 
	for(int i=0;i<5;i++)
		cout<<*(a+i)<<endl;
}
int main(){
	//指针 
	//数组是用指针来实现的
	//指针：存放地址的变量                                     
	//地址：变量存放在内存中的位置                              
	int a=10;
	cout<<&a<<endl;//取a的地址 --输出一个0x开头的16进制数
	
	int *p;
	p=&a;//表示指针p指向a
	cout<<p<<endl;
	cout<<*p<<endl;//&表示取地址   *表示取内容  
	
	int *q;//只定义没有初始化---野指针
	int *qq=NULL;//指向空 地址为0---空指针 nullptr;//也表是空 
	cout<<qq<<endl;
	//+=1<1++<++1 
	
	int x[10];                                        //cher bo0l 1 字节 
	cout<<a<<endl;                                    //int float 4 字节        
	cout<<&a[0]<<endl;//0x73fe00                      //long long dounle 8 字节 
	cout<<&a[1]<<endl;//0x73fe04                      //1 字节(Byte)=8 二进制位(bit)
	f(a);
	void f(int a[])//函数传递时一维数组的形参
	void f(int b[][5])//二维数组的形参须指定列数 
	
	
	//引用 
	int syx=435;
	int &my=syx;
	//引用 相当于外号
	//必须在定义的时候赋值
	//这个别名不能转移给别人
	//别名等同于变量名使用 
	cout << my;//435 
	
	
	/*函数的三种传递方式
	值传递
	void f1(int a)
		a+=1;	

	指针传递 
	void f2(int *a)
		*a+=1;	

	引用传递 
	void f3(int &a)
		a+=1;	
	int main()
	{
		int a=1;
		f1(a);
		cout << a << endl;   1
		f2(&a);
		cout << a << endl;   2
		f3(a);
		cout << a << endl;   3 
	}*/
	return 0;
}

指针（Pointer）

指针是一个变量，其值为另一个变量的地址。你可以通过指针来间接访问或修改该地址处存储的值。指针在C++中广泛使用，尤其是在处理动态内存分配、数据结构（如链表、树等）以及某些底层编程任务时

指针的基本语法如下：

int x = 10;  
int* ptr = &x;  // ptr 是一个指向 int 类型的指针，存储了 x 的地址  
  
// 通过指针访问 x 的值  
cout << *ptr << endl;  // 输出 10  
  
// 通过指针修改 x 的值  
*ptr = 20;  
cout << x << endl;  // 输出 20
& 符号用于获取变量的地址。
* 符号用于解引用指针，即访问指针指向的变量的值。
指针可以指向任何有效的内存地址，也可以为 nullptr（或 NULL，但在C++11及以后推荐使用 nullptr）表示空指针

引用（Reference）
引用是已存在变量的别名。一旦引用被初始化，它就不能再指向其他变量。引用在语法上类似于变量，但在语义上更接近于常量指针（即指向某个地址且不能改变的指针）

引用的基本语法如下：

int x = 10;  
int& ref = x;  // ref 是 x 的引用  
  
// 通过引用访问 x 的值  
cout << ref << endl;  // 输出 10  
  
// 通过引用修改 x 的值  
ref = 20;  
cout << x << endl;  // 输出 20
注意，引用在声明时必须初始化，且一旦初始化后就不能再改变其指向的变量。引用在函数参数传递和返回值中特别有用，因为它们可以避免不必要的拷贝操作，提高效率

指针与引用的主要区别
​可变性​：指针可以改变其指向的地址（即可以重新赋值），而引用一旦初始化就不能再改变其指向的量
​空值​：指针可以为空（即可以指向 nullptr），而引用必须始终指向某个有效的变量
​初始化​：引用在声明时必须初始化，而指针则可以在声明后任意时刻初始化
​语义​：引用在语义上更接近于常量指针，因为它们都表示对某个特定内存地址的引用。然而，由于引用不能重新赋值，它们在某种程度上比指针更安全。
​大小​：在大多数情况下，指针的大小是固定的（例如，在32位系统上通常为4字节，在64位系统上通常为8字节），而引用的大小则取决于它所引用的变量的类型。然而，在实际编程中，我们通常不需要关心引用的大小，因为编译器会为我们处理这些细节

排序时间复杂度

排序算法   时间复杂度	    最优	   最劣	    稳定性 
冒泡排序 	O(n^2)      O(n)	  O(n^2)	稳定的 
插入排序		O(n^2)	    O(n)	  O(n^2)	稳定的 
选择排序		O(n^2)	   O(n^2)     O(n^2)	不稳定 

深搜模板

#include<bits/stdc++.h>
using namespace std;
int n,m;
char q[505][505];
int p[505][505];
int dx[4]={1,0,-1,0};//下右上左 
int dy[4]={0,1,0,-1} ;
int flag=0;
void dfs(int x,int y){
	p[x][y]=1;
	if(q[x][y]=='g'){
		flag=1;
		return;
	}
	for(int i=0;i<4;i++){
		int tx=dx[i]+x;
		int ty=dy[i]+y;
		if(q[tx][ty]=='#') continue;
		if(p[tx][ty]==1) continue;
		if(tx<1||tx>n||ty<1||ty>m) continue;
		dfs(tx,ty);
	} 
}
int main(){
	cin>>n>>m;
	int a,b;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cin>>q[i][j];
			if(q[i][j]=='s'){
				a=i,b=j;
			}
		}
	}
	dfs(a,b);
	if(flag) cout<<"Yes";
	else cout<<"No";
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
int n,m;
void x(string a;int len)
{
	if(len==n)
	{
		cout<<a<<endl;
		return ;
	}
	for(int i=0;i<m;i++)
	{
		x(a+char(i+'0'),len+1);
	}
}
int main()
{
	cin>>n>>m;
	x("",0);
	return 0;
}