排序算法的复杂度
你这个问题是自己想出来的吧?
第一,你指的时间复杂度是大O表示法的复杂度,也就是一个上界,但不是上确界,所以就算你以一种方式中断排序过程,时间复杂度还是O(N*logN),假设排序过程还能执行的话。
第二,达到O(N*logN)的排序算法,以快速排序为例,快速排序不知道你看过没有,它不像选择排序或者冒泡排序那样,每一趟可以确定一直最大或者最小值,对于快速排序,每一趟排序后如果你删掉最后一个元素将导致整个算法失效。如果你要用这种删除元素方法的话,只能采用冒泡排序或者选择排序,时间复杂度是O(N^2)
所以,我猜想你是不是想做类似于在N个元素中寻找前K个最大者之类的事情(K=N-L)
如果是这样的话,有复杂度是O(N*logK)的算法,利用快速排序中的partition操作
经过partition后,pivot左边的序列sa都大于pivot右边的序列sb;
如果|sa|==K或者|sa|==K-1,则数组的前K个元素就是最大的前K个元素,算法终止;
如果|sa|<K-1,则从sb中寻找前K-|sa|-1大的元素;
如果|sa|>K,则从sa中寻找前K大的元素。
一次partition(arr,begin,end)操作的复杂度为end-begin,也就是O(N),最坏情况下一次partition操作只找到第1大的那个元素,则需要进行K次partition操作,总的复杂度为O(N*K)。平均情况下每次partition都把序列均分两半,需要logK次partition操作,总的复杂度为O(N*logK)。
由于K的上界是N,所以以N表示的总复杂度还是O(N*logN)
常见的几种排序算法复杂度如下:
方式: 平均 最坏 最好
插入 n^2 n^2 n
希尔 n^1.3 / /
冒泡 n^2 n^2 n
快速 nlogn n^2 nlogn
选择 n^2 n^2 n^2
堆排 nlogn nlogn nlogn
归并 nlogn nlogn nlogn
基数 d(n+r) d(n+r) d(n+r)
其中最好、最坏、平均三项复杂度全是一样的就是与初始排序无关的排序方法,也就是:
选择排序、堆排、归并、基数
由于程序比较简单,所以没有加什么注释。所有的程序都给出了完整的运行代码,并在我的VC环境
下运行通过。因为没有涉及MFC和WINDOWS的内容,所以在BORLAND C++的平台上应该也不会有什么
问题的。在代码的后面给出了运行过程示意,希望对理解有帮助。 这是最原始,也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡: #include<iostream>usingnamespacestd;voidBubbleSort(int*pData,intCount){intiTemp;for(inti=0;i<Count;i++){for(intj=Count-1;j>i;j--){if(pData[j]<pData[j-1]){iTemp=pData[j-1];pData[j-1]=pData[j];pData[j]=iTemp;}}}}voidmain(){intdata[7]={10,9,8,7,6,5,4};BubbleSort(data,7);for(inti=0;i<7;i++){cout<<data[i]<<;}cout<<endl;system(PAUSE);}倒序(最糟情况)
第一轮:10,9,8,7->10,9,7,8->10,7,9,8->7,10,9,8(交换3次)
第二轮:7,10,9,8->7,10,8,9->7,8,10,9(交换2次)
第一轮:7,8,10,9->7,8,9,10(交换1次)
循环次数:6次
交换次数:6次
其他:
第一轮:8,10,7,9->8,10,7,9->8,7,10,9->7,8,10,9(交换2次)
第二轮:7,8,10,9->7,8,9,10->7,8,10,9(交换1次)
(这是原撰写人的--7,8,10,9->7,8,10,9->7,8,10,9(交换0次),第二轮应该是这样的)
第三轮:7,8,9,10->7,8,9,10(交换1次)
循环次数:6次
交换次数:3次
上面我们给出了程序段,现在我们分析它:这里,影响我们算法性能的主要部分是循环和交换,
显然,次数越多,性能就越差。从上面的程序我们可以看出循环的次数是固定的,为1+2+...+n-1。
写成公式就是1/2*(n-1)*n。
现在注意,我们给出O方法的定义:
若存在一常量K和起点n0,使当n>=n0时,有f(n)<=K*g(n),则f(n) = O(g(n))。(呵呵,不要说没学好数学呀,对于编程数学是非常重要的!!!)
现在我们来看1/2*(n-1)*n,当K=1/2,n0=1,g(n)=n*n时,1/2*(n-1)*n<=1/2*n*n=K*g(n)。所以f(n)
=O(g(n))=O(n*n)。所以我们程序循环的复杂度为O(n*n)。
再看交换。从程序后面所跟的表可以看到,两种情况的循环相同,交换不同。其实交换本身同数据源的
有序程度有极大的关系,当数据处于倒序的情况时,交换次数同循环一样(每次循环判断都会交换),
复杂度为O(n*n)。当数据为正序,将不会有交换。复杂度为O(0)。乱序时处于中间状态。正是由于这样的
原因,我们通常都是通过循环次数来对比算法。 交换法的程序最清晰简单,每次用当前的元素一一的同其后的元素比较并交换。 #include<iostream.h>voidExchangeSort(int*pData,intCount){intiTemp;for(inti=0;i<Count-1;i++){//共(count-1)轮,每轮得到一个最小值for(intj=i+1;j<Count;j++){//每次从剩下的数字中寻找最小值,于当前最小值相比,如果小则交换if(pData[j]<pData[i]){iTemp=pData[i];pData[i]=pData[j];pData[j]=iTemp;}}}}voidmain(){intdata[]={10,9,8,7,6,5,4};ExchangeSort(data,sizeof(data)/sizeof(int));for(inti=0;i<sizeof(data)/sizeof(int);i++){cout<<data[i]<<;}cout<<endl;system(PAUSE);}第一轮: 9,10,8,7->8,10,9,7->7,10,9,8(交换3次)
第二轮:7,10,9,8->7,9,10,8->7,8,10,9(交换2次)
第一轮:7,8,10,9->7,8,9,10(交换1次)
循环次数:6次
交换次数:6次
其他:
第一轮:8,10,7,9->8,10,7,9->7,10,8,9->7,10,8,9(交换1次)
第二轮:7,10,8,9->7,8,10,9->7,8,10,9(交换1次)
第一轮:7,8,10,9->7,8,9,10(交换1次)
循环次数:6次
交换次数:3次
从运行的表格来看,交换几乎和冒泡一样糟。事实确实如此。循环次数和冒泡一样
也是1/2*(n-1)*n,所以算法的复杂度仍然是O(n*n)。由于我们无法给出所有的情况,所以
只能直接告诉大家他们在交换上面也是一样的糟糕(在某些情况下稍好,在某些情况下稍差)。 现在我们终于可以看到一点希望:选择法,这种方法提高了一点性能(某些情况下)
这种方法类似我们人为的排序习惯:从数据中选择最小的同第一个值交换,在从剩下的部分中
选择最小的与第二个交换,这样往复下去。 #include<iostream.h>voidSelectSort(int*pData,intCount){intiTemp;intiPos;for(inti=0;i<Count-1;i++){iTemp=pData[i];iPos=i;for(intj=i+1;j<Count;j++){if(pData[j]<iTemp){iTemp=pData[j];iPos=j;}}pData[iPos]=pData[i];pData[i]=iTemp;}}voidmain(){intdata[]={10,9,8,7,6,5,4};SelectSort(data,7);for(inti=0;i<7;i++)cout<<data[i]<<;cout<<
;}倒序(最糟情况)
第一轮:10,9,8,7->(iTemp=9)10,9,8,7->(iTemp=8)10,9,8,7->(iTemp=7)7,9,8,10(交换1次)
第二轮:7,9,8,10->7,9,8,10(iTemp=8)->(iTemp=8)7,8,9,10(交换1次)
第一轮:7,8,9,10->(iTemp=9)7,8,9,10(交换0次)
循环次数:6次
交换次数:2次
其他:
第一轮:8,10,7,9->(iTemp=8)8,10,7,9->(iTemp=7)8,10,7,9->(iTemp=7)7,10,8,9(交换1次)
第二轮:7,10,8,9->(iTemp=8)7,10,8,9->(iTemp=8)7,8,10,9(交换1次)
第一轮:7,8,10,9->(iTemp=9)7,8,9,10(交换1次)
循环次数:6次
交换次数:3次
遗憾的是算法需要的循环次数依然是1/2*(n-1)*n。所以算法复杂度为O(n*n)。
我们来看他的交换。由于每次外层循环只产生一次交换(只有一个最小值)。所以f(n)<=n
所以我们有f(n)=O(n)。所以,在数据较乱的时候,可以减少一定的交换次数。 插入法较为复杂,它的基本工作原理是抽出牌,在前面的牌中寻找相应的位置插入,然后继续下一张 #include<iostream.h>voidInsertSort(int*pData,intCount){intiTemp;intiPos;for(inti=1;i<Count;i++){iTemp=pData[i];//保存要插入的数iPos=i-1;//被插入的数组数字个数while((iPos>=0)&&(iTemp<pData[iPos])){//从最后一个(最大数字)开始对比,大于它的数字往后移位pData[iPos+1]=pData[iPos];iPos--;}pData[iPos+1]=iTemp;//插入数字的位置}}voidmain(){intdata[]={10,9,8,7,6,5,4};InsertSort(data,7);for(inti=0;i<7;i++)cout<<data<<;cout<<
;}其他:
第一轮:8,10,7,9->8,10,7,9(交换0次)(循环1次)
第二轮:9,10,8,7->8,9,10,7(交换1次)(循环2次)
第一轮:8,9,10,7->7,8,9,10(交换1次)(循环3次)
循环次数:6次
交换次数:3次
其他:
第一轮:8,10,7,9->8,10,7,9(交换0次)(循环1次)
第二轮:8,10,7,9->7,8,10,9(交换1次)(循环2次)
第一轮:7,8,10,9->7,8,9,10(交换1次)(循环1次)
循环次数:4次
交换次数:2次
上面结尾的行为分析事实上造成了一种假象,让我们认为这种算法是简单算法中最好的,其实不是,
因为其循环次数虽然并不固定,我们仍可以使用O方法。从上面的结果可以看出,循环的次数f(n)<=
1/2*n*(n-1)<=1/2*n*n。所以其复杂度仍为O(n*n)(这里说明一下,其实如果不是为了展示这些简单
排序的不同,交换次数仍然可以这样推导)。现在看交换,从外观上看,交换次数是O(n)(推导类似
选择法),但我们每次要进行与内层循环相同次数的‘=’操作。正常的一次交换我们需要三次‘=’
而这里显然多了一些,所以我们浪费了时间。
最终,我个人认为,在简单排序算法中,选择法是最好的。 高级排序算法中我们将只介绍这一种,同时也是目前我所知道(我看过的资料中)的最快的。
它的工作看起来仍然象一个二叉树。首先我们选择一个中间值middle程序中我们使用数组中间值,然后
把比它小的放在左边,大的放在右边(具体的实现是从两边找,找到一对后交换)。然后对两边分别使
用这个过程(最容易的方法——递归)。
1.快速排序://这段代码编译可以通过,一运行就出错,内部的细节有些问题,我还没找到解决方法。 #include<iostream.h>voidrun(int*pData,intleft,intright){inti,j;intmiddle,iTemp;i=left;j=right;middle=pData[left];do{while((pData[i]<middle)&&(i<right))//从左扫描大于中值的数i++;while((pData[j]>middle)&&(j>left))//从右扫描大于中值的数j--;if(i<=j)//找到了一对值{//交换iTemp=pData[i];pData[i]=pData[j];pData[j]=iTemp;i++;j--;}}while(i<=j);//如果两边扫描的下标交错,就停止(完成一次)//当左边部分有值(left<j),递归左半边if(left<j)run(pData,left,j);//当右边部分有值(right>i),递归右半边if(right>i)run(pData,i,right);}voidQuickSort(int*pData,intCount){run(pData,0,Count-1);}voidmain(){intdata[]={10,9,8,7,6,5,4};QuickSort(data,7);for(inti=0;i<7;i++)cout<<data[i]<<;//原作者此处代码有误,输出因为date[i],date数组名输出的是地址cout<<
;}这里我没有给出行为的分析,因为这个很简单,我们直接来分析算法:首先我们考虑最理想的情况
1.数组的大小是2的幂,这样分下去始终可以被2整除。假设为2的k次方,即k=log2(n)。
2.每次我们选择的值刚好是中间值,这样,数组才可以被等分。
第一层递归,循环n次,第二层循环2*(n/2)......
所以共有n+2(n/2)+4(n/4)+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n
所以算法复杂度为O(log2(n)*n)
其他的情况只会比这种情况差,最差的情况是每次选择到的middle都是最小值或最大值,那么他将变
成交换法(由于使用了递归,情况更糟)。但是你认为这种情况发生的几率有多大??呵呵,你完全
不必担心这个问题。实践证明,大多数的情况,快速排序总是最好的。
如果你担心这个问题,你可以使用堆排序,这是一种不稳定的O(log2(n)*n)算法,但是通常情况下速度要慢
于快速排序(因为要重组堆)。 双向冒泡
通常的冒泡是单向的,而这里是双向的,也就是说还要进行反向的工作。 #include<iostream.h>inlinevoidexchange(int*a,int*b){inttemp;temp=*a;*a=*b;*b=temp;}voidbubblesort(int*array,intnum){inti,j,k,flag=0;for(i=0;i<num;i++){printf(%d,array[i]);}printf(
);for(i=0;i<num;i++){//所有数的个数为num个flag=0;for(j=i;j<num-i-1;j++){//每循环一次最底端的数的顺序都会排好,所以初始时j=i;if(array[j]>array[j+1]){exchange(&array[j],&array[j+1]);flag=1;}}for(k=num-1-i-1;k>i;k--){//每循环一次最顶端的数据的顺序也会排好,所以初始时k=num-i-2if(array[k]<array[k-1]){exchange(&array[k],&array[k-1]);flag=1;}}if(flag==0){//如果flag未发生改变则说明未发生数据交换,则排序完成return;}}}voidmain(){intdata[]={10,9,8,7,6,5,4,3,2,1,-10,-1};bubblesort(data,12);for(inti=0;i<12;i++)cout<<data<<;cout<<
;} 这个程序我想就没有分析的必要了,大家看一下就可以了。不明白可以在论坛上问。
MyData.h文件
///////////////////////////////////////////////////////
class CMyData
{
public:
CMyData(int Index,char* strData);
CMyData();
virtual ~CMyData();
int m_iIndex;
int GetDataSize(){ return m_iDataSize; };
const char* GetData(){ return m_strDatamember; };
//这里重载了操作符:
CMyData& operator =(CMyData &SrcData);
bool operator <(CMyData& data );
bool operator >(CMyData& data );
private:
char* m_strDatamember;
int m_iDataSize;
};
////////////////////////////////////////////////////////
MyData.cpp文件
////////////////////////////////////////////////////////
CMyData::CMyData():
m_iIndex(0),
m_iDataSize(0),
m_strDatamember(NULL)
{
}
CMyData::~CMyData()
{
if(m_strDatamember != NULL)
delete[] m_strDatamember;
m_strDatamember = NULL;
}
CMyData::CMyData(int Index,char* strData):
m_iIndex(Index),
m_iDataSize(0),
m_strDatamember(NULL)
{
m_iDataSize = strlen(strData);
m_strDatamember = new char[m_iDataSize+1];
strcpy(m_strDatamember,strData);
}
CMyData& CMyData::operator =(CMyData &SrcData)
{
m_iIndex = SrcData.m_iIndex;
m_iDataSize = SrcData.GetDataSize();
m_strDatamember = new char[m_iDataSize+1];
strcpy(m_strDatamember,SrcData.GetData());
return *this;
}
bool CMyData::operator <(CMyData& data )
{
return m_iIndex<data.m_iIndex;
}
bool CMyData::operator >(CMyData& data )
{
return m_iIndex>data.m_iIndex;
}
///////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//主程序部分
#include <iostream.h>
#include MyData.h
template <class T>
void run(T* pData,int left,int right)
{
int i,j;
T middle,iTemp;
i = left;
j = right;
//下面的比较都调用我们重载的操作符函数
middle = pData[(left+right)/2]; //求中间值
do{
while((pData<middle) && (i<right))//从左扫描大于中值的数
i++;
while((pData[j]>middle) && (j>left))//从右扫描大于中值的数
j--;
if(i<=j)//找到了一对值
{
//交换
iTemp = pData;
pData = pData[j];
pData[j] = iTemp;
i++;
j--;
}
}while(i<=j);//如果两边扫描的下标交错,就停止(完成一次)
//当左边部分有值(left<j),递归左半边
if(left<j)
run(pData,left,j);
//当右边部分有值(right>i),递归右半边
if(right>i)
run(pData,i,right);
}
template <class T>
void QuickSort(T* pData,int Count)
{
run(pData,0,Count-1);
}
void main()
{
CMyData data[] = {
CMyData(8,xulion),
CMyData(7,sanzoo),
CMyData(6,wangjun),
CMyData(5,VCKBASE),
CMyData(4,jacky2000),
CMyData(3,cwally),
CMyData(2,VCUSER),
CMyData(1,isdong)
};
QuickSort(data,8);
for (int i=0;i<8;i++)
cout<<data.m_iIndex<< <<data.GetData()<<
;
cout<<
;
快速排序的算法复杂度分析
原文地址:快速排序的算法复杂度分析 以下是快排的java算法:大家都知道快排的时间复杂度是O(n*ln[n]),那么这个复杂度是如何计算出来的呢?最好的情况下,每次划分对一个记录定位后,要记录的左侧子序列与右侧子序列的长度相同。在具有n个记录的序列中,一次划分需要对整个待划分序列扫描一遍,所需的...
快速排序算法在平均情况下的时间复杂度为 求详解
时间复杂度为O(nlogn) n为元素个数 1. 快速排序的三个步骤:1.1. 找到序列中用于划分序列的元素 1.2. 用元素划分序列 1.3. 对划分后的两个序列重复1,2两个步骤指导序列无法再划分 所以对于n个元素其排序时间为 T(n) = 2*T(n\/2) + n (表示将长度为n的序列划分为两个子序列,每个子...
归并排序的最好时间复杂度
归并排序的最好时间复杂度是O(nlog)。1、归并排序的最优时间复杂度为O(n),最差时间复杂度为O(nlogn),平均时间复杂度为O(nlogn)。归并排序的空间复杂度为O(n)。归并排序的时间复杂度为Onlogn,相比于其他排序算法如冒泡排序、插入排序等,它在处理大规模数据时更加高效。2、归并排序是...
希尔排序的复杂度是多少?
希尔排序时间复杂度是 O(n^(1.3-2)),空间复杂度为常数阶 O(1)。希尔排序没有时间复杂度为 O(n(logn)) 的快速排序算法快 ,因此对中等大小规模表现良好,但对规模非常大的数据排序不是最优选择,总之比一般 O(n^2 ) 复杂度的算法快得多。希尔排序(Shell Sort)是插入排序的一种,它是针对直接插入排序算法...
八大经典排序算法原理及实现
我们发现第一次外层循环之后就排序成功了,但是还是会继续循环下去,造成了不必要的时间复杂度,怎么优化?冒泡排序都是相邻元素的比较,当相邻元素相等时并不会交换,因此冒泡排序算法是稳定性算法 插入排序是对冒泡排序的一种改进 插入排序的思想是数组是部分有序的,再将无序的部分插入有序的部分中去,...
归并排序平均时间复杂度
归并排序是一种有效的排序算法,其平均时间复杂度为O(nlogn),其有关知识如下:1、归并排序的核心思想是将待排序的数组切分为若干个子数组,对每个子数组进行排序,然后将已排序的子数组合并成一个有序的数组。这个过程可以递归地进行,直到整个数组变得有序。因此,归并排序的时间复杂度取决于递归的...
基于比较的排序算法
5、归并排序 归并排序是一种分治算法,它将待排序的元素每次分成两个子组,对每个子组进行排序,直至子组的元素个数为1。然后将排好序的子组合并成一个有序的数组。归并排序的时间复杂度为O(n log n)。6、快速排序 快速排序也是一种分治算法,它选择一个基准元素,将待排序的元素分为小于基准...
以下哪个排序算法的最坏时间复杂度是O(nlogn)?
快速排序 O(n log n)堆排序 O(n log n)归并排序 O(n log n)基数排序 O(n)希尔排序 O(n^1.25)有一个时间复杂度的排列顺序,依次为 Ο(1)<Ο(log2n)<Ο(n)<Ο(nlog2n)<Ο(n2)<Ο(n3)<…<Ο(2n)<Ο(n!)Ο(1)表示基本语句的执行次数是一个常数,一般来说,只要算...
快速排序方法的时间复杂度为O(n^2)=n(n-1)\/2中O()是什么意思?
O(n): 表示该算法是线性算法 O(㏒2n): 二分查找算法 O(n2): 对数组进行排序的各种简单算法,例如直接插入排序的算法。O(n3): 做两个n阶矩阵的乘法运算 O(2n): 求具有n个元素集合的所有子集的算法 O(n!): 求具有N个元素的全排列的算法 O(n²)表示当n很大的时候,复杂度约等于Cn...
对于输入为N个数进行快速排序算法的平均时间复杂度是多少?
则选择中位数的总复杂度为:T(n) = O(n) + T(n\/5) + T(3n\/4) 有T(n) = O(n)。因此快速排序的复杂度为T(n) = 2T(n\/2) + O(n) 有:T(n) = nlogn。但最坏情况下复杂度为O(n^2),出现此条件的情况是N个数原来就已经按照规定要求排好序了。
周钩吲哚: 选择排序抄算法复杂度是O(n^2). 插入排序是O(n^2) 快速排序快速排序是不稳2113定的.5261最理想情况算法时间复杂度O(nlog2n),最坏4102O(n^2). 堆排序算法时间复杂度O(nlogn). 归并1653排序的时间复杂度是O(nlog2n).
闻喜县19793305941: 冒泡排序时间复杂度冒泡排序最好的时间复杂度为 - ________,平均时间复杂度为 - _______ -- ?
周钩吲哚:[答案] 冒泡排序的最坏时间复杂度为O(n2). 算法的平均时间复杂度为O(n2) .冒泡排序最好的时间复杂度为O(n).
闻喜县19793305941: 请问一下:有谁能总结数据结构中排序章内介绍各种算法的时间复杂度呀,很急... - ?
周钩吲哚: 1.插入排序:每次将一个待排的记录插入到前面的已经排好的队列中的适当位置.①.直接插入排序 直接排序法在最好情况下(待排序列已按关键码有序),每趟排序只需作1次比较而不需要移动元素.所以n个元素比较次数为n-1,移动次数0....
闻喜县19793305941: 求各种查找和排序的时间复杂度 - ?
周钩吲哚: 冒泡排序是稳定的,算法时间复杂度是O(n ^2). 2.2 选择排序(Selection Sort) 选择排序的基本思想是对待排序的记录序列进行n-1遍的处理,第i遍处理是将L[i..n]中最小者与L[i]交换位置.这样,经过i遍处理之后,前i个记录的位置已经是正确...
闻喜县19793305941: 对于输入为N个数进行快速排序算法的平均时间复杂度是多少? - ?
周钩吲哚: 根据T(n) = T(ðn) + O(n) (0 < ð <1) 则有 T(n) = O(n) 因此关键问题是怎样解决划分标准的问题, 因此产生下列线性时间找中位数的算法: 将数组a有n个元素, 划分成5个一组, 则共有[n/5]个元素, 对于每组用一般的排序找中位数,需要25次, ...
闻喜县19793305941: 快速排序时间复杂度怎样推算的 - ?
周钩吲哚: 快速排序是基于二分的,所以在理想情况下它的时间复杂度为O(NLOG2N),极端情况下(数据恰好逆序)则相当于选择排序,复杂度退化为O(N^2);
闻喜县19793305941: 常用的排序算法特点和逻辑数据模型特点 - ?
周钩吲哚: 常用的排序算法有插入排序,希尔排序,冒泡排序,快速排序,归并排序,堆排序还有基数排序.排序算法一般考虑的就是两个方面,即时间复杂度和空间复杂度.其中插入排序,冒泡排序是简单排序,排序的平均时间复杂度是O(n^2), 最坏的...
闻喜县19793305941: 排序算法的分类 - ?
周钩吲哚: 排序(Sorting) 是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或记录)的任意序列,重新排列成一个关键字有序的序列.稳定度(稳定性) 一个排序算法是稳定的,就是当有两个相等记录的关键字R和S,且在原本的列表...
闻喜县19793305941: 快速排序方法的时间复杂度为O(n^2)=n(n - 1)/2中O()是什么意思? - ?
周钩吲哚: 1)对于你的问题简单解释如下: 理论计算机研究中,衡量算法一般从两个方面分析:时间复杂度和空间复杂度.空间复杂度跟时间复杂度是类似的,下面简单解释一下时间复杂度:对于一个数据规模为n的问题,解决该问题的算法所用时间可以用...
闻喜县19793305941: 怎么估算c语言冒泡排序法的时间复杂度 - ?
周钩吲哚: 冒泡排序的算法时间复杂度上O(n^2 )冒泡排序是这样实现的:首先将所有待排序的数字放入工作列表中.从列表的第一个数字到倒数第二个数字,逐个检查:若某一位上的数字大于他的下一位,则将它与它的下一位交换.重复2号步骤,直至再也不能交换.冒泡排序的平均时间复杂度与插入排序相同,也是平方级的,但也是非常容易实现的算法.选择排序选择排序是这样实现的:设数组内存放了n个待排数字,数组下标从1开始,到n结束.i=1从数组的第i个元素开始到第n个元素,寻找最小的元素.将上一步找到的最小元素和第i位元素交换.如果i=n-1算法结束,否则回到第3步选择排序的平均时间复杂度也是O(n^2)的.