算法设计与分析——蛮力法

小熳芋

已于 2024-01-05 22:01:33 修改

阅读量1.4k

点赞数 26

文章标签：算法数据结构

于 2024-01-05 18:09:24 首次发布

本文链接：https://blog.csdn.net/m0_74164311/article/details/135406511

版权

前言

蛮力法感觉是在用最笨的方法解决问题，但是对一些问题不乏适用性。对于算法中的多种问题的求解我们大多时候还是会用其他算法技术，这里只是大概看看有哪些算法问题。

1.设计思想

蛮力法又叫枚举法或穷举法，基本技术是遍历，即按照某种策略依次处理待求解问题的所有元素，从而找出所有的元素。

2.查找问题中的蛮力法

2.1顺序查找

【问题】在查找集合中依次查找值为k的元素，若查找成功，则给出该元素在查找集合中的位置；若查找失败，则给出失败的信息。

【算法实现1】

int SeqSearch(int r[],int n,int k)
{
	int i=n-1;
	while(i>=0&&r[i]!=k)
		i--;
	return i;
 }

【算法分析1】

基本语句：i>0和r[i]!=k

执行次数：2×1/n×(1+n)×n/2=n+1=O(n)

【算法实现2】设置一个哨兵

int SeqSearch(int r[],int n,int k)
{
	r[0]=k; //设置哨兵
	int i=n;
	while(r[i]!=k)i--;
	return i;
 }

【算法分析2】

基本语句：r[i]!=k

执行次数：（n+1）/2=O(n)

2.2串匹配问题

【问题描述】给定两个字符串S和T，在主串S中查找子串T的过程称为串匹配，T称为模式。设主串S=“abcabcacb”,模式T=“abcac”

【算法实现】BF算法，即暴力算法

#include<iostream>
using namespace std;
int BF(char S[],char T[])
{
	int index=0;
	int n=0,m=0;
	while((S[n]!='\0') && (T[m]!='\0'))
		{
			if(S[n]==T[m])
			{
				n++;m++;
			}
			else
			{
				index++;n=index;m=0;	
			}
		}
	if(T[m]=='\0') return n+1;
	else return  0;
}
int main()
{
	char s[30];
	gets(s);
	char t[20];
	gets(t);
	cout<<BF(s,t);
}

【算法分析】假设在第i个位置匹配成功了，那么在前i-1趟中共比较了（i-1）×m次，第i趟比较了m次，所以总的比较了i×m次，时间复杂性是O（n×m）

【代码优化】KMP算法

首先计算模式串T的next数组，求解过程如下：

void GetNext(char T[],int next[])
{
	int i,j,len;
	next[0]=-1;
	for(i=1;T[i]!='\0';i++)
	{
		for(len=i-1;len>=1;len--)//相等子串的最大长度是j-1
		{
			for(j=0;j<len;j++)
			{
				if(T[j]!=T[i-len+j])break;//依次比较T[0]~T[len-1]和T[i-len]~T[i-1]
			}
			if(j==len)
			{
				next[i]=len;
				break;
			}
		}	
		if(len<1)next[i]=0;//没有相等的子串
	}
}

KMP算法：

int KMP(char S[],char T[])
{
	int i=0,j=0;
	int next[10]={-2};
	GetNext(T,next);
	while(S[i]!='\0'&& T[j]!='\0')
	{
		if(S[i]==T[j])
		{
			i++;
			j++;
		}
		else
		{
			j=next[j];
			if(j==-1)
			{
				i++;
				j++; 
			}
		}
	}
	if(T[j]=='\0')
	{
		return (i-strlen(T)+1);
	}
	else return 0;
}

主函数：

int main()
{
	cout<<"S:";
	char S[10];
	gets(S);
	cout<<"T:";
	char T[10];
	gets(T);
	cout<<KMP(S,T); 
}

【算法分析】在算出next数组后，KMP算法的时间复杂度是O（n）即把字符串T扫描了一下。而计算next值的时间代价最坏是O（ $_m{}^{3}$ ）

3.排序问题中的蛮力法

3.1选择排序

【问题描述】初始序列：49 27 65 76 38 13，按升序排序

【算法实现】

#include<iostream>
using namespace std;
void SelectSort(int a[],int n)
{
	int i,j,index,temp;
	for(i=0;i<n-1;i++)
	{
		index=i;
		for(j=i+1;j<n;j++)
		{
			if(a[j]<a[index])index=j; 
		}
		if(index!=i)
		{
			temp=a[i];a[i]=a[index];a[index]=temp;//不是a[i]=a[j]
		}
	}
	for(int i=0;i<n;i++)
	cout<<a[i]<<" ";
} 
int main()
{
	int a[6]={49,27,65,76,38,13};
	SelectSort(a,6);
	return 0; 
}

【算法分析】时间复杂性是O( $_n{}^{2}$ ）

3.2起泡排序

【问题描述】起泡排序的基本实现是两两比较，如果反序就交换，直到没有反序的记录为止

就像冒泡一样，起泡越来越大。

【算法实现】

#include<iostream>
using namespace std;
void Bubblesort(int a[],int n)
{
	int bound=0;
	int exchange=n-1;//第一趟起泡排序的区间[0,n-1] 
	int i,temp;
	while(exchange!=0)
	{
		bound=exchange;
		exchange=0;
		for(i=0;i<bound;i++)//一趟起泡排序的区间是[0,bound] 
		{
			if(a[i]>a[i+1])
			{
				temp=a[i];a[i]=a[i+1];a[i+1]=temp;
				exchange=i;	//计录每一次交换的位置 
			}
		}
	}
	for(i=0;i<n;i++)
	 cout<<a[i]<<" "; 
}
int main()
{
	int a[8]={50,13,55,97,27,38,49,65};
	Bubblesort(a,8);
 }

【算法分析】基本语句是a[i]>a[i+1],时间复杂度是O（ $_n{}^{2}$ ）