常用算法（学习笔记）

最新推荐文章于 2022-03-14 19:05:07 发布
最新推荐文章于 2022-03-14 19:05:07 发布
阅读量126 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58139679/article/details/119150118
版权

1.遍历算法（for_each,transform) 

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
//普通函数
void print01_for_each(int val)
{
	cout << val << " ";
}
//仿函数
class print02_for_each
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
//利用for_each遍历容器
void test_for_each()
{
	vector<int> v;
	for (int i=0; i < 10; i++)
	{
		v.push_back(i);
	}
	//利用普通函数
	for_each(v.begin(), v.end(), print01_for_each);
	cout << endl;
	//利用仿函数
	for_each(v.begin(), v.end(), print02_for_each());
	cout << endl;
}

//利用transform遍历容器

//仿函数
class Transform
{
public:
	int operator()(int v)
	{
		return v;
	}
};
void test_transform()
{
	vector<int> v0;
	for (int i = 0; i < 10; i++)
	{
		v0.push_back(i);
	}

	vector<int> v1;//目标容器
	v1.resize(v0.size());//目标容器需要提前开辟空间
	//将v0转移到v1
	transform(v0.begin(), v0.end(), v1.begin(), Transform());//按照需求来改变逻辑规则Transform()
	for_each(v1.begin(), v1.end(), print02_for_each()); cout << endl;
}
int main()
{
	//test_for_each();
	test_transform();
	return 0;
}

find   //查找元素

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Person
{
public:
	string m_name;
	int m_age;
	Person(string name,int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	bool operator==(const Person&p)
	{
		if (this->m_name == p.m_name && this->m_age == p.m_age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
};
void test_find()
{
	//内置数据类型
	vector<int> v;
	for (int i=0; i < 10; i++)
	{
		v.push_back(i);
	}
	vector<int>::iterator pos = find(v.begin(), v.end(), 5);
	if (pos != v.end())
	{
		cout << "找到" << *pos << endl;
	}
	else
	{
		cout << "未找到" << endl;
	}
	
	//自定义数据类型Person
	vector<Person>vp;
	Person p1("aaa", 11);
	Person p2("bbb", 22);
	Person p3("ccc", 33);
	Person p4("ddd", 44);

	vp.push_back(p1);
	vp.push_back(p2);
	vp.push_back(p3);
	vp.push_back(p4);

	vector<Person>::iterator Ppos=find(vp.begin(), vp.end(), p2);//因为没有可以进行比较的函数，所以重载==运算符
	if (Ppos == vp.end())
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << "找到:" << Ppos->m_name << " " << Ppos->m_age << endl;
	}
}



int main()
{
	test_find();

	return 0;
}

find_if  //按条件查找

#include <iostream>
#include <vector>
#include <algorithm>
#include<string>
using namespace std;
class Person
{
public:
	string m_name;
	int m_age;
	Person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
};
//内置数据类型谓词仿函数（大于5）
class FIve
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

//自定义数据类型谓词仿函数（大于30）
class FIND30
{
public:
	bool operator()(const Person& p)
	{
		return p.m_age > 30;
	}
};
void test_find_if()
{
	//内置数据类型
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	vector<int>::iterator pos = find_if(v.begin(), v.end(), FIve());

	for (; pos != v.end(); pos++)
	{
		if (pos != v.end())
		{
			cout << "找到" << *pos << endl;
		}
		else
		{
			cout << "未找到" << endl;
		}
	}

	//自定义数据类型Person
	vector<Person>vp;
	Person p1("aaa", 11);
	Person p2("bbb", 22);
	Person p3("ccc", 33);
	Person p4("ddd", 44);

	vp.push_back(p1);
	vp.push_back(p2);
	vp.push_back(p3);
	vp.push_back(p4);

	vector<Person>::iterator Ppos = find_if(vp.begin(), vp.end(), FIND30());
	if (Ppos == vp.end())
	{
		cout << "未找到" << endl;
	}
	else
		for (; Ppos != vp.end(); Ppos++)
		{

			cout << "找到:" << Ppos->m_name << " " << Ppos->m_age << endl;
		}
}
int main()
{
	test_find_if();

	return 0;
}


adjacent——find   //查找相邻重复元素

#include <iostream>
#include <vector>
#include <algorithm>
#include<string>
using namespace std;
void test_find_if()
{
	//内置数据类型
	vector<int> v;
	v.push_back(2);
	v.push_back(1);
	v.push_back(3);
	v.push_back(5);
	v.push_back(6);
	v.push_back(3);
	v.push_back(3);


	vector<int>::iterator pos = adjacent_find(v.begin(), v.end());
	if (pos != v.end())
	{
		cout << "找到相邻重复元素" << *pos << endl;
	}
	else
	{
		cout << "未找到相邻重复元素" << endl;
	}

}
int main()
{
	test_find_if();

	return 0;
}


binary_search    //二分法查找（返回值为ture或false）（在有序序列查找）

#include <iostream>
#include <vector>
#include <algorithm>
#include<string>
using namespace std;
void test_binary_search()
{
	//内置数据类型
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	bool pos = binary_search(v.begin(), v.end(),6);//必须有序 且返回值为true或false
	if (pos)
	{
		cout << "找到元素" <<endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}

}
int main()
{
	test_binary_search();

	return 0;
}


count   //统计元素个数

#include <iostream>
#include <vector>
#include <algorithm>
#include<string>
using namespace std;
class Person
{
public:
	string m_name;
	int m_age;
	Person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	bool operator==(const Person&p)
	{
		if (this->m_age == p.m_age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
};
void test_count()
{
	//内置数据类型
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(3);
	v.push_back(5);
	v.push_back(6);

	int num = count(v.begin(), v.end(), 3);
	cout <<"共"<< num<<"个" << endl;

	//自定义数据类型Person
	vector<Person>vp;
	Person p1("aaa", 11);
	Person p2("bbb", 22);
	Person p3("ccc", 33);
	Person p4("ddd", 44);
	Person p5("eee", 44);
	Person p6("fff", 44);

	vp.push_back(p1);
	vp.push_back(p2);
	vp.push_back(p3);
	vp.push_back(p4);
	vp.push_back(p5);
	vp.push_back(p6);
	Person p("***", 44);
	int num2 = count(vp.begin(), vp.end(),p);//需要重载==
	cout <<num2<< endl;
}
int main()
{
	test_count();

	return 0;
}


count_if   //按条件统计元素个数

#include <iostream>
#include <vector>
#include <algorithm>
#include<string>
using namespace std;
class Person
{
public:
	string m_name;
	int m_age;
	Person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
};
//谓词 return大于3
class Greater
{
public:
	bool operator()(int val)
	{
		return val > 3;
	}
};

//谓词年龄大于33
class Greaterage
{
public:
	bool operator()(const Person& p)
	{
		return p.m_age > 30;
	}
};
void test_count_if()
{
	//内置数据类型
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(3);
	v.push_back(5);
	v.push_back(6);

	int num = count_if(v.begin(), v.end(), Greater());
	cout <<"大于3的个数："<< num << endl;

	//自定义类型
	vector<Person>vp;
	Person p1("aaa", 11);
	Person p2("bbb", 22);
	Person p3("ccc", 33);
	Person p4("ddd", 44);
	Person p5("eee", 44);
	Person p6("fff", 55);

	vp.push_back(p1);
	vp.push_back(p2);
	vp.push_back(p3);
	vp.push_back(p4);
	vp.push_back(p5);
	vp.push_back(p6);
	int num2 = count_if(vp.begin(), vp.end(), Greaterage());//统计大于30岁人数
	cout << "年龄大于30的个数：" << num2 << endl;
}
int main()
{
	test_count_if();

	return 0;
}

3.排序算法

sort();   //对容器内元素进行排序

#include <iostream>
#include <vector>
#include <algorithm>
#include<string>
using namespace std;
//输出打印
class print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test_sort()
{
	
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(7);
	v.push_back(3);
	v.push_back(5);
	v.push_back(6);

	//默认排序
	sort(v.begin(), v.end());
	//遍历
	for_each(v.begin(), v.end(), print()); cout << endl;
	
	//降序排列，利用内建函数对象
	sort(v.begin(), v.end(),greater<int>());
	//遍历
	for_each(v.begin(), v.end(), print()); cout << endl;
}
int main()
{
	test_sort();

	return 0;
}


random_shuffle();   //洗牌 在指定范围内的元素随机调整次序

#include <iostream>
#include <vector>
#include <algorithm>
#include<string>
#include<ctime>
using namespace std;
//输出打印
class print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test_sort()
{
	//加入随机种子
	srand((unsigned int)time (NULL));
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//打乱顺序 洗牌算法
	random_shuffle(v.begin(), v.end());
	//遍历
	for_each(v.begin(), v.end(), print()); cout << endl;
}
int main()
{
	test_sort();

	return 0;
}


merge();   //容器元素合并，并存储到另一容器上

#include <iostream>
#include <vector>
#include <algorithm>
#include<string>
#include<ctime>
using namespace std;
//输出打印
class print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test_merge()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	vector<int>v2;
	for (int i = 15; i <20; i++)
	{
		v2.push_back(i);
	}
	vector<int>v3;
	v3.resize(v1.size() + v2.size());
	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());//v1 v2必须是有序序列 合并后v3也是有序序列
	//遍历
	for_each(v3.begin(), v3.end(), print()); cout << endl;
	
}
int main()
{
	test_merge();

	return 0;
}


reverse();   /反转指定范围的元素

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
//输出打印
class print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test_merge()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	reverse(v1.begin(), v1.end());
	//遍历
	for_each(v1.begin(), v1.end(), print()); cout << endl;
	
}
int main()
{
	test_merge();

	return 0;
}

4.常用拷贝和替换算法：

copy();   //容器内指定范围的元素拷贝到另一个容器中（使用赋值更好）

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
//输出打印
class print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test_merge()
{
	vector<int>v1;
	vector<int>v2;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	v2.resize(v1.size());
	copy(v1.begin(), v1.end(), v2.begin());
	//遍历
	for_each(v2.begin(), v2.end(), print()); cout << endl;
	
}
int main()
{
	test_merge();

	return 0;
}


replace();   将容器内指定范围内的旧元素修改为新元素

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
//输出打印
class print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
void test_merge()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	
	//替换部分元素
	replace(v1.begin(), v1.end(), 6, 66);
	//遍历
	for_each(v1.begin(), v1.end(), print()); cout << endl;
	
}
int main()
{
	test_merge();

	return 0;
}


replace_if();  //容器内指定范围满足条件的元素替换为新元素

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
//输出打印
class print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
//仿函数 大于5替换为999
class Greater999
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};
void test_merge()
{
	vector<int>v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	
	//替换部分元素
	replace_if(v1.begin(), v1.end(), Greater999(), 999);
	//遍历
	for_each(v1.begin(), v1.end(), print()); cout << endl;
	
}
int main()
{
	test_merge();

	return 0;
}


swap();   //互换两个容器的元素

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
//输出打印
class print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test_merge()
{
	vector<int>v1;
	vector<int>v2;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
		v2.push_back(i + 2);
	}
	//遍历
	for_each(v1.begin(), v1.end(), print()); cout << endl;
	for_each(v2.begin(), v2.end(), print()); cout << endl;

	//互换两个同种类型的容器
	swap(v1, v2);
	//遍历
	for_each(v1.begin(), v1.end(), print()); cout << endl;
	for_each(v2.begin(), v2.end(), print()); cout << endl;

}
int main()
{
	test_merge();

	return 0;
}

5.算法生成算法属于小型算法，使用时包含头文件#include<numeric>

accumulate   //计算容器元素累计总和

#include <iostream>
#include <vector>
#include <algorithm>
#include<numeric>
using namespace std;
void test01()
{
	vector<int>v1;
	for (int i = 0; i <= 100; i++)
	{
		v1.push_back(i);
	}
	int num=accumulate(v1.begin(), v1.end(),0); //参数三 是起始的累加值 例如：1000--6050
	cout << num << endl;
	
}
int main()
{
	test01();

	return 0;
}

fill   //向容器添加元素

#include <iostream>
#include <vector>
#include <algorithm>
#include<numeric>
using namespace std;
//输出打印
class print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int>v1;
	v1.resize(10);//给10个大小 元素为0
	fill(v1.begin(), v1.end(), 100);//将十个数改成100
	for_each(v1.begin(), v1.end(), print()); cout << endl;
}
int main()
{
	test01();

	return 0;
}

6.集合算法

set_interesectiom   //求两个容器的交集

#include <iostream>
#include <vector>
#include <algorithm>
#include<numeric>
using namespace std;
//输出打印
class print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int>v1;
	vector<int>v2;//这两个容器必须是有序序列
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
		v2.push_back(i + 7);
	}
	vector<int>v;
	//利用min()算法求一个最小值
	v.resize(min(v1.size(), v2.size()));
	vector<int>::iterator itend=set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), v.begin());//求两个容器中的交集，返回最后一个元素的位置
	for_each(v.begin(), itend, print());
}
int main()
{
	test01();

	return 0;
}

set_union   //求两个容器的并集

#include <iostream>
#include <vector>
#include <algorithm>
#include<numeric>
using namespace std;
//输出打印
class print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int>v1;
	vector<int>v2;//这两个容器必须是有序序列
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
		v2.push_back(i + 7);
	}
	vector<int>v;
	//利用min()算法求一个最小值
	v.resize(v1.size()+ v2.size());
	vector<int>::iterator itend=set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), v.begin());//求两个容器中的并集，返回最后一个元素的位置
	for_each(v.begin(), itend, print());
}
int main()
{
	test01();

	return 0;
}


set_difference    //求两个容器的差集

#include <iostream>
#include <vector>
#include <algorithm>
#include<numeric>
using namespace std;
//输出打印
class print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int>v1;
	vector<int>v2;//这两个容器必须是有序序列
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
		v2.push_back(i + 7);
	}
	vector<int>v;
	//利用min()算法求一个最大值,提前开辟空间
	v.resize(max(v1.size(),v2.size()));
	vector<int>::iterator itend=set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), v.begin());//求两个容器中的差集，返回最后一个元素的位置
	//(v1,v2)求出的是v1和v2的差集 ; (v2,v1)求v2和v1的差集
	for_each(v.begin(), itend, print());//结束使用 最后一个元素的迭代器
}
int main()
{
	test01();

	return 0;
}

白白白；
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++学习日记 STL函数对象、谓词、内建函数对象、常见算法集合
KLh
07-11 121
一、STL函数对象的概念。 1、概念。 重载函数调用操作符的类，其对象称为函数对象。 函数对象使用重载()时，行为类似函数调用，也叫仿函数。 2、本质。 函数对象(仿函数)是一个类的对象，不是一个函数。 例如： class Person{ public: void operator()() { } }; Person p; //p就是函数对象 p(); //对象使用()时，非常像函数调用 -> 仿函数 二、函数对象的使用。 1、函数对象在使用时，可...
C++学习笔记（10）---函数对象（仿函数）、STL遍历、查找、排序、拷贝与替换、算术生成、集合算法
plain_rookie的博客
08-18 429
1 函数对象 1.1 函数对象概念 （1）重载函数调用操作符的类，其对象常称为函数对象； （2）函数对象使用重载的()时，行为类似函数调用，也叫仿函数； 本质：函数对象(仿函数)是一个类，不是一个函数； 1.2 函数对象使用 特点：（1）函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值； （2）函数对象超出普通函数的概念，函数对象可以有自己的状态； （3）函数对象可以作为参数传递； //-------------练习1：函数对象（仿函数）----------------
第五章 STL常用算法
Memorise1999的博客
03-14 1259
概述： 5.1常用遍历算法 5.1.1for_each（遍历） 代码 #include<iostream> using namespace std; #include<vector> #include<algorithm> //普通函数 void print01(int val) { cout << val << " "; } //仿函数 class print02 { public: void operat.
函数调用操作符（operator（））
脚踏实地，用心编写出客户满意的代码，为公司创造出应有的价值。
06-18 1447
 许多STL算法都需要用户指定某个条件或某个策略，而条件或策略的背后由一整组操作构成，便需要某种特殊的东西来代表这“一整组操作”。 代表“一整组操作”的，当然是函数。过去C语言时代，欲将函数当做参数传递，唯有通过函数指针才能达成。但是函数指针有缺点，最重要的是它无法持有自己的状态（所谓局部状态），也无法达到组件技术中的可适配性（adaptablity）-----也就是无法再将某些修
void operator()()的含义
JunJie的个人博客
04-12 2257
operator()()的含义： 1、第一个括号代表我要重载运算符() 2、第二个括号代表重载时传入的参数，可以有参数，也可以不传入参数
算法学习笔记.pdf
06-22
常用算法整理，包括二分、快速排序、贪心算法、动态规划、二叉树，用数组来实现链表、用数组来实现堆、用栈来实现队列，常用的头文件的整理等。
P243~245C++常用遍历算法学习笔记.docx
04-13
C++常用遍历算法学习笔记 C++中的遍历算法是指对容器或数组中的元素进行遍历操作的算法，常用的遍历算法有for_each、transform、find等。这些算法都是STL（Standard Template Library）中的一部分，用于实现对容器...
P251~254C++常用排序算法学习笔记.docx
04-13
P251~254C++常用排序算法学习笔记.docx
P246~250C++常用查找算法学习笔记.docx
04-13
P246~250C++常用查找算法学习笔记.docx
P262~263C++常用集合算法学习笔记.docx
04-13
P262~263C++常用集合算法学习笔记.docx
C++函数对象operator()
热门推荐
summer
10-29 3万+
函数对象：定义了调用操作符（）的类对象。当用该对象调用此操作符时，其表现形式如同普通函数调用一般，因此取名叫函数对象。举个最简单的例子： class A { public: int operator() ( int val ) { return val > 0 ? val : -val; } }; 类A中定义了操作符 ( )，A
operator++()和operator++(int) 区别
shandianling
08-30 1879
++i; // 调用 i.operator++(); i++; // 调用 i.operator++(0);
void operator()() const 的编程实践
EsLinuxQt的博客
08-23 3204
void operator()() const ()是操作符的名字, ()的操作将被调用,当对象前面用()时. 如下例: class background_task { public: void operator()() const { do_something(); do_something_else(); } }; /*The ...
函数操作符operator()
qq_42138448的博客
07-14 444
函数操作符(): 可以将对象当作函数来使用 #include <iostream> using namespace std; class Square { public: double operator(doublex) {return x*x;} int operator(int a,int b,int c = 9) {return a + b - c;} }; int main(void) { Square square; cout <
void operator()()的功能
dnfx91224的博客
08-04 2754
在学习多线程的时候看到这样的一段代码 #include <iostream> #include <thread> class Counter { public: Counter(int value) : value_(value) { } void operator()() { while (value_ > 0) { s...
C++学习第三章
weixin_38705074的博客
09-29 177
1、函数对象 #include <string> //1、函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值 class MyAdd { public : int operator()(int v1,int v2) { return v1 + v2; } }; void test01() { MyAdd myAdd; cout << myAdd(10, 10) << endl; } //2、函数对象可以有自己的状态 class MyP
C++中的函数对象（Function Object）（一）
轻轻草原
10-09 654
一个函数对象，即一个重载了括号操作符“（）”的对象。当用该对象调用此操作符时，其表现形式如同普通函数调用一般，因此取名叫函数对象。举个最简单的例子：class FuncObjType { public: void operator() () { cout&lt;&lt;"Hello C++!"&lt;&lt;endl; } }; 类FuncObjType中重载了“（）”操作符，因此对...
ar-track二维码数字8，标准15cm宽度打印
06-15
ar_track二维码数字8，标准15cm宽度打印
关于C语言的基础代码.zip
最新发布
06-15
C语言是一种广泛使用的编程语言，它具有高效、灵活、可移植性强等特点，被广泛应用于操作系统、嵌入式系统、数据库、编译器等领域的开发。C语言的基本语法包括变量、数据类型、运算符、控制结构（如if语句、循环语句等）、函数、指针等。下面详细介绍C语言的基本概念和语法。 1. 变量和数据类型 在C语言中，变量用于存储数据，数据类型用于定义变量的类型和范围。C语言支持多种数据类型，包括基本数据类型（如int、float、char等）和复合数据类型（如结构体、联合等）。 2. 运算符 C语言中常用的运算符包括算术运算符（如+、、、/等）、关系运算符（如==、!=、、=、<、<=等）、逻辑运算符（如&&、||、！等）。此外，还有位运算符（如&、|、^等）和指针运算符（如、等）。 3. 控制结构 C语言中常用的控制结构包括if语句、循环语句（如for、while等）和switch语句。通过这些控制结构，可以实现程序的分支、循环和多路选择等功能。 4. 函数 函数是C语言中用于封装代码的单元，可以实现代码的复用和模块化。C语言中定义函数使用关键字“void”或返回值类型（如int、float等），并通过“{”和“}”括起来的代码块来实现函数的功能。 5. 指针 指针是C语言中用于存储变量地址的变量。通过指针，可以实现对内存的间接访问和修改。C语言中定义指针使用星号（）符号，指向数组、字符串和结构体等数据结构时，还需要注意数组名和字符串常量的特殊性质。 6. 数组和字符串 数组是C语言中用于存储同类型数据的结构，可以通过索引访问和修改数组中的元素。字符串是C语言中用于存储文本数据的特殊类型，通常以字符串常量的形式出现，用双引号（"..."）括起来，末尾自动添加'\0'字符。 7. 结构体和联合 结构体和联合是C语言中用于存储不同类型数据的复合数据类型。结构体由多个成员组成，每个成员可以是不同的数据类型；联合由多个变量组成，它们共用同一块内存空间。通过结构体和联合，可以实现数据的封装和抽象。 8. 文件操作 C语言中通过文件操作函数（如fopen、fclose、fread、fwrite等）实现对文件的读写操作。文件操作函数通常返回文件指针，用于表示打开的文件。通过文件指针，可以进行文件的定位、读写等操作。 总之，C语言是一种功能强大、灵活高效的编程语言，广泛应用于各种领域。掌握C语言的基本语法和数据结构，可以为编程学习和实践打下坚实的基础。
算法设计与分析学习笔记
05-15
算法设计与分析是计算机科学中非常重要的一门课程，它主要涵盖了算法的设计、分析和实现等方面的内容。在学习该课程时，需要掌握基本的算法思想和技巧，如贪心、分治、动态规划、回溯等，同时还需要熟练掌握常用的数据结构，如树、图、堆、队列等。 在算法设计与分析学习笔记中，通常会包括以下内容： 1. 基本算法思想的介绍和举例； 2. 常用数据结构的介绍和操作方法； 3. 算法的正确性证明和时间复杂度分析； 4. 算法实现的注意事项和技巧； 5. 算法应用实例和相关练习题目。 如果你想更深入地了解算法设计与分析，可以参考一些经典的算法教材，如《算法导论》、《数据结构与算法分析》等。同时，在学习过程中，要多动手实践，写代码进行模拟和实现，这样才能真正掌握算法的精髓。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值