算法程序

最新推荐文章于 2024-03-29 23:24:20 发布
Tiger_v
最新推荐文章于 2024-03-29 23:24:20 发布
阅读量683
点赞数
分类专栏： Old data
本文链接：https://blog.csdn.net/Tiger_v/article/details/107745780
版权
Old data 专栏收录该内容
1 篇文章 0 订阅
订阅专栏
  算法程序  



1、//	从小到大排序的函数模版
template <class T> void Sort(T arr[], int size)
{
	T temp;
	for (int i = 0; i != size - 1; ++i)
		for (int j = i + 1; j != size; ++j)
			if (arr[i] > arr[j])
			{
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
}



2、//	二分查找法的函数模版
//	arr中的元素应按从小到大排序，返回目标的索引值
template <class T> int BinarySearch(T *arr, T target_value, int arr_size)
{
	int mid_idx, left_idx = 0, right_idx = arr_size - 1;

	while (left_idx <= right_idx)
	{
		mid_idx = left_idx + ((right_idx - left_idx) >> 1);

		if (*(arr + mid_idx) == target_value)
			return mid_idx;		// 找到，则返回目标的索引值
		else if (*(arr + mid_idx) < target_value)
			left_idx = mid_idx + 1;
		else
			right_idx = mid_idx - 1;
	}

	return -1;					// 如果没有找到，返回 -1
}



3、// 归并排序  非递归方式-推荐
#include <iostream>

using namespace std;


//================================================================
void Merge(int sr[], int tr[], unsigned int idx_start, unsigned int idx_mid, unsigned int idx_end)
{
	unsigned int n = idx_start;
	unsigned int i = idx_start, j = idx_mid + 1;

	for (; i <= idx_mid && j <= idx_end; )
	{
		if (sr[i] <= sr[j])
			tr[n++] = sr[i++];
		else
			tr[n++] = sr[j++];
	}

	while (i <= idx_mid)
	{
		tr[n++] = sr[i++];
	}
	while (j <= idx_end)
	{
		tr[n++] = sr[j++];
	}
}

void MergePass(int sr[], int tr[], unsigned int step, unsigned int n_total)
{
	unsigned int i = 0;
	while (i + 2 * step - 1 <= n_total-1)
	{
		Merge(sr, tr, i, i + step - 1, i + 2 * step - 1);
		i += 2 * step;
	}
	if (i + step - 1 < n_total - 1)
		Merge(sr, tr, i, i + step - 1, n_total - 1);
	else
		for (unsigned int j = i; j != n_total; ++j)
			tr[j] = sr[j];
}

void MergeSort(int x[], const unsigned int n_total)
{
	int *tr = new int[n_total]();
	unsigned int step = 1;

	while (step < n_total)
	{
		MergePass(x, tr, step, n_total);
		step <<= 1;				// 左移一位
		MergePass(tr, x, step, n_total);
		step <<= 1;				// 左移一位
	}
}
//================================================================


int main(int argc, char *argv[])
{
	int x[] = { 50, 10, 90, 30, 70, 40, 80, 60, 20 };
	const unsigned int n_total = sizeof(x) / sizeof(int);	// 得到元素数量

	for (unsigned int i = 0; i != n_total; ++i)
		cout << x[i] << '\t';
	cout << endl << endl;

	MergeSort(x, n_total);
	for (unsigned int i = 0; i != n_total; ++i)
		cout << x[i] << '\t';
	cout << endl << endl;

	system("pause");
	return 0;
}



4、// 快速排序
#include <iostream>
#include <vector>

using namespace std;


//================================================================
int Partition(vector<int> &vec, int idx_low, int idx_high)
{
	int pivot_key = vec[idx_low];
	while (idx_low < idx_high)
	{
		// 注意下面两个 while 的顺序，才能防止 x[idx_low] 不是最小时能够被交换
		// 否则 x[idx_low] 将一直处于最左端
		while (idx_low < idx_high && pivot_key <= vec[idx_high])
			--idx_high;
		swap(vec[idx_low], vec[idx_high]);
		while (idx_low < idx_high && pivot_key >= vec[idx_low])
			++idx_low;
		swap(vec[idx_low], vec[idx_high]);
	}

	return idx_low;
}

void QSort(vector<int> &vec, int idx_low, int idx_high)
{
	if (idx_low < idx_high)
	{
		int pivot = Partition(vec, idx_low, idx_high);	// 左小右大
		QSort(vec, idx_low, pivot - 1);
		QSort(vec, pivot + 1, idx_high);
	}
}
//================================================================


int main(int argc, char *argv[])
{
	vector<int> vec = { 50, 10, 90, 30, 70, 40, 80, 60, 20 };

	QSort(vec, 0, vec.size() - 1);
	for (auto &ele : vec)
		cout << ele << "  ";

	cout << endl << endl;
	system("pause");
	return 0;
}



5、// 冒泡排序
#include <iostream>

using namespace std;


//================================================================
void BubbleSort(int x[], const unsigned int n_total)
{
	for (unsigned int i = 0; i != n_total - 1; ++i)
		for (unsigned int j = n_total - 1; j > i; --j)
		{
			if (x[j] < x[j - 1])
				swap(x[j], x[j - 1]);
		}
}
//================================================================


int main(int argc, char *argv[])
{
	int x[] = { 50, 10, 90, 30, 70, 40, 80, 60, 20 };
	const unsigned int n_total = sizeof(x) / sizeof(int);	// 得到元素数量

	for (unsigned int i = 0; i != n_total; ++i)
		cout << x[i] << '\t';
	cout << endl << endl;

	BubbleSort(x, n_total);
	for (unsigned int i = 0; i != n_total; ++i)
		cout << x[i] << '\t';
	cout << endl << endl;

	system("pause");
	return 0;
}



6、/**********  动态规划  01 背包  **********/
/*************************************************
Description:  有N个物品，每个物品的重量为 w[j]、价值为 v[j];
现在有一个背包，它所能容纳的重量为 bag_capacity。
求：该背包所能容纳的最大价值？

参考：https://www.jianshu.com/p/d9a0624c05e7
*************************************************/
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;


/*************************************************
Function: GetMaxValue_ZeroOneBag
Description: 得到01背包所能容纳的最大价值
Input:  vec_vec_01goods: 各单件物品的 体积/质量、价值
bag_capacity：背包容量
Return: 01背包能够容纳的最大价值
*************************************************/
template<class T> size_t GetMaxValue_ZeroOneBag(const vector<vector<T>> &vec_vec_01goods, const size_t &bag_capacity)
{
	size_t max_val = 0;
	if (!vec_vec_01goods.empty() && bag_capacity > 0)
	{
		vector<size_t> vec_dp(bag_capacity + 1, 0);

		vector<T> good_cur;		// 存放当前物品的属性  体积/质量、价值
		const size_t goods_kinds = vec_vec_01goods.size();
		for (size_t j = 0; j != goods_kinds; ++j)
		{
			good_cur = vec_vec_01goods[j];

			for (size_t i = bag_capacity; i >= good_cur[0]; --i)
				vec_dp[i] = max(vec_dp[i], good_cur[1] + vec_dp[i - good_cur[0]]);
		}

		max_val = vec_dp.back();
	}

	return max_val;
}


int main(int argc, char* argv[])
{
	// 体积/质量、价值
	vector<vector<int>> vec_vec_01goods = { { 2, 6 },{ 2, 3 },{ 6, 5 },{ 5, 4 },{ 4, 6 } };

	size_t max_val = GetMaxValue_ZeroOneBag(vec_vec_01goods, 10);
	cout << max_val << endl;

	system("pause");
	return 0;
}



7、/**********  动态规划  完全背包  **********/
/*************************************************
Description:  有N种物品（各自都有无限个），每种物品的重量为 w[j]、价值为 v[j];
现在有一个背包，它所能容纳的重量为 bag_capacity。
求：该背包所能容纳的最大价值？
*************************************************/
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <functional>

using namespace std;


/*************************************************
Function: GetMaxValue_CompletelyBag
Description: 得到完全背包所能容纳的最大价值
Input:  vec_vec_completelygoods: 各种物品的 体积/质量、价值
bag_capacity：背包容量
Return: 完全背包能够容纳的最大价值
*************************************************/
template<class T> size_t GetMaxValue_CompletelyBag(
	const vector<vector<T>> &vec_vec_completelygoods, const size_t &bag_capacity)
{
	size_t max_val = 0;
	if (!vec_vec_completelygoods.empty() && bag_capacity > 0)
	{
		vector<size_t> vec_dp(bag_capacity + 1, 0);

		vector<T> good_cur;		// 存放当前物品的属性  体积/质量、价值
		const size_t goods_kinds = vec_vec_completelygoods.size();
		for (size_t j = 0; j != goods_kinds; ++j)
		{
			good_cur = vec_vec_completelygoods[j];

			for (size_t i = good_cur[0]; i <= bag_capacity; ++i)	// 从左往右
				vec_dp[i] = max(vec_dp[i], good_cur[1] + vec_dp[i - good_cur[0]]);
		}

		max_val = vec_dp.back();
	}

	return max_val;
}


int main(int argc, char* argv[])
{
	// 体积 价值
	vector<vector<int>> vec_vec_completelygoods = { { 6, 7 },{ 5, 4 },{ 5, 5 }};

	size_t max_val = GetMaxValue_CompletelyBag(vec_vec_completelygoods, 10);
	cout << max_val << endl;

	system("pause");
	return 0;
}



8、/**********  动态规划  多重背包  **********/
/*************************************************
Description:  有N种物品，每个物品的重量为 w[j]、价值为 v[j]、数量为 c[j];
现在有一个背包，它所能容纳的重量为 bag_capacity。
求：该背包所能容纳的最大价值？
*************************************************/
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;


/*************************************************
Function: GetMaxValue_MultiBag
Description: 得到多重背包所能容纳的最大价值
Input:  vec_vec_multigoods: 各种物品的 体积/质量、价值、数量
bag_capacity：背包容量
Return: 多重背包能够容纳的最大价值
*************************************************/
template<class T> size_t GetMaxValue_MultiBag(
	const vector<vector<T>> &vec_vec_multigoods, const size_t &bag_capacity)
{
	size_t max_val = 0;
	if (!vec_vec_multigoods.empty() && bag_capacity > 0)
	{
		vector<size_t> vec_dp(bag_capacity + 1, 0);

		const size_t goods_kinds = vec_vec_multigoods.size();
		for (size_t j = 0; j != goods_kinds; ++j)
		{
			vector<T> good_cur = vec_vec_multigoods[j];	// 存放当前物品的属性  体积/质量、价值、数量

			T cnt_threshold;	// 该物品在容量为 i 的背包里可带走的最大数量
			for (size_t i = bag_capacity; i >= good_cur[0]; --i)
			{
				cnt_threshold = min(T(i/good_cur[0]), good_cur[2]);
				for (size_t k = 1; k <= cnt_threshold; ++k)
					vec_dp[i] = max(vec_dp[i], k*good_cur[1] + vec_dp[i - k*good_cur[0]]);
			}
		}

		max_val = vec_dp.back();
	}

	return max_val;
}


int main(int argc, char* argv[])
{
	// 体积/质量、价值、数量
	vector<vector<int>> vec_vec_multigoods = { { 1, 6, 10 },{ 2, 10, 5 }, {2, 20, 2} };

	size_t max_val = GetMaxValue_MultiBag(vec_vec_multigoods, 8);
	cout << max_val << endl;

	system("pause");
	return 0;
}



9、



10、
Tiger_v
关注
0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
算法程序

算法程序 1、// 从小到大排序的函数模版template <class T> void Sort(T arr[], int size){ T temp; for (int i = 0; i != size - 1; ++i) for (int j = i + 1; j != size; ++j) if (arr[i] > arr[j]) { temp = arr[i]; arr[i] = arr[j]; arr[j] = t...
复制链接

扫一扫