算法

最新推荐文章于 2022-10-24 11:32:29 发布
最新推荐文章于 2022-10-24 11:32:29 发布
阅读量186 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43893890/article/details/103241660
版权

一个程序主要应该包括两方面内容:一个是对数据组织的描述，另一个则是对程序操作的描述。对数据组织的描述称为数据结构，而对程序操作的描述称为算法。因此有这样一个公式:数据结构+算法=程序。对于面向对象程序设计，强调的是数据结构，而对于面向过程程序设计，如C. Pascal. FORTRAN等语言，主要关注的是算法。

 

算法：解决一个问题的完整步骤描述。

五个特征:有穷、正确、可行、输入、输出。

三种基本结构:顺序、选择、循环

流程图：普通流程图    ；  N-S流程图

 

 

下面介绍排序算法：

为什么介绍排序算法呢？因为 排序是数据处理中的一种重要运算。在当今计算机系统中，花费在数据排序的时间占用了一部分系统运行的时间，所以研究并采用好的排序算法，能够提高工作效率是很重要的。

//选择排序
#include<stdio.h>
int main()
{
	int a[10];
	int i,j,k,m;
	printf("10 numbers:\n");
	for(i=0;i<10;i++)
	{
		scanf("%d",&a[i]);
	}
	for(i=0;i<9;i++)
	{
		k=i;
		for(j=i+1;j<10;j++)
			if(a[k]>a[j])
				k=j;
			if(k!=i)
			{
				m=a[i];
				a[i]=a[k];
				a[k]=m;
			}
	}
	printf("The sorted array is :  by the chosen method .\n  ");
	for(i=0;i<10;i++)
	{
		printf("%d  ",a[i]);
	}
	printf("\n");
 } 
//9 4 3 34 32 4 38 98 0 99

 

//堆排序
#include<stdio.h>
#define LENGTH 20

 递归方式构建大根堆(len是arr的长度，index是第一个非叶子节点的下标)
void adjust(int arr[],int len,int index)
{
	int left = 2*index + 1; // index的左子节点下表 
	int right = 2*index + 2;// index的右子节点下标 
	int temp;
	int maxIdx=index;
	if(left<len&&arr[left]>arr[maxIdx]) maxIdx=left;
	if(right<len&&arr[right]>arr[maxIdx])  maxIdx=right;
	if(maxIdx!=index)
	{
		temp=arr[maxIdx];
		arr[maxIdx]=arr[index];
		arr[index]=temp;
		adjust(arr,len,maxIdx);
	 } 
}
//堆排序
void heapSort(int arr[],int size)

{
	int i,temp;
	//构建大根堆（从最后一个非叶子节点向上） 
	for(i=size/2-1;i>=0;i--)
	{
		adjust(arr,size,i);
	}
	printf("the max heap:\n");
	for(i=0;i<size;i++)
	{
		printf("%d  ",arr[i]);	
	} 
	printf("\n");
	//调整大根堆
	for(i=size-1;i>=1;i--)
	{
		temp=arr[i];
		arr[i]=arr[0]; // 将当前最大的放置到数组末尾
		arr[0]=temp;
		adjust(arr,i,0);// 将未完成排序的部分继续进行堆排序
	 } 
 } 
 main()
 {
 	int b[LENGTH];
 	int i;
 	for(i=0;i<LENGTH;i++)
 	{
 		scanf("%d ",&b[i]);
	 }
	 printf("\n");
	 heapSort(b,LENGTH);
	 for(i=0;i<LENGTH;i++)
	 {
	 	printf("%d  ",b[i]);
	 }
	 return 0;
	 
 }

 

8 9 0 2 3 4 223 4 3 78 6767 9889 78 67 56 45 34 23 21 213 99

//冒泡排序
#include<stdio.h>
main()
{
	int a[10]; 
	int i,j,k;
	printf("10 numbers:\n");
	for(i=0;i<10;i++)
	{
		scanf("%d",&a[i]);
	}
	for(i=0;i<9;i++)//十个数进行九趟排序 
	{
		for(j=0;j<9-i;j++)
		{
			if(a[j]>a[j+1])
			{
				k=a[j];
				a[j]=a[j+1];
				a[j+1]=k;
			}
		}
	 }
	 printf("The sorted array is : by bubble.");
	for(i=0;i<10;i++)
	{
		printf("%d  ",a[i]);
	}
	printf("\n"); 
 } 

//quicksort
//对冒泡的改进 
#include<stdio.h>
#define N 10000
#include<time.h>
main()
{	
	clock_t begin,end;
	double cost;
	int p(int a[],int low,int high);
	void q(int a[],int low,int high); 
	int a[N];
	int i;
	//printf("please input 10 numbers.\n");
	int j=1000;
	begin=clock();
	for(i=0;i<N;i++)
	{
	//	scanf("%d",&a[i]);
	a[i]=j--;
	}
	
	q(a,0,N-1);
	end=clock();
	cost=(double)(end-begin);
	printf("The sorted array is :  by quicksort method .\n  ");
	for(i=0;i<N;i++)
	{
		printf("%d  ",a[i]);
	}
	printf("The cost is: %lf\n",cost); 
} 
int p(int a[],int low,int high)
{
	int key=a[low],p;
	while(low<high)
	{
		while(low<high&&a[high]>=key)
		{
			--high;
		}
		p=a[low];
		a[low]=a[high];
		a[high]=p;
		while(low<high&&a[low]<=key)
		{
			++low;
		}
		p=a[high];
		a[high]=a[low];
		a[low]=p;
	}
	a[low]=key;
	return low;
}
void q(int a[],int low,int high)
{
	int j;
	if(low<high)
	{
		j=p(a,low,high);
		q(a,low,j-1);
		q(a,j+1,high);
	}
}

 

 

 

//quicksort
//对冒泡的改进 
#include<stdio.h>
#define N 5000
#include<time.h>
main()
{	
	clock_t begin,end;
	double cost;
	int p(int a[],int low,int high);
	void q(int a[],int low,int high); 
	int a[N];
	int i;
	//printf("please input 10 numbers.\n");
	int j=1000;
	begin=clock();
	for(i=0;i<N;i++)
	{
	//	scanf("%d",&a[i]);
	a[i]=j--;
	}
	
	q(a,0,N-1);
	end=clock();
	cost=(double)(end-begin);
	printf("The sorted array is :  by quicksort method .\n  ");
	for(i=0;i<N;i++)
	{
		printf("%d  ",a[i]);
	}
	printf("\nThe cost is: %lf\n",cost); 
} 
int p(int a[],int low,int high)
{
	int key=a[low],p;
	while(low<high)
	{
		while(low<high&&a[high]>=key)
		{
			--high;
		}
		p=a[low];
		a[low]=a[high];
		a[high]=p;
		while(low<high&&a[low]<=key)
		{
			++low;
		}
		p=a[high];
		a[high]=a[low];
		a[low]=p;
	}
	a[low]=key;
	return low;
}
void q(int a[],int low,int high)
{
	int j;
	if(low<high)
	{
		j=p(a,low,high);
		q(a,low,j-1);
		q(a,j+1,high);
	}
}

 

 

OPENMP并行快排主要利用了OpenMP里面的#omp parallel sections将对两个子数组的快速排序函数用两个线程并行化执行，至于线程的创建和销毁我们不用管，只要告诉编译器哪里的代码需要并行执行就可以了，具体请看OpenMP资料。

//quicksort
//对冒泡的改进 
#include<stdio.h>
#include<time.h>
#include "omp.h"
#define N 5000
#pragma warning(disable:4996)
int main()
{	
	omp_set_num_threads(2);//----------------设置线程数为2，因为是双核的CPU
	double  cost;
	clock_t begin, end;
	int p(int a[], int low, int high);
	void q(int a[], int low, int high);
	int a[N];
	int b[N / 2];
	int c[N / 2];
	int d[N];
	int j = 1000;

	int i = 0,k = 0,m=0,n=0;
#pragma omp parallel default(none) shared(a,d,N) private(i)//private(list)表示每个线程的变量都是局部的，shared()表示的变量被线程组中所有线程共享，default（）定义缺省范围
	{	//---这个for循环是并行的  
#pragma omp for
		for (i = 0; i < N; i++)
	{
		a[i] = j;
		d[i] = j;
		j--;
	}
	}
	begin = clock();
#pragma omp parallel default(none) shared(a,b,c,N/2) private(i)//---这个for循环是并行的  
	{
#pragma omp for
		for (i = 0; i < N / 2; i++)
		{
			b[i] = a[i];
			c[i] = a[i + N / 2];
		}
	}
#pragma omp parallel default(none) shared(b,c,N/2)//private(i)------快速排序的并行region 
	{
#pragma omp parallel sections
		{
#pragma omp section
			q(b, 0, N/2 - 1);
			
#pragma omp section
			q(c, 0, N / 2 - 1);
		}
	}
	for (; k < N; k++)//----------将D[]和E[]进行归并排序放入B[]里面  
	{
		if (m < N / 2 && n < N / 2)
		{
			if (b[n] <= c[m])
			{
				d[k] = b[n];
				n++;
			}
			else
			{
				d[k] = c[m];
				m++;
			}
		}
		if (m == N / 2 || n == N / 2)
		{
			if (m == N / 2)
				d[k] = c[m];
			else
				d[k] = b[n-1];
			k += 1;
			break;
		}
	}
	if (n < N / 2)
	{
		int tem = N / 2 - n;
		int pp = 0;
		for (pp = 0; pp < tem; pp++)
		{
			d[k] = b[n];
			n++;
			k++;
		}
	}
	else if (m < N / 2)
	{
		int tem = N / 2 - m;
		int pp = 0;
		for (pp = 0; pp < tem; pp++)
		{
			d[k] = c[m];
			m++;
			k++;
		}
	}
	end = clock();
	printf("The sorted array is :  by quicksort method .\n  ");
	for (i = 0; i < N; i++)
	{
		printf("%d  ", d[i]);
	}
	cost = (double)(end - begin);
	printf("\n并行时间为:%lf\n",cost);
}
int p(int a[], int low, int high)
{
	int key = a[low], p;
	while (low < high)
	{
		while (low < high && a[high] >= key)
		{
			--high;
		}
		p = a[low];
		a[low] = a[high];
		a[high] = p;
		while (low < high && a[low] <= key)
		{
			++low;
		}
		p = a[high];
		a[high] = a[low];
		a[low] = p;
	}
	a[low] = key;
	return low;
}
void q(int a[], int low, int high)
{
	int j;
	if (low < high)
	{
		j = p(a, low, high);
		q(a, low, j - 1);
		q(a, j + 1, high);
	}
}

 

 

 

 

 

 

#include <iostream>
using namespace std;
#define LENGTH 20

//直接插入排序：将第一个数据看做一个顺序表，将后面的数据一次插入表中
void InsertSort(int a[], int n)  
{  
for(int i= 1; i<n; i++){  
     int j= i-1;   //表中最后一个数据
    int x = a[i];        //复制为哨兵，即存储待排序元素  
    while(j>=0 && x < a[j]){  //查找在有序表的插入位置  (遍历表)
        a[j+1] = a[j];  
        j--;         //元素后移  
    }  
    a[j+1] = x;      //插入到正确位置  
}  
  
} 

int main()
{

int b[LENGTH];
for(int i=0;i<LENGTH;i++){
    printf("%d ",b[i]);
}

cout<<"\n";
InsertSort(b,LENGTH);
for(int i=0;i<LENGTH;i++)
    cout<<b[i]<<" ";

return 0;
}

 

 

基本思想是：希尔排序是在插入排序的基础上进行发展的，通过一个希尔增量先排序一定间隔的数据。待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
平均时间复杂度：O(N^3/2)
空间复杂度：O(1)
稳定性：不稳定

#include <iostream>
using namespace std;
#define LENGTH 20
void shellsort(int a[],int n) {  
for (int increment = n / 2; increment > 0; increment /= 2)
{
    for (int i = increment; i < n; i++)
    {
        int insert_num = a[i], j;
        for (j = i - increment; j >= 0; j -= increment)
        {
            if (a[j] > insert_num)
                a[j + increment] = a[j];
            else
                break;
        }
        a[j + increment] = insert_num;
    }
} 
}  
int main()
{

int b[LENGTH];
for(int i=0;i<LENGTH;i++){
    printf("%d ",b[i]);
}
cout<<"\n";
shellsort(b,LENGTH);
for(int i=0;i<LENGTH;i++)
    cout<<b[i]<<" ";

return 0;
}

 

小白-52HZ
关注
JAVA近百种算法大全
05-29
Java算法大全是一个包含约100种常见算法的资源库，专为Java程序员设计，用于深入理解和实践编程中的各种算法。这些算法涵盖了数据结构、排序、搜索、图论等多个领域，是提升编程技能和解决问题能力的重要工具。下面...
并行计算：OpenMP(二)关于变量的可共享性——private、shared子句
JacksonKim的博客
05-09 8268
一、private子句 1. private private 子句可以将变量声明为线程私有，声明称线程私有变量以后，每个线程都有一个该变量的副本，线程之间不会互相影响，其他线程无法访问其他线程的副本。原变量在并行部分不起任何作用，也不会受到并行部分内部操作的影响。 #include <stdio.h> #include <omp.h> int main(int argc, char* argv[]) { int i = 20; #pragma omp pa...
OMP 设置线程的3种方法
热门推荐
weixin_37804469的博客
12-12 2万+
设置线程的3种方法： 在子语句 data clause 中设置 ： num_threads( ) 在 run time 函数库中设置 ： omp_set_num_threads( ) 在环境变量中设置environment variables， 在命令窗口中设置 ： export OMP_NUM_THREADS = 3 1、2、3 优先级依次降低的，也就是前面的设置可以覆盖...
openmp开启后计算结果错误原因
VivienFu的专栏
03-09 7241
openmp多线程使用方法十分简单，一般对于for循环只需要加一句#pragma omp parallel for就可以了。新手使用的时候有时候可能会出现开启omp之后，得到的计算结果是错的，而且多次执行结果还不相同。1.   其中一个可能的原因是你的代码中不同的线程同时使用某一内存的值并且试图改变它，比如累加操作，这种情况下线程x获取的数据可能不是最新的。示例1：参考https://www.cn...
并行处理及分布式系统 第五章 用OpenMP进行共享内存编程
qq_52808734的博客
10-24 1908
OpenMP学习笔记
OpenMP学习笔记
叶子心情你不懂
08-04 3241
一、OpenMP简介 1. 内存共享并行模型。 机器必须多处理器/核，共享内存。 底层架构可以是UMA和NUMA。 UMA NUMA 2. Fork-Join模型 重复fork-join操作。 3. OpenMP特性 OpenMP仅通过线程来完成并行。 OpenMP的程序一般由串行等价性，也就是并行运算最终的结果会和某个串行程序相等。 支持 c / c++ 等语言。 编译器VS、gcc、clang等都支持OpenMP。可移植性好。 编译命令一般加上-fopenmp就可以。 二、Op
落实算法安全主体责任基本情况（模板）
08-18
在当前的数字化时代，算法已成为企业运营的核心组成部分，特别是在互联网信息服务领域。算法安全的重要性日益凸显，因为不安全的算法可能导致信息泄露、用户隐私侵犯、甚至社会秩序混乱等问题。因此，落实算法安全的...
程序员算法大全
05-04
《程序员算法大全》是针对IT专业人士，特别是程序员和软件开发者设计的一份综合资源，它涵盖了数据结构和算法的广泛知识。这份资料集旨在提升程序员在解决复杂问题时的逻辑思维和编程能力，从而提高其在面试和实际...
JAVA经典算法90题【含源码】
10-10
在编程领域，特别是Java开发，熟练掌握算法是提升技术能力的关键。"JAVA经典算法90题【含源码】"的资源集合为Java初学者提供了一个绝佳的学习平台，旨在通过实际操作来理解和应用各种基础及进阶算法。下面将详细阐述...
算法竞赛入门到进阶 课件+源码
06-17
《算法竞赛入门到进阶 课件+源码》这套资源是为想要在算法竞赛中提升自己能力的初学者和进阶者准备的宝贵资料。它涵盖了从基础到高级的各种算法，通过课件和源码的结合，使学习者能够理论与实践相结合，更好地理解和...
DBSCAN聚类算法matlab代码
03-22
DBSCAN（Density-Based Spatial Clustering of Applications with Noise）是一种基于密度的空间聚类算法，它能够发现任意形状的聚类，并且对噪声具有很好的处理能力。在MATLAB中实现DBSCAN，可以帮助我们更方便地...
遗传算法优化测试函数，方便理解
07-13
遗传算法优化测试函数，方便理解 ，简单通俗易懂 ，方便和其他算法对比 遗传算法优化测试函数，方便理解 ，简单通俗易懂 ，方便和其他算法对比 遗传算法优化测试函数，方便理解 ，简单通俗易懂 ，方便和其他算法对比...
SABO算法、DBO算法、GWO算法、WOA算法、GSABO算法合集
最新发布
09-23
资源采用CEC2005测试集，减法平均优化（SABO）算法、蜣螂优化(DBO)算法、灰狼（GWO）算法、鲸鱼（WOA）算法、融合黄金正弦（GSABO）算法合集
模型算法大全（20+种常用算法模型+代码实现）
04-24
模型算法大全（20+种常用算法模型+代码实现）模型算法大全（20+种常用算法模型+代码实现）模型算法大全（20+种常用算法模型+代码实现）模型算法大全（20+种常用算法模型+代码实现）模型算法大全（20+种常用算法模型+...
粒子群算法、遗传算法以及两者的结合的优化算法
10-25
粒子群算法（Particle Swarm Optimization, PSO）与遗传算法（Genetic Algorithm, GA）是两种在优化问题中广泛应用的全局搜索方法。它们都是基于自然选择和群体智能的启发式算法，能够有效地解决复杂多模态优化问题...
OpenMP学习（三）
xiaoan_ding的专栏
03-06 731
一、OpenMP组成 由三大部分组成： 1、指令 Directives 2、运行时环境 Runtime Environment 3、环境变量 Environment Variable 二、指令 Directives 指令有以下几种： 并行区域 parallel region worksharing结构 worksharing constructs 任务 tasks 同步
《多核程序设计》PART 6:OpenMP 一种可移植的多线程解决方案(转载)
huainianjiangbei的专栏
06-01 723
<br />OpenMP中的任务循环调度和分块<br />对于内存利用比较好的情况下，对于负载平衡可能是不利的；同样，有利于负载平衡的策略也有可能对访存的性能不利。因此，在对性能优化时，必须在优化内存利用和优化负载平衡之间进行折中，通过对性能的测量找到能够得到最佳结果的方法。<br />在OpenMP for结构中，使用schedule子句将循环调度和分开信息传达给编译器和运行时库：<br />#pragma omp for schedule (kind [, chunk-size])<br />如果指定可
OpenMP中数据属性相关子句详解(2):shared/default/copyin/copyprivate子句的使用
。。。。
11-22 1万+
(1) shared shared子句可以用于声明一个或多个变量为共享变量。所谓的共享变量，是值在一个并行区域的team内的所有线程只拥有变量的一个内存地址，所有线程访问同一地址。所以，对于并行区域内的共享变量，需要考虑数据竞争条件，要防止竞争，需要增加对应的保护，这是程序员需要自行考虑的。 下面的例子是一个求和的并行实现，使用共享变量，由于没有采取保护，会有数据竞争： #define
斗地主AI算法解析
"斗地主AI算法的详细讲解文档" 斗地主AI算法是一种在计算机科学领域，特别是游戏人工智能中的一个重要研究课题。它涉及到人工智能、博弈论、概率论、搜索算法等多个方面的知识。斗地主是一种三人对战的扑克游戏，AI...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值