学习笔记——《算法导论》第2章习题

最新推荐文章于 2022-12-17 19:40:52 发布
最新推荐文章于 2022-12-17 19:40:52 发布
阅读量492 收藏
点赞数
分类专栏： MSP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a794767404/article/details/79396813
版权
前言：这个月开始拜读《算法导论》，难度挺大的，在这里记录一下课后习题的思路和代码实现。

2-1：在归并排序中对小数组用插入排序
分析：在多小的小数组时采用插入排序呢？
归并排序的最坏时间复杂度和平均时间复杂度都是 nlogn
插入排序的最坏时间复杂度为 n(n-1)/2, 平均时间复杂度为 n(n-1)/4
所以另　nlogn = n(n-1)/2  -- <1>
nlogn = n(n-1)/4  -- <2>

n大约在6~18之间，插入排序和归并排序可以说效率几乎相等，
n大于这个范围应该用归并排序，小于这个范围应该用插入排序

此次取n = 10 
#include <iostream>

using namespace std;



void merge(int arr[], int low, int mid, int high) // arr[low, mid] and arr[mid + 1, high] are sorted

{

	int* tmp = new int[high - low + 1];

	int left = low, right = mid + 1, index = 0;

	while (left <= mid && right <= high)

	{

		if (arr[left] <= arr[right])

		{

			tmp[index] = arr[left];

			++left;

		}

		else

		{

			tmp[index] = arr[right];

			++right;

		}

		++index;

	}

	while (left <= mid)

	{

		tmp[index] = arr[left];

		++left;

		++index;

	}

	while (right <= high)

	{

		tmp[index] = arr[right];

		++index;

		++right;

	}

	for (int i = 0; i < index; ++i, ++low)  // dont forget ++low

		arr[low] = tmp[i];                  // 注意是tmp[i]  不是tmp[index]



	delete [] tmp;

}



void insertion_sort(int arr[], int low, int high)  // [low, high]

{

	if (high - low < 1) return;

	for (int i = low + 1; i <= high; ++i)

	{

		int key = arr[i];

		int j = i - 1;

		while (j >= low && key < arr[j])

		{

			arr[j + 1] = arr[j];

			--j;

		}

		arr[j + 1] = key;

	}

}



void merge_and_insert_sort(int arr[], int low, int high)  // [low, high]

{

	if (high - low >= 10)                                 //　当元素个数大于10的时候，用归并排序

	{

		int mid = (low + high) / 2;

		merge_and_insert_sort(arr, low, mid);

		merge_and_insert_sort(arr, mid + 1, high);

		merge(arr, low, mid, high);

	}

	else                                                  //  当元素个数小于等于10的时候，用插入排序

	{

		insertion_sort(arr, low, high);

	}

}



int main()

{

	int arr[20] = {1,9,20,5,7,13,19,15,14,3,17,16,2,11,8,4,18,12,10,6};

	cout << "prim: ";

	for (int i = 0; i < 20; ++i) cout << arr[i] << " ";  cout << endl;



	merge_and_insert_sort(arr, 0, 19);

	cout << "mais: ";

	for (int i = 0; i < 20; ++i) cout << arr[i] << " "; cout << endl;

	return 0;

}
2.1-2 重写INSERTION_SORT,使之按非升序排列 
#include <vector>

#include <iostream>

using namespace std;



void Insertion_sort_lower(vector<int>& iv)

{

	for (int i = 1; i < iv.size(); ++i)

	{

		int key = iv[i];

		int j = i - 1;

		while (j >= 0 && iv[j] < key)

		{

			iv[j + 1] = iv[j];

			--j;

		}

		iv[j + 1] = key;

	}

}



int main()

{

	vector<int> v = {5, 3, 9, 7, 10, 1, 4, 7, 0, 2, 8};

	cout << "原　序　列：";

	for (auto i : v)  cout << i << " ";

	cout << endl;

	Insertion_sort_lower(v);

	cout << "排序后序列：";

	for (auto i : v)  cout << i << " ";

	cout << endl;

	return 0;

}

2.1-3 题目：
输入：一个序列，一个值v
输出：使得v = a[i]的下标i，若v不在a中出现，则v为特殊值NIL 
#include <vector>

#include <iostream>

#include <string>

using namespace std;





int main()

{

	vector<string> sv;

	string s;

	while (cin >> s && s != "END")

		sv.push_back(s);

	string v;

	cin >> v;

	

	int flag = 0;  // 如果v在sv里面,那么flag变为１

	for (int i = 0; i < sv.size(); ++i)

	{

		if (sv[i] == v)

		{

			flag = 1;

			cout << i << " ";

		}

	}

	if (flag == 0)

	{

		v = "NIL";

		cout << "v is not in sv, v = " << v << endl;

	}

	return 0;

}


2.1-4 题目：
输入:两个n位以二进制数组形式储存的整数
输出:一个n+1位的以二进制数组形式储存的整数 

#include <vector>

#include <iostream>

using namespace std;



vector<int> foo(const vector<int>& v1, const vector<int>& v2)

{

	vector<int> ret(v1.size() + 1, 0);

	for (int i = v1.size() - 1; i >= 0 ; --i)

	{

		if (v1[i] + v2[i] == 1)

		{

			if (ret[i + 1] == 0)

				ret[i + 1] = 1;

			else   // 要么等于０，要么等于１

			{

				ret[i + 1] = 0;

				ret[i] = 1;   //进位

			}

		}

		else if (v1[i] + v2[i] == 2)

		{

			ret[i] = 1;

		}

	}

	return ret;

}



int main()

{

	vector<int> iv1 = {1, 1, 1, 0}; // 14

	vector<int> iv2 = {1, 0, 0 ,1}; // 9

	vector<int> v = foo(iv1, iv2);

 	cout << "输出应为: 1 0 1 1 1 " << endl << "输　　出: ";

	for (auto i : v)  cout << i << " "; 

	cout << endl;

	return 0;

}

2-2 冒泡排序
冒泡排序基本思想：从左到右遍历数组，将待排序的序列从右到左遍历，如果相邻元素顺序相反，则交换这两个元素，直到没有要交换的元素为止
时间复杂度：O(n^2)
空间复杂度：O(1)
冒泡排序特点：
1. 最好情况为已排序情况，时间复杂度为O(n^2), 优化后为O(n)
2. 最坏情况为反序，复杂度为O(n^2)
3. 优点为思想简单，容易实现
4. 缺点为低效率 

#include <iostream>

using namespace std;



void swap(int& a, int& b)

{

	int tmp = a;

	a = b;

	b = tmp;

}





void bubble_sort(int arr[], int sz)

{

	if (sz <= 1) return;

	for (int i = 0; i < sz - 1; ++i)

	{

		for (int j = sz - 1; j > i; --j)

		{

			if (arr[j] < arr[j - 1])

				swap(arr[j], arr[j - 1]);

		}

	}

}



void bubble_sort_optimize(int arr[], int sz)

{

	if (sz <= 1) return;

	for (int i = 0; i < sz - 1; ++i)

	{

		bool flag = false;

		for (int j = sz - 1; j > i; --j)

		{

			if (arr[j] < arr[j - 1])

			{

				swap(arr[j], arr[j - 1]);

				flag = true;

			}

		}

		if (flag == false) return;

	}

}



int main()

{

	int arr[10] = {5, 8, 9, 1, 0, 3, 7, 2, 4, 6};

	cout << "prim: ";

	for (int i = 0; i < 10; ++i) cout << arr[i] << " "; cout << endl;



	bubble_sort(arr, 10);

	cout << "bbst: ";

	for (int i = 0; i < 10; ++i) cout << arr[i] << " "; cout << endl;



	int arr1[10] = {5, 8, 9, 1, 0, 3, 7, 2, 4, 6};

	cout << "prim: ";

	for (int i = 0; i < 10; ++i) cout << arr1[i] << " "; cout << endl;



	bubble_sort_optimize(arr1, 10);

	cout << "prim: ";

	for (int i = 0; i < 10; ++i) cout << arr1[i] << " "; cout << endl;



	return 0;

}

2.2-2 选择排序


选择排序：n个元素，经过n-1次循环，每次选出待排序序列中最小（大）元素与已排序序列的后一位元素交换
   从左到右遍历序列，将最小（大）元素选出来与第一个位置元素交换，次小（大）元素选出来与第二个位置的元素交换，以此类推。。
选择排序时间复杂度：O(n^2)   　
选择排序空间复杂度：O(1)

选择排序的特点：
   1. 优点是思想简单，容易实现
   2. 缺点是对于大数据集效率不高
   3. 每次循环最多交换一次数据，n个数据完成排序最多交换n-1次数据，相对不错
   4. 不是稳定排序 

#include <vector>

#include <iostream>

using namespace std;



void swap(int& i, int& j)

{

	int tmp = i;

	i = j;

	j = tmp;

}



void selection_sort(vector<int>& iv)

{

	if (iv.size() == 0 || iv.size() == 1) return;

	for (int i = 0; i < iv.size(); ++i)

	{

		int min = iv[i], min_index = i;

		for (int j = i + 1; j < iv.size(); ++j)

		{

			if (iv[j] < min)

			{

				min = iv[j];

				min_index = j;

			}

		}

		if (min_index != i)

			swap(iv[min_index], iv[i]);

	}

}



int main()

{

	vector<int> v = {5, 2, 9, 10, 6, 1, 8, 3, 7, 0, 4};

	cout << "原　序　列：";

	for (auto i : v) cout << i << " ";

	cout << endl;

	selection_sort(v);

	cout << "排序后序列：";

	for (auto i : v) cout << i << " ";

	cout << endl;

	return 0;

}
2.3-1 题目：说明归并排序在数组A = {3, 41, 52, 26, 38, 57, 9, 49}上的操作 
#include <iostream>

using namespace std;



void merge(int arr[], int low, int mid, int high) // arr[low, mid] and arr[mid + 1, high] are sorted

{

	int* tmp = new int[high - low + 1];

	int left = low, right = mid + 1, index = 0;

	while (left <= mid && right <= high)

	{

		if (arr[left] <= arr[right])  // <= 保证了稳定排序

		{

			tmp[index] = arr[left];

			++left;

		}

		else

		{

			tmp[index] = arr[right];

			++right;

		}

		++index;

	}

	while (left <= mid)

	{

		tmp[index] = arr[left];

		++left;

		++index;

	}

	while (right <= high)

	{

		tmp[index] = arr[right];

		++right;

		++index;

	}

	for (int i = 0; i < index; ++i, ++low)  // 注意边界条件 i < index 和 ++low

		arr[low] = tmp[i];



	delete [] tmp;  // 千万不能忘记

}



void merge_sort(int A[], int low, int high)  // A[low, high]

{

	if (low < high)

	{

		int mid = (low + high) / 2;

		merge_sort(A, low, mid);

		merge_sort(A, mid + 1, high);

		merge(A, low, mid, high);

	}

}



int main()

{

	int A[8] = {3, 41, 52, 26, 38, 57, 9, 49};

	cout << "原　序　列：";

	for (int i = 0; i < 8; ++i)  cout << A[i] << " ";

	cout << endl;

	merge_sort(A, 0, 7);

	cout << "排序后序列：";

	for (int i = 0; i < 8; ++i)  cout << A[i] << " ";

	cout << endl;

	return 0;

}


2.3-2 题目：
重写merge，不使用哨兵，而是一旦数组Ｌ或Ｒ的所有元素均被复制回Ａ就立刻停止，再将另一数组的剩余部分复制回Ａ 
void merge(int arr[], int low, int mid, int high) // arr[low, mid] and arr[mid + 1, high] are sorted

{

	int* tmp = new int[high - low + 1];

	int left = low, right = mid + 1, index = 0;

	while (left <= mid && right <= high)

	{

		if (arr[left] <= arr[right]) // <= 保证了稳定排序

		{

			tmp[index] = arr[left];

			++left;

		}

		else

		{

			tmp[index] = arr[right];

			++right;

		}

		++index;

	}

	while (left <= mid)

	{

		tmp[index] = arr[left];

		++left;

		++index;

	}

	while (right <= high)

	{

		tmp[index] = arr[right];

		++right;

		++index;

	}

	for (int i = 0; i < index; ++i, ++low)

		arr[low] = tmp[i];

}

2.3-5 二分查找 
#include <iostream>

using namespace std;



int binary_search(int arr[], int sz, int key)

{

	int left = 0, right = sz - 1;

	while (left <= right)

	{

		int mid = (left + right) / 2;

		if (arr[mid] == key)

			return mid;

		else if (arr[mid] < key)

			left = mid + 1;

		else 

			right = mid - 1;

	}

	return -1;  // 执行到这里就说明没有与key值相等的元素

}



int main()

{

	int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

	cout << "元素1的位置应为1, 输出：" << binary_search(arr, 10, 1) << endl;

	cout << "元素5的位置应为5, 输出：" << binary_search(arr, 10, 5) << endl;

	cout << "元素11不在arr中，输出应为-1, 输出：" << binary_search(arr, 10, 11) << endl;

	return 0;

}

2.3-6 题目：
将插入排序中反向查找已排序序列部分用二分查找改写，将复杂度降为O(nlogn) 
#include <iostream>

using namespace std;



/* 插入排序原版 */

void insertion_sort(int arr[], int sz)

{

	if (sz <= 1) return;

	for (int i = 1; i < sz; ++i)

	{

		int key = arr[i];

		int j = i - 1;

		while (j >= 0 && key < arr[j])

		{

			arr[j + 1] = arr[j];

			--j;

		}

		arr[j + 1] = key;

	}

}



/* 二分优化版本 */

void insertion_sort_optimize(int arr[], int sz)

{

	if (sz <= 1) return;

	for (int i = 1; i < sz; ++i)

	{

		int key = arr[i];

		int left = 0, right = i - 1;  // search range [left, right]

		while (left <= right)

		{									

			int mid = (left + right) / 2;    

			if (arr[mid] <= key)

				left = mid + 1;     // <= 保证了排序的稳定性，循环结束后，left即为key要插入的位置

			else

				right = mid - 1;

		}

		for (int j = i - 1; j >= left; --j)  // 将[left, i - 1]的元素copy到[left + 1, i]

			arr[j + 1] = arr[j];

		

		arr[left] = key;

	}

}



int main()

{

	int arr[10] = {5, 1, 0, 9, 4, 2, 6, 6, 3, 8};



	cout << "prim: " ;

	for (int i = 0; i < 10; ++i) cout << arr[i] << " ";

	cout << endl;

	

	insertion_sort(arr, 10);

	cout << "sort: ";

	for (int i = 0; i < 10; ++i) cout << arr[i] << " ";

	cout << endl;

	

	insertion_sort_optimize(arr, 10);

	cout << "s_op: ";

	for (int i = 0; i < 10; ++i) cout << arr[i] << " ";

	cout << endl;

	return 0;

}



Linjingchun97
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《算法导论》第三版第2章 算法基础 练习&思考题 个人答案
张劲声的博客
12-27 6010
第2章 算法基础 2.1 插入排序 2.1-1 以图2-2为模型，说明INSERTION-SORT在数组A=&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;31, 41, 59, 26, 41, 58&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;上的执行过程。 思路：仔细研究插入排序代码即可，无需思路，注意A中先后存在两个41，在排序过程中及排序后这两个41的先后顺序仍然不变，即插入排序具
算法导论课后习题第二章（1）
zhouhero的博客
06-02 685
算法导论课后习题第二章 算法导论 算法
算法导论第二版课后答案中文完全版
08-25
算法导论第二版课后答案中文完全版是算法导论的课后答案有 完整的解题过程 对于学好算法有很大帮助
《算法导论》第二章习题解答
weixin_30361641的博客
01-25 126
2.1-1 描述数组A = {31,41,59,26,41,58}插入排序过程 转载于:https://www.cnblogs.com/geyifan/archive/2013/01/25/2875929.html
《算法导论》读书笔记--第1、2章课后题
weixin_34391854的博客
07-17 312
第一章 思考题 1-1（运行时间的比较）确定时间t内求解的问题的最大规模。 上面是网上提供的答案。 注意点： 1、最左边一列的是关于n的增长情况描述，值得记住的是这些增长的排列顺序，这是非常有用的，啊，数分学好了会很容易； 2、注意1s内能处理的以n为增长量级的规模是10的6次方，记住这个结果可以推导出其他增长量级的处理规模； 3、注意这里的lg指的是以2为底的对数函数。 顺便...
信息奥赛c++学习笔记——贪心算法
01-06
2.算法：按照结束时间bi从小到大排序，然后按照排序顺序依次考虑每个活动，如果没有和已选活动冲突，就选，否则不选。 3.代码 #include #include #include using namespace std; struct qing{ int a,b; bool ...
A星算法学习笔记——记录
04-12
A星算法学习笔记——记录
算法导论 学习笔记.pdf
05-04
算法导论学习笔记 本资源是对《算法导论》的学习笔记，涵盖了算法的基础知识、算法分析、函数的增长、递归式等方面的内容。 一、算法基础知识 算法是指将输入转换为输出的一系列计算步骤，目的是为了有效利用...
MIT公开课——算法导论教材
10-05
《MIT公开课——算法导论教材》是一份源自美国麻省理工学院（MIT）的珍贵教育资源，专注于教授计算机科学中的核心概念——算法。这份教材涵盖了排序、树和Hash等基础但至关重要的算法，对于学习和理解计算机科学的...
人人学IoT———第二章学习笔记
01-06
第二个挑战：标准不同一、集成困难 终端传感器厂家多，通信协议众多、标准不统一、集成困难等 第三个挑战：网络连接复杂 物联网环境复杂、网络类型多、厂家开发终端需要适配很多协议、厂家进入物联网领域门槛较高等 ...
算法导论 第二版答案 中文版
02-14
机械工程出版社 算法导论 原书第二版 课后习题答案 中文版答案
算法导论(第二版)》(中文版)课后答案
10-06
《算法导论》一书深入浅出，全面地介绍了计算机算法。对每一个算法的分析既易于理解又十分有趣，并保持了数学严谨性。本书的设计目标全面，适用于多种用途。涵盖的内容有：算法在计算中的作用，概率分析和随机算法的介绍。本书专门讨论了线性规划，介绍了动态规划的两个应用，随机化和线性规划技术的近似算法等，还有有关递归求解、快速排序中用到的划分方法与期望线性时间顺序统计算法，以及对贪心算法元素的讨论。本书还介绍了对强连通子图算法正确性的证明，对哈密顿回路和子集求和问题的NP完全性的证明等内容。全书提供了900多个练习题和思考题以及叙述较为详细的实例研究。 　　《算法导论》一书内容丰富，对本科生的数据结构课程和研究生的算法课程都是很实用的教材。本书在读者的职业生涯中，也是一本案头的数学参考书或工程实践手册。 　　在有关算法的书中，有一些叙述非常严谨，但不够全面，另一些涉及了大量的题材，但又缺乏严谨性。《算法导论》将严谨性和全面性融为一体。 　　《算法导论》一书深入讨论各类算法，并着力使这些算法的设计和分析能为各个层次的读者接受。各章自成体系，可以作为独立的学习单元。算法以英语和伪代码的形式描述，具备初步程序设计经验的人就能看懂。说明和解释力求浅显易懂，不失深度和数学严谨性。
算法导论15.2-1矩阵链最优括号化方案
11-27
算法导论第三版练习题15.2-2的C++实现方案
算法导论第二章思考题
sscout的博客
08-05 1486
2-1 a.   ∵  长度为k的数组 ∴ 时间复杂度为 Θ（k²） ∵ 共有n/k个数组 ∴ T（n）= n/k * Θ（k²）= Θ（nk） b. ∵ 2^i = n/k ∴ i = lg（n/k） ∴ 共有 lg（n/k）+ 1层 ∵ 每层合并数组花费的时间为 Θ（n） ∴ 合并所有子数组的时间为 Θ（nlg（n/k）） c. ∵ 要与原来归并排序具有相同的运行时间...
＜算法导论＞第二章思考题
a1121420的博客
03-20 254
2-1 a、对长度为k的子表使用插入排序最坏的情况下复杂度为Θ($k^{2}$),因此对n/k个每个长度为k的子表 排序最坏需要Θ(k^2 * n/k)=Θ(nk). b、$ J_\alpha(x) = \sum_{m=0}^\infty \frac{(-1)^m}{m! \Gamma (m + \alpha + 1)} {\left({ \frac{x}{2} }\right)}^{2m + \alpha} \text {，行内公式示例} $ ...
算法导论作业第二章思考题
fugitive1的博客
05-17 260
2-1 在归并排序中对小数组采用插入排序 2-2 2-3 2-4
算法导论 思考题 2-1
zslomo的博客
04-16 2490
题目：在合并排序中，对小数组采用插入排序解答：a）证明在最坏情况下，n/kn/k个子列表（每个子列表长度为kk）可以用插入排序在Θ(nk)\Theta(nk)时间内完成：长度为k的表插入排序是 Θ(n2)\Theta(n^2) 那么 n/kn/k 个就是 Θ(n2)∗n/k=Θ(nk)\Theta(n^2)*n/k=\Theta(nk)b）证明这些子列表可以在Θ(nlg(n/k))\Theta(nl
算法导论2-1-4
36ICE的博客
07-16 559
希望大家多多支持，算法导论2-1-4n位二进制相加源码，转载请注明出处。#include #include using namespace std; typedef int Elem; void Show(Elem *A, int n) { for (int i = n; i >= 1; i--) { cout << A[i] ; } cout << endl; } //插入排序
算法导论第三版第二章思考题答案
最新发布
游者的博客
12-17 484
插入排序花在寻找插入位置的时间与逆序对的数量正相关。的段，我们需要两个子序列，并递归的做下去，每次合并都比较。每次迭代我们都把较大的数字交换到左边的位置，小，所以最后一个元素是最大的，也就是不等式。所以每次迭代开始前，中所有元素不重不漏的有序排列。按照降序排列拥有最多的逆序对，中的终止结论可知，上一次关于。终止：当最后一次迭代结束后，通过插入排序获得了长度为。保持：每次迭代开始前，由。插入排序的时间复杂度为。只有末尾单独元素，成立。终止时的式子展开即可。的有序段，且总长度为。最后一次迭代结束后，

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值