插入排序算法

⑴ 插入排序的算法复杂度

如果目标是把n个元素的序列升序排列，那么采用插入排序存在最好情况和最坏情况。最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需（n-1）次即可。最坏情况就是，序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。插入排序的赋值操作是比较操作的次数加上 (n-1）次。平均来说插入排序算法的时间复杂度为O(n^2）。因而，插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择。

⑵ 编写程序用直接插入排序的算法进行排序。

#include<stdio.h>
#include<time.h>
#include<math.h>
#include<malloc.h>

void BubbleSort(int *L,int N)
{ //冒泡
int i,j;
int t;

for(i=1;i<=N;i++)
{
for(j=N;j>i;j--)
if(L[j]<L[j-1])
{
t=L[j];
L[j]=L[j-1];
L[j-1]=t;
}
}
}

int SelectMinKey(int *L,int N,int n)
{
int i,min=n;

for(i=n+1;i<=N;i++)
if(L[i]<L[min])
min=i;

return min;
}

void SelectSort(int *L,int N)
{ //选择
int i,j;
int t;

for(i=1;i<N;i++)
{
j=SelectMinKey(L,N,i);
if(i!=j)
{
t=L[i];
L[i]=L[j];
L[j]=t;
}
}
}

void InsertSort(int *L,int N)
{ //插入
int i,j;

for(i=2;i<=N;i++)
{
if(L[i]<L[i-1])
{
L[0]=L[i];
L[i]=L[i-1];
for(j=i-2;L[0]<L[j];j--)
L[j+1]=L[j];
L[j+1]=L[0];
}
}
}

void ShellInsert(int *L,int N, int dk)
{ // 对顺序表L作一趟希尔插入排序。本算法对算法10.1作了以下修改：
// 1. 前后记录位置的增量是dk，而不是1；
// 2. r[0]只是暂存单元，不是哨兵。当j<=0时，插入位置已找到。
int i,j;
for(i=dk+1;i<=N;++i)
if(L[i]<L[i-dk])
{ // 需将L.r[i]插入有序增量子表
L[0]=L[i]; // 暂存在L.r[0]
for(j=i-dk;(j>0&&L[0]<L[j]);j-=dk)
L[j+dk]=L[j]; // 记录后移，查找插入位置
L[j+dk]=L[0]; // 插入
}
} // ShellInsert

void ShellSt(int *L,int N, int dlta[], int t)
{ // 算法10.5
// 按增量序列dlta[0..t-1]对顺序表L作希尔排序。
for(int k=0;k<t;++k)
ShellInsert(L,N, dlta[k]); // 一趟增量为dlta[k]的插入排序
} // ShellSort

void ShellSort(int *L,int N)
{ //希尔
int t=(int)log(N);
int k,*dlta;

dlta=(int*)malloc(t*4); //产生增量序列
for(k=0;k<t;k++)
dlta[k]=(int)pow(2,t-k)-1;

ShellSt(L,N,dlta,t);
}

int main()
{
int N=250;
int i,j,k;
int t;
int ti[16];
int *L;

srand(time(NULL));

printf("长度\t|冒泡\t|选择\t|插入\t|希尔\n");
printf("--------+-------------------------------------------------------------");
for(j=0;N<100000;j++)
{
L=(int *)malloc((N+1)*4);

t=0;

for(i=1;i<=N;i++)
L[i]=rand();
ti[t++]=clock();
BubbleSort(L,N);
ti[t++]=clock();

for(i=1;i<=N;i++)
L[i]=rand();
ti[t++]=clock();
SelectSort(L,N);
ti[t++]=clock();

for(i=1;i<=N;i++)
L[i]=rand();
ti[t++]=clock();
InsertSort(L,N);
ti[t++]=clock();

for(i=1;i<=N;i++)
L[i]=rand();
ti[t++]=clock();
ShellSort(L,N);
ti[t++]=clock();

printf("\n%d\t",N);
for(k=0;k<4;k++)
printf("| %d\t",(ti[2*k+1]-ti[2*k]));

N*=5;
}
printf("\n\n");
}

//这是我们当年学数据结构时我自己写的，给你改了一下，输出是对随机产生一些数，对四种算法进行比较，有问题可以hi我啊

⑶ 插入排序算法在最坏情况下最多的比较次数是

第i个数与前i-1个数继续比较，最坏一共比较i-1次。最后还会与最前面设置的哨兵比较一次，加上1。
所以第i个数比较i次。从i=2的位置开始求和。
最后结果是b

⑷ VB插入排序算法

Option Explicit

Private Sub Form_Load()
Dim i As Integer, intC As Integer
Dim IntOuSus() As String, strOuSus As String
Dim IntJiSus() As String, strJiSus As String

Randomize
For i = 1 To 30
intC = CInt(Rnd * 90) + 10
If intC Mod 2 = 1 Then
strJiSus = strJiSus & IIf(strJiSus = "", "", ",") & intC
Else
strOuSus = strOuSus & IIf(strOuSus = "", "", ",") & intC
End If
Next
IntOuSus = Split(strOuSus, ",")
IntJiSus = Split(strJiSus, ",")

OrderNumbers IntJiSus, "ASC"
OrderNumbers IntOuSus, "DESC"

End Sub

'注意以下过程中第一个参数使用了ByRef
'此方法比传统的冒泡法快得多
Private Sub OrderNumbers(ByRef a() As String, Optional ByVal ASCDESC As String = "ASC")
Dim min As Long, max As Long, num As Long, first As Long, last As Long, temp As Long, all As New Collection, steps As Long
ASCDESC = UCase(ASCDESC)
min = LBound(a)
max = UBound(a)
all.Add a(min)
steps = 1
For num = min + 1 To max
last = all.Count
If a(num) < CDbl(all(1)) Then all.Add a(num), BEFORE:=1: GoTo nextnum '加到第一项
If a(num) > CDbl(all(last)) Then all.Add a(num), AFTER:=last: GoTo nextnum '加到最后一项

first = 1
Do While last > first + 1 '利用DO循环减少循环次数
temp = (last + first) \ 2
If a(num) > CDbl(all(temp)) Then
first = temp
Else
last = temp
steps = steps + 1
End If
Loop
all.Add a(num), BEFORE:=last '加到指定的索引

nextnum:
steps = steps + 1
Next
For num = min To max
If ASCDESC = "ASC" Then a(num) = CDbl(all(num - min + 1)): steps = steps + 1 '升序
If ASCDESC = "DESC" Then a(num) = CDbl(all(max - num + 1)): steps = steps + 1 '降序
Next
'MsgBox "本数组共经过 " & steps & "步实现" & IIf(ASCDESC = "ASC", "升序", "降序") & "排序！", 64, "INFORMATION"
Set all = Nothing
End Sub

⑸ 插入排序法是什么

排序
排序(Sorting)的基本功能是依某种条件将资料项目按顺序排列,例如依照数字的大小由
小至大排列,或是按笔画顺序排列姓名 .
插入排序法 :
所谓插入排序法乃是将一个数目插入该占据的位置.假设我们输入的是
5,1,4,2,3
我们从第二个数字开始,这个数字是1,我们的任务只要看看1有没有正确的位置,我
们的做法是和这个数字左边的数字来比,因此我们比较1和5,1比5小,所以我们就交
换1和5,原来的排列就变成了
1,5,4,2,3
接下来,我们看第3个数字有没有在正确的位置.这个数字是4,它的左边数字是5,4
比5小,所以我们将4和5交换,排列变成了
1,4,5,2,3
我们必须继续看4有没有在正确的位置,4的左边是1,1比4小,4就维持不动了.
再来看第四个数字,这个数字是2,我们将2和它左边的数字相比,都比2大,所以就
将2一路往左移动,一直移到2的左边是1,这时候排序变成了
1,2,4,5,3
最后,我们检查第五个数字,这个数字是3,3必须往左移,一直移到3的左边是2为止,
所以我们的排列就变成了
1,2,3,4,5
排序因此完成了.
所谓插入排序法,就是检查第i个数字,如果在它的左边的数字比它大,进行交换,这
个动作一直继续下去,直到这个数字的左边数字比它还要小,就可以停止了.
插入排序法主要的回圈有两个变数:i和j,每一次执行这个回圈,就会将第i个数字放
到左边恰当的位置去.

时间复杂度： O(n的平方)

⑹ 插入排序的算法

排序算法在编程领域中起着举足轻重的作用，在目标检索、机器学习、数值计算、图像处理等领域有着广泛地应用。为了追本溯源，公众号特推出常用经典排序算法系列推文，让小伙伴们深入了解排序算法的实现原理，同时也提升matlab编程能力。
插入排序算法，它是将无序序列分成两部分，一部分为假设已经排列完成的序列，另一部分为余下序列，将余下序列中的元素取出插入到已排列完成的序列中，依次比较确定插入位置，下面就一起来看看该算的实现原理吧。
插入排序算法实现过程(以升序排列为例)：
对于长度为N的无序数组A，假定序列A(1)为排列完成的序列K，将A(2)与A(1)作比较，如果A(2)<A(1)，则两者交换，否则保持不变，即完成序列K的元素添加；将A(3)与A(2)比较，如果A(2)<A(3)，则保持不变，否则两者交换，继续将A(3)与A(1)比较，如果A(3)>A(1)，则两者交换，否则保持不变；以此类推，将余下序列中的元素取出插入到序列K中，从序列K尾部往首部进行比较，直至完成所有元素的插入。

matlab代码
主程序：main.m

format short;
clc;clear;
A = round(rand(1,8),2);
nA = InsertSort(A);
disp(['原始序列：',num2str(A)]);
disp(['插入排序：',num2str(nA)]);
插入排序函数：InsertSort.m

function A = InsertSort(A)
% 感谢关注：matlab爱好者
% 插入排序算法源代码
% 作者：matlab爱好者

len = length(A);
for w = 1:len-1
% 从余下序列中取出一个元素插入到新序列中
for v = w+1:-1:2
if(A(v)<A(v-1))
% 如果新元素小于所插入位置的元素，则交换
tmp = A(v-1);
A(v-1) = A(v);
A(v) = tmp;
else
% 否则保持位置不变
break;
end
end
end

⑺ C语言的插入排序法是什么

插入排序(insertion sort)

如果需要对一个小型数组进行升序排列，那么可以选用插入排序，插入排序可以用打牌时对摸起的牌根据牌的点数来对其进行插入排列来描述。

可以把左手中的牌比做已经摸起的牌，即已经被排列好的牌，左手可以容纳的牌数的空间可以假想为和要摸的牌的总数相同；而在桌子上的那部分没摸的牌则是未被排序的牌，这二者的关系可以抽象为数组中已经被排序好的部分和未被排序好的部分。

一开始摸起的第一张牌不需要排序，可以认定其为已排序的牌。

如果用外层循环for来表示摸起的牌的话，则可以抽象为：

// 对象数组

// 桌子上的牌

int A[] = {5,1,3,6,2,4};

// 从数组的第二个元素开始抽取

for(int i = 1; i < sizeof A/sizeof A[0]; ++i)

{

int pick = A[i]; // 被摸起的牌

int j = i - 1; // j记录已排序部分的最后一张牌的位置

. . .

}

而后摸起的排要根据排列策略和先前摸起的牌的点数的大小来确定其插入的合适位置，这里示范的排列策略是升序排列，摸起了这张牌后，便自右向左地和手中的牌进行比较。

把pick称作摸起的牌，如果pick比手中的牌小，则手中较大的那张牌就向右挪一位，pick再和下一张牌做比较，如果下一张牌仍然比pick大，那么那张牌便也向右移动一个位置，依此类推。

如果手中下一张和pick比较的牌比pick小，那么pick就被插入在了手中前一张牌移动后空下的位置；

或者手中所有的牌都比pick大，那么所有的牌就都向右移动过一个位置，所以pick最终被插入在了手中最左边的位置。

这个过程可以抽象为：

// 对象数组

// 桌子上的牌

int A[] = {5,1,3,6,2,4};

// 从数组的第二个元素开始抽取

for(int i = 1; i < sizeof A/sizeof A[0]; ++i)

{

int pick = A[i]; // 被摸起的牌

int j = i - 1; // j记录已排序部分的最后一张牌的位置

// 如果循环了j+1次，即j = -1时还未找到比pick小的牌

// 那么pick就是最小的牌被插入在位置A[0]处

// A[j]是当前手中和pick进行比较的牌

while(j >= 0 && A[j] > pick)

{

// 未找到可插入位置，则A[j]向后挪一位

A[j+1] = A[j];

// j减1继续向左定位手中下一张供和pick比较的牌--j;

}


// while结束后，j+1所表达的位置便是pick可以插入的位置

A[j+1] = pick;

}

// 对于有N个元素的数组A，采用插入排序法排序时，当外层循环进行了N-1次后排序完毕

⑻ java插入排序算法

import java.util.Arrays;
public class Insert {
public static void main(String[] args) {
int[] ary={8,3,7,1,9,4};
selectionSort(ary);
System.out.println(Arrays.toString(ary));
}
public static void selectionSort(int[] ary) {
int i,j,t;
for(i=1;i<ary.length;i++){
t=ary[i];
for(j=i-1;j>=0&&t<ary[j];j--){
ary[j+1]=ary[j];
}ary[j+1]=t;
}
}
}

插入算法的原理是当要被插入的数比数组中元素小就放在他的前面，加了一个中间变量t，把数组元素先放那存着。如果成功插入就把插入数据放到对应的数组位置。然后下一个继续先放在t里面存着。直到最后一个数