大二（下）算法与设计 分治策略

最新推荐文章于 2020-03-11 23:09:54 发布
最新推荐文章于 2020-03-11 23:09:54 发布
阅读量202 收藏
点赞数
分类专栏： 算法与设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43271844/article/details/89223506
版权

在这里插入图片描述
在这里插入图片描述
关键代码

（1）快速排序算法：时间复杂度O(nlog2n)
int Partition(List* list, int low, int high)  
{
	int i = low, j = high + 1;
	Entry pivot = list->D[low];
	do
	{
		do i++; while (list->D[i].key < pivot.key); //i前进
		do j--; while (list->D[j].key > pivot.key); //j前进
		if (i < j) Swap(list->D, i, j);
	} while (i < j);
	Swap(list->D, low, j);
	return j;
}
void QuickSort(List* list, int low, int high) //快速排序算法
{
	int k;
	if (low < high)
	{
		k = Partition(list, low, high);
		QuickSort(list, low, k - 1);
		QuickSort(list, k + 1, high);
	}
}
void QuickSort(List *list)  //快速排序的调用函数
{
	QuickSort(list, 0, list->n - 1);
}


（2）优化的快速排序算法：时间复杂度O(nlog2n)
int NewPartition(List* list, int low, int high)
{
	int i = low, j = high + 1;
	Entry pivot = list->D[(low + high) / 2]; //主元修改为low + high) / 2
	do
	{
		do i++; while (list->D[i].key < pivot.key); //i前进
		do j--; while (list->D[j].key > pivot.key); //j前进
		if (i < j) Swap(list->D, i, j);
	} while (i < j);
	Swap(list->D, low, j);
	return j;
}
void NewQuickSort(List* list, int low, int high) //优化的快速排序算法
{
	int k;
	if (low < high)
	{
		k = NewPartition(list, low, high);
		NewQuickSort(list, low, k - 1);
		NewQuickSort(list, k + 1, high);
	}
}
void NewQuickSort(List *list)  //优化的快速排序的调用函数
{
	NewQuickSort(list, 0, list->n - 1);
}


（3）两路合并排序算法：时间复杂度O(nlog2n)
Entry temp[max];
long MergeSort(List* l)    //两路合并排序
{
	int size = 1, n1, n2;
	while (size < l->n)
	{
		int k = 0;
		int low = 0;
		while (low + size <= l->n)
		{
			n1 = size;
			if (low + size * 2 < l->n)
			{
				n2 = size;
			}
			else
			{
				n2 = l->n - low - size;
			}

			int i = low, j = low + n1;
			while (i <= low + n1 - 1 && j <= low + n1 + n2 - 1)
			{
				if (l->D[i].key <= l->D[j].key)
				{
					temp[k++] = l->D[i++];
				}
				else
				{
					temp[k++] = l->D[j++];
				}
			}
			while (i <= low + n1 - 1)
			{
				temp[k++] = l->D[i++];
			}
			while (j <= low + n1 + n2 - 1)
			{
				temp[k++] = l->D[j++];
			}
			low += n1 + n2;
		}
		for (int i = 0; i < l->n; i++)
		{
			l->D[i] = temp[i];
		}
		size *= 2;
	}
	return 0;
}

完整代码：

#include<iostream>
#include<stdlib.h>
#include<time.h>
const int  max = 51000;
using namespace std;
typedef int KeyType;
typedef int DataType;
typedef struct entry
{
	KeyType key;
	DataType data;
}Entry;
typedef struct list
{
	int n;
	Entry D[max];
}List;

int FindMin(List list, int startIndex)  //找最小值（简单选择排序）
{
	int i, minIndex = startIndex;
	for (i = startIndex + 1; i < list.n; i++)
	{
		if (list.D[i].key < list.D[minIndex].key)
			minIndex = i;
	}
	return minIndex;
}
void Swap(Entry* D, int i, int j)
{
	if (i == j)return;
	Entry temp = *(D + i);
	*(D + i) = *(D + j);
	*(D + j) = temp;
}
void SelectSort(List* list) //简单选择排序
{
	int minIndex, startIndex = 0;
	while (startIndex < list->n - 1)
	{
		minIndex = FindMin(*list, startIndex);
		Swap(list->D, startIndex, minIndex);
		startIndex++;
	}
}

void InsertSort(List *list) //直接插入排序
{
	int i, j;
	for (i = 1; i < list->n; i++)
	{
		Entry insertItem = list->D[i];
		for (j = i - 1; j >= 0; j--)
		{
			if (insertItem.key < list->D[j].key)
				list->D[j + 1] = list->D[j];
			else break;
		}
		list->D[j + 1] = insertItem;
	}
}

void BubbleSort(List* list, int n) //冒泡排序,n为待排序的个数
{
	int i, j;
	bool isSwap = false;
	for (i = n - 1; i > 0; i--)
	{
		for (j = 0; j < i; j++)
		{
			if (list->D[j].key > list->D[j + 1].key)
			{
				Swap(list->D, j, j + 1);
				isSwap = true;
			}
		}
		if (!isSwap) break;
	}
}


int Partition(List* list, int low, int high)
{
	int i = low, j = high + 1;
	Entry pivot = list->D[low];
	do
	{
		do i++; while (list->D[i].key < pivot.key); //i前进
		do j--; while (list->D[j].key > pivot.key); //j前进
		if (i < j) Swap(list->D, i, j);
	} while (i < j);
	Swap(list->D, low, j);
	return j;
}
void QuickSort(List* list, int low, int high) //快速排序算法
{
	int k;
	if (low < high)
	{
		k = Partition(list, low, high);
		QuickSort(list, low, k - 1);
		QuickSort(list, k + 1, high);
	}
}
void QuickSort(List *list)  //快速排序的调用函数
{
	QuickSort(list, 0, list->n - 1);
}



int NewPartition(List* list, int low, int high)
{
	int i = low, j = high + 1;
	Entry pivot = list->D[(low + high) / 2]; //主元修改为low + high) / 2
	do
	{
		do i++; while (list->D[i].key < pivot.key); //i前进
		do j--; while (list->D[j].key > pivot.key); //j前进
		if (i < j) Swap(list->D, i, j);
	} while (i < j);
	Swap(list->D, low, j);
	return j;
}
void NewQuickSort(List* list, int low, int high) //优化的快速排序算法
{
	int k;
	if (low < high)
	{
		k = NewPartition(list, low, high);
		NewQuickSort(list, low, k - 1);
		NewQuickSort(list, k + 1, high);
	}
}
void NewQuickSort(List *list)  //优化的快速排序的调用函数
{
	NewQuickSort(list, 0, list->n - 1);
}


Entry temp[max];
long MergeSort(List* l)    //两路合并排序
{
	int size = 1, n1, n2;
	while (size < l->n)
	{
		int k = 0;
		int low = 0;
		while (low + size <= l->n)
		{
			n1 = size;
			if (low + size * 2 < l->n)
			{
				n2 = size;
			}
			else
			{
				n2 = l->n - low - size;
			}

			int i = low, j = low + n1;
			while (i <= low + n1 - 1 && j <= low + n1 + n2 - 1)
			{
				if (l->D[i].key <= l->D[j].key)
				{
					temp[k++] = l->D[i++];
				}
				else
				{
					temp[k++] = l->D[j++];
				}
			}
			while (i <= low + n1 - 1)
			{
				temp[k++] = l->D[i++];
			}
			while (j <= low + n1 + n2 - 1)
			{
				temp[k++] = l->D[j++];
			}
			low += n1 + n2;
		}
		for (int i = 0; i < l->n; i++)
		{
			l->D[i] = temp[i];
		}
		size *= 2;
	}
	return 0;
}



typedef struct maxheap   //堆排序
{
	int n, MaxHeap;
	Entry D[max];
}MaxHeap;
void AdjustDown(List *list, int r, int j)
{
	int child = 2 * r + 1;
	Entry temp = list->D[r];
	while (child <= j)
	{
		if ((child < j) && (list->D[child].key < list->D[child + 1].key))
			child++;
		if (temp.key >= list->D[child].key)
			break;
		list->D[(child - 1) / 2] = list->D[child];
		child = 2 * child + 1;
	}
	list->D[(child - 1) / 2] = temp;
}
void HeapSort(List *list)
{
	for (int i = (list->n - 2) / 2; i > -1; i--)
		AdjustDown(list, i, list->n - 1);
	for (int i = list->n - 1; i > 0; i--)
	{
		Swap(list->D, 0, i);
		AdjustDown(list, 0, i - 1);
	}
}


void Rand(List *list, int a[])  /*产生随机整数*/
{
	for (int i = 0; i < max; i++)
	{
		int b = rand() % 100000;
		list->D[i].key = b;
		list->D[i].data = b;
		a[i] = b;
		list->n++;
	}
}

void RepeatRand(List *list, int *a)  /*复制随机整数*/
{
	for (int i = 0; i < max; i++)
	{
		list->D[i].key = a[i];
		list->D[i].data = a[i];
	}
}


int main()
{
	List L1;
	L1.n = 0;
	int a[max];
	clock_t start, finish;
	Rand(&L1, a); /*产生100以内的随机整数*/

	for (int i = 0; i < 10000; i++)
		printf("%d\t", L1.D[i].data);

	RepeatRand(&L1, a);
	start = clock();
	NewQuickSort(&L1);       //优化的快速排序的调用函数
	finish = clock();
	printf("\n优化的快速排序：\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;

	RepeatRand(&L1, a);
	start = clock();
	QuickSort(&L1);       //快速排序的调用函数
	finish = clock();
	printf("\n快速排序：\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;


	start = clock();
	SelectSort(&L1);      //简单选择排序
	finish = clock();
	printf("\n简单选择排序\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;

	RepeatRand(&L1, a);
	start = clock();
	InsertSort(&L1);      //直接插入排序
	finish = clock();
	printf("\n直接插入排序:\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;

	RepeatRand(&L1, a);
	start = clock();
	BubbleSort(&L1, 100);  //冒泡排序
	finish = clock();
	printf("\n冒泡排序：\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;

	RepeatRand(&L1, a);
	start = clock();
	MergeSort(&L1);      //两路合并排序
	finish = clock();
	printf("\n两路合并排序：\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;

	RepeatRand(&L1, a);
	start = clock();
	HeapSort(&L1);       //堆排序
	finish = clock();
	printf("\n堆排序：\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;
	

	system("pause");
	return 0;
}
Thorold's Deer
关注
专栏目录
Gray码是一个长度为2n的序列。序列中无相同的原图，每个元素都是长度为n位的串，相邻元素恰好只有一位不同。用分治策略设计一个算法对任意的n构造相应的Gray码。
06-22
n=1时，Gray码：0，1 n=2时，Gray码：00，10， 11，01 n=3时，Gray码：000，010，011，001， 101，111，110，100 n=4,时，Gray码：0000，0010，0011，0001，0101，0111，0110，0100， 1100，1110，1111，1101，1001，1011，1010，1000 从上面可以看出如下规律：从n=2开始，每个n的Gray码由两部分组成。后一位的Gray码可以从前一位的Gray码求出，即，在n的Gray码的前半部分是n-1的所有Gray码顺次在前面加0得到；n的Gray码的后半部分是n-1的所有Gray码逆序在前面加1得到。
大二算法分析课程全部ppt
12-14
这份文档很详细，很全面，对于迫切想要预习和复习的童鞋非常有帮助，这是一个包含大学全部要求所学内容的ppt课程资源。
大二（下）算法与设计 动态规划法
Albirostris
05-11 264
内容：用动态规划法实现求两序列的最长公共子序列。 要求：掌握动态规划法的思想，及动态规划法在实际中的应用；分析最长公共子序列的问题特征，选择算法策略并设计具体算法，编程实现两输入序列的比较，并输出它们的最长公共子序列。 #include <iostream> #include <string> using namespace std; int const MaxLen = ...
大二算法课课堂算法练习-dp篇(持续更新)
Aczy156的博客
10-20 211
01背包 dp 2019.10.20 题目1 hdu2602 这个题真是怀疑人生，两分钟把代码一打，然后盯了大半个小时，结果到最后发现是应该先读入所有物品的价值，不是先读入所有物品的体积（真是无语，中间各种debug，甚至还拿起了原来的代码跑一跑看原来是不是错的。。。） 题目2 hdu3466 ...
算法导论（2）分治策略
xhh22900的博客
03-11 371
文章目录算法导论（2）分治策略1.最大子数组问题分治策略求解2.矩阵乘法的Strassen算法分治算法Strassen方法 算法导论（2）分治策略 分治策略递归地求解一个问题时，每层递归中实行三个步骤： 分解：将问题划分为一些形式与原问题一致但规模更小的子问题 解决：递归地求解出子问题。如果子问题的规模足够下则通知递归直接求解 合并：将子问题的解合成原问题的解 1.最大子数组问题 假如你获得投...
算法设计与分析实验报告
07-10
在这个nefu大二下学期的算法四次实验报告中，学生将深入理解并实践一系列基础及进阶的算法，通过实际操作来增强对算法设计原则和分析方法的理解。 一、实验目的 1. 掌握基本的算法设计技巧，如分治、动态规划、...
算法设计与分析作业及答案
09-20
北京邮电大学的大二下学期课程深入探讨了这一话题，旨在培养学生的算法思维和实践能力。以下是相关知识点的详细说明： 1. **循环赛**：循环赛通常指的是在算法竞赛中的一种常见问题，如每两个选手都要进行一次比赛...
数据结构课程设计报告.docx
07-30
- **归并排序**：采用分治策略，时间复杂度为O(n log n)，空间复杂度为O(m)。 - **快速排序**：基于“分区”操作，平均时间复杂度为O(n log n)，最坏情况下为O(n^2)，空间复杂度为O(m)。 - **堆排序**：利用堆...
数据结构-大二上复习思维导图
11-11
大二上学期的数据结构课程通常涵盖了一些基本和重要的概念，这些概念在软件开发和算法设计中至关重要。这份"数据结构-大二上复习思维导图"提供了对这一主题的全面概述，主要分为查找、二叉树、排序和复习四个主要...
深入探讨数据结构编程题：算法实践与技巧
堆排序是基于二叉堆的数据结构实现的，而快速排序则是通过分治策略，以一个元素为基准进行分区，将数组分为两个子数组，递归地对子数组进行排序。 10. 图的遍历（Graph Traversal） 图是由顶点和边组成的复杂数据...
数据结构堆排序的源代码
05-20
#include #define MAXNUM 100 #define TRUE 1 #define FALSE 0 typedef int KeyType; typedef int DataType; typedef struct { KeyType key; } RecordNode; typedef struct { int n; RecordNode record[MAXNUM]; } SortObject; #define leftChild(i) (2*(i)+1)
分治策略详解 算法及伪代码 选择 排序 ppt
04-10
2.1 分治策略的基本思想 2.1.1 分治算法的一般性描述 2.2 分治算法的分析 2.3 改进分治算法的途径(不做要求) 2.3.1 通过代数变换减少子问题个数 2.3.2 利用预处理减少递归内部的计算量 2.4 典型实例 2.4.1 求最大最小元 2.4.2 排序问题 2.4.3 选择问题
2-14 用分治策略构造Gray码
HHHHHHep的博客
03-28 5400
Gray码是一个长度为2^n的序列。序列中无相同元素，每个元素都是长度为n位的串，相邻元素恰好只有1位不同。用分治策略设计一个算法对任意的n构造相应的Gray码。#include &lt;bits/stdc++.h&gt; using namespace std; void GrayCode(int a[][100], int n, int len) { if(n == 0) ...
构造Gray码的分治算法
新博客：https://aping-dev.com/
11-15 9997
#include "iostream" #include "cmath" using namespace std;int arr[1024][1024]; //arr[i][j]表示第i个格雷码的第j位//构造b位格雷码 //a为格雷码的个数 void gray(int a, int b) { if(b==1) //如果格雷码宽度为1 { arr[0][0] = 0;
算法中分治策略实现快速排序
jiav_net的专栏
10-26 619
快速排序算法是基于分治策略的一个排序算法，其基本思想是，对于输入的子数组，按以下三个步骤求解： 1 分解：选择一个基准元素，将整个数组分为大于基准元素，等于基准元素，小于基准元素的三组。基准元素在在划分的过程中确定 2 递归求解：通过递归调用快速排序算法分别对大于和小于基准元素的数组进行排序 3 合并：将递归的子数组进行合并最后成为排好序的数组 下面是程序的代码： #include&lt...
求第k大数
计算机编程开发学习交流的专栏
04-01 2118
问题描述：给定线性序集中n个元素和一个整数k，1≤k≤n，要求找出这n个元素中第k大的元素，（这里给定的线性集是无序的）。 　　其实这个问题很简单，直接对线性序列集qsort，再找出第k个即可。但是这样的时间复杂度就是qsort的时间复杂度O(nlogn)。有没有更快的方法呢？看到网上有一种解法是采取了快排的思路，但是稍微坐了些改动，然后时间复杂度能够接近O(n)。因为最近刚刚写了快排的实现
数据结构 C语言 综合排序问题
zpl19980503的博客
06-12 838
一、实验目的和要求1、掌握各种内排序算法的实现方法；2、学会分析各种内排序算法的时间复杂度；二、实验环境软件：Dev-C++三、实验原理及内容#include&lt;stdio.h&gt;#include&lt;stdlib.h&gt;#include&lt;time.h&gt;#define MaxSize 100000//const int MaxSize=100000;#define FAL...
算法分析与设计实验(一)之分治算法
有机盐的博客
03-13 4752
实验目的 （1）基本掌握分治算法的原理。 （2）掌握递归算法及递归程序的设计。 （3）能用程序设计语言求解相关问题。 实验要求 （1）用分治法求解问题； （2）分析算法的时间性能，设计实验程序验证分析结论。 预习要求 （1）了解用分治法求解的问题：当要求解一个输入规模为n，且n的取值相当大的问题时，如果问题可以分成k个不同子集合，得到k个不同的可独立求解的子问题，其中1&amp;lt;k≤n，而且子问题与...
算法设计：二维最接近点对问题的分治策略
1. 掌握递归与分治法的基本思想及基本原理。 2. 掌握使用分治法求解问题的一般特征及步骤。 3. 掌握分治法的设计方法及复杂性分析方法。 4. 掌握分治法解平面最接近点对算法设计思想、算法设计过程及程序编码实现。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值