《计算机数学基础》精品课程
为了避免检测是否应插在R1的前面，在R1的前面设立记录R0，它既是中间变量，又是监视哨.设（R1，R2，…，Ri-1）是已排序的有序子文件，则插入Ri的步骤是：首先将Ri存放到Ro中，然后将Ko（即原Ri的关键字Ki）依次与Ki-1，Ki-2，…比较，若Ko&Kj（j=i-1，i-2，…，1），则Rj后移一个位置，否则停止比较和移动；最后，将Ro（即原来待插入的记录Ri）移到j+1的位置上.由于Ri的前面有监视哨Ro，因此不必每次判断下标j是否出界.算法描述如下：
insertsort(struct
node r[ n+1],int
/* r[n+1]为一维数组，其中r[0]为监视哨，r[1]到r[n]为待排序的n个记录，排序好的记录仍放在r中*/
{ for(i=2;i&=n;i++)&&&&&&&&&&&&
/*共进行n-1趟*/
{ r[0]=r[i];&&&&&&&&&&
/*r[0]为监视哨，也可做下边循环结束标志*/
while(r[j].key&r[0].key)
&&&&&&&&&&&&
{ r[j+1]=r[j];
&&&&&&&&&&&&&&
&&&&&&&&&&&&&
r[j+1]=r[0];
2、折半插入排序
在线性插入排序中，我们采用顺序查找法来确定记录的插入位置.由于（R1，R2，…，Ri-1）是有序子文件，我们可以采用折半查找法来确定R1的插入位置，这种排序称为折半插入排序.其算法可写出如下：
binarysort(struct
node r[ n+1],int
/*按关键字递增的次序对记录r[1],r[2],……,r[n]进行折半插入排序
{ for(i=2;i&=n;i++)
{ r[0]=r[i];
while(l&=h)
&&&&&&&&&&&
{ mid=(l+h)/2;
&&&&&&&&&&&&&
if(r[0].key&r[mid].key)
&&&&&&&&&&&&&
&&h=mid-1;
&&&&&&&&&&&&&
else l=mid+1;
&&&&&&&&&&&&
for(j=i-1;j&=l;j--)
&&&&&&&&&&
r[j+1]=r[j];
r[l]=r[0];
在上面的算法中，每插入一个R1，平均比较次数为log2i.
二、希尔排序
希尔排序（Shell’s
Method）又称“缩小增量排序”（Diminishing
Increment Sort），是由D.L.Shell在1959年提出来的.它的作法是：先取定一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组，所有距离为d1的倍数的记录放在同一个组中，在各组内进行直接插入排序；然后，到第二个增量d2&d1重复上述分组和排序，直至所取的增量dt=1（dt&dt-1&…&d2&d1），即所有记录放在同一组中进行直接插入排序为止.
先从一个具体的例子来看希尔排序.假设待排序文件有10个记录，其关键字分别是：49，38，65，97，76，13，27，49/，55，04.增量序列取值依次为：5，3，1.
第一趟排序时，d1=5，整个文件被分成5组：（R1，R6），（R2，R7），…，（R5，R10）各组中的第1个记录都自成一个有序区，我们依次将各组的第2个记录R6，R7，…R10分别插入到各组的有序区中，使文件的各组均是有序的.
第二趟排序时，d2=3，整个文件分成三组：（R1，R4，R7，R10），（R2，R5，R8），（R3，R6，R9），各组的第1个记录仍自成一个有序区，然后依次将各组的第2个记录R4，R5，R6分别插入到该组的当前有序区中，使得（R1，R4），（R2，R5），（R3，R6）均变为新的有序区，接着依次将各组的第3个记录R7，R8，R9分别插入到该组当前的有序区中，又使得（R1，R4，R7），（R2，R5，R8），（R3，R6，R9）均变为新的有序区，最后将R10插入到有序区（R1，R4，R7）中就得到第二趟排序结果.
最后一趟排序时，d3=1，即是对整个文件做直接插入排序，其结果即为有序文件.
若不设置监视哨，根据上例的分析不难写出希尔排序算法，请读者自行完成之.下面我们先分析如何设置监视哨，然后给出具体算法.设某一趟希尔排序的增量为h，则整个文件被分成h组：（R1，Rh+1，R2h+1，…），（R2，Rh+2，R2h+2，…），…（Rh，R2h，R3h，…），因为各组中记录之间的距离均为是h，故第1组至第h组的哨兵位置依次为1-h，2-h，…，0.如果象直接插入排序算法那样，将待插入记录Ri（h+1≤i≤N）
在查找插入位置之前保存到监视哨中，那么必须先计Ri属于哪一组，才能决定使用哪个监视哨来保存Ri.为了避免这种计算，我们可以将Ri保存到另一个辅肋记录X中，而将所有监视哨R1-h，R2-h，…，R0的关键字，设置为小于文件中的任何关键字即可.因为增量是变化的，所以，各趟排序中所需的监视哨数目也不相同，但是我们可以按最大增量d1来设置监视哨.
R[n+d1]；&&&&&&&&&&&&&&&&&&&&&&
/* R[d1-1]为d1个监视哨*/
d[t]；&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/* d[0]到d[t-1]为增量序列*/
SHELLSORT(R,d)
i，j，k，h；
maxint=32767；&&&&&&&&&&&&&&&&
/*机器中最大整数*/
&for (i=0；i&d[0]；i++)
R[i].key=-maxint；&&&&&&&&&&&&&&&&&&
/*设置哨兵*/
H=d[k]；&&&&&&&&&&&&&&&&&&&&
/*取本趟增量*/
For(i=h+di；i&n+d1；i++)&&&&
/*R[h+d1]到R[n+d1-1]插入当前有序区*/
{temp=R[i]}；&&&&&&&&&&&&&
/*保存待插入记录R[i]*/
&&&&&&&&&&
&&&&&&&&&&&
while(temp.key&R[j].key)&&
/*查找正确的插入位置*/
&&&&&&&&&&&
{R[j+h]=R[j]}；&&&&&&&&&&&&
/*后移记录*/
&&&&&&&&&&&&
j=j-h；&&&&&&&&&&&&&&&&&&&
/*得到前一记录位置*/
&&&&&&&&&&&&
&&&&&&&&&&&&
R[j+h]=temp；&&&&&&&&&&&&&
/*插入R[i]*/
&&&&&&&&&&&
}&&&&&&&&&&&&&&&&&&&&&&&&&&
/*本趟排序完成*/
&&&&&&&&&&
} while (h！=1)；&&&&&&&&&&&&&
/*增量为1排序后终止算法*/
}&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*SHELLSORT*/
读者可能看出，当增量h=1时，SHELLSORT算法与INSERTSORT基本一致.
为什么希尔排序的时间性能优于直接插入排序呢？我们知道直接插入排序在文件初态为正序时所需要时间最少，实际上，当文件初基本有序时直接插入排序所需的比较和移动次数均较少.另一面，当n值较小时，n和n2的差别也较小，即直接插入排序的最好时间复杂度O(n)和最坏时间复杂度O(n2)差别不大.在希尔排序时增量较大，分组较多，每组的记录数目少，故各组内直接插入较快，后来增量di逐渐缩小，分组数逐渐减少，而各组的记录数目逐渐增多，但由于已经按di-1作为距离排过序，使文件较近于有序状态，所以新的国趟排序过程也较快.因此，希尔排序在较率上较直接接入排序有较大的改进.
三、选择排序
选择排序（selection sort）也是一种简单排序法.一个记录最多只需进行一次交换就可以直接到达它的排序位置.
设待排序的文件为（R1，R2，…，Rn），进行选择排序的基本步骤如下：
（2）当i&n时，重复下列步骤；
1）当(Ri，…，Rn)中选出一个关键字最小的记录Rmin，若Rmin不是Ri，即Rmin≠i则交换Ri和Rmin的位置；否则，不进行交换.
2）i的值加1.
第1遍扫描时，在n个记录中为了选出最小关键字的记录，需要进行n-1次比较，第2扫描时，在余下的n-1记录中，再选出具有最小关键字的记录需要比较n-2次，……第n-1扫描时，在最后的2个记录中，比较1次选出最小关键字的记录.
四、堆排序
堆排序(heap sort)是在选择排序的基础上发展起来的.它比选择排序的效率要高.在堆排序中，把待排序的文件逻辑上看作是一棵顺序二叉树，并用到堆的概念.在介绍堆排序之前，先引入堆的概念.
当我们把顺序表示的文件(R1，R2，…，Rn)看作为顺序二叉树时，由顺序二叉树的性质可知：记录Ri(1&i≤n)的双亲是记录R[i
2]；R1的左孩子是记录R2i(2i≤n)，但若2i&n，则Ri的左孩子不存在；Ri的右孩子是记录R2i+1(2i+1≤n)，但若2i+1&n，则Ri的右孩子不存在.
什么是堆呢?堆是一个具有这样性质的顺序二叉树，每个非终端结点(记录)的关键字大于等于它的孩子结点的关键字.
显然，在一个堆中，根结点具有最大值(指关键字，下同)，而且堆中任何一个结点的非空左、右子树都是一个堆，它的根结点到任一叶子的每条路径上的结点都是递减有序的.
堆排序的基本思想是：首先把待排序的顺序表示(一维数组)的文件(R1，R2，…，Rn)在概念上看作一棵顺序二叉树，并将它转换成一个堆.这时，根结点具有最大值，删去根结点，然后将剩下的结点重新调整为一个堆.反复进行下去，直到只剩下一个结点为止.
堆排序的关键步骤是如何把一棵顺序二叉树调整为一个堆.初始状态时，结点是随机排列的，需要经过多次调整才能把它转换成一个堆，这个堆叫做初始堆.建成堆之后，交换根结点和堆的最后一个结点的位置，相当于删去了根结点.同时，剩下的结点(除原堆中的根结点)又构成一棵顺序二叉树.这时，根结点的左、右子树显然仍都是一个堆，它们的根结点具有最大值(除上面删去的原堆中的根结点).把这样一棵左、右子树均是堆的顺序二叉树调整为新堆，是很容易实现的.
由于堆的根结点应该是具有最大值的结点，且已知左、右子树是堆，因此，新堆的根结点应该是这棵二叉树的根结点，根结点的左孩子，根结点的右孩子(若存在的话)中最大的那个结点.于是，先找出根结点的左、右孩子，比较它们的大小.将其中较大的孩子再与根结点比较大小.如果这个孩子大于根结点，则将这个孩子上移到根结点的位置，而根结点下沉到这个孩子的位置，即交换它们的位置.
adjust(struct
node r[m+1],int
将文件(r[1],r[2],…,r[m])解释为一棵顺序二叉树,将其中以r[i]为根结点的二叉树调整
为一个堆,设以r[i]为根的二叉树的左,右子树已是堆,1≤i≤1[m/2]&
{ x=r[i];j=2*i;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*求出r[i]的左孩子r[2*i]，即r[j]
while (j&=m)&& /*有左孩子*/
{ if ((j&m) &&(r[j].key&r[j+1].key))&&&&&&
/*比较左、右孩子*/
&&&&&&&&&&&&
j=j+1; /*左孩子&右孩子*/
if (x.key&r[j].key)&&&&&&&&&&&&&&
/*比较根结点和它的大孩子*/
&&&&&&&&&&&&
{ r[i]=r[j];&&&&&&&&&&&&&&
/*大孩子上移到它的双亲位置*/
&&&&&&&&&&&&&
i=j;& /*今
r[j]为根结点*/
&&&&&&&&&&&&&
j=2*i;&&&&&&&&&&&&&&&
/*求出左孩子*/
&&&&&&&&&&&&&&
else& j=m+1&&&&&&&&&&&&&&
/*根不小于它的任一孩子时，强迫退出while循环*/
r[i]:=x;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
/*将存放在x中的根结点放到r[i]中*/
五、快速排序
快速排序(Quick Sort)称划分交换排序.其基本思想是：在当前无序区R[1]到R[h]到中任取一个记录作为比较的“基准”（不妨记为temp），用此基准将当前无序区划分为左右两个较小的无序子区：R[1]到R[i-1]和R[i+1]到R[h]，且左边的无序子区中记录的关键字均小于或等于基准temp的关键字，右边的无序子区中记录的关键字均大于或等于基准temp的关键字，而基准temp则位于最终排序的位置上
R[1]到R[i-1]中关键字≤temp.key=R[i+1]到R[h]的关键字（1≤i≤h）
当R[1]到R[I-1]和R[I+1]到R[h]均非空时，分别对它们进行上述的划分过程，直至所有无序子区中记录均已排好序为止.
要完成对当前无序区R[1]到R[h]的划分，具体做法是：设置两个指针i和j，它们的初值分别为i=1和j=h.不妨取基准为无序区的第1个记录R[i]（即R[1]），并将它保存在变量temp中.令j自h起向左扫描，直到找到第1个关键字小于temp.key的记录R[j]，将R[j]移至i所指的位置上（这相当于交换了R[j]和基准R[i]（即temp）的位置，使关键字小于基准关键字的记录移到了基准的左边）；然后，令i自i+1起向右扫描，直至找到第1个关键字大于temp.key的记录R[i]，将R[i]移至
j指的位置上（这相当于交换了R[j]和基准R[i]（即temp）的位置，使关键字大于基准关键字的记录移到了基准的右边）；接着，令j自j+1起向右扫描，如此交替改变扫描方向，从两端各自往中间靠拢，直至i=j时，i便是基准x的最终位置，将x放在此位置
上就完成了一次划分.
综合上面的叙述，下面分别给出一次划分及其排序的算法.
partition(r,1,h)&&&&&&&&&&&
/*返回划分后被定们的基准记录的位置*/
R[ ];&&&&&&&&&&&&&&
/*对无序区R[1]到R[h]做划分*/
i=1;j=h temp=R[i];&&&&&&&&&&
/*初始化，temp为基准*/
While((R[j].key&=temp.key)&
j--;&&&&&& /*从右向左扫描，查找第1个关键字小于temp.key的记录*/
if(i&j) R[i++]=R[j];&&&&&&&
/*交换R[i]和R[j]*/
while((R[i].key&=temp.key)
i++;&&&&&&
/*从左向左扫描，查找第1个关键字大于temp.key的记录*/
R[j--]=R[i];&&&&&&&
/*交换R[i]和R[j]*/
quicksort(R,s1,t1)&&&&&&&&&
/*对R[s1]到R[t1]*/
if (s1&t1)&&&&&&&&&&&&&&&
只有一个记录或无记录须排序*/
{i= partition
(R,s1,t1);&&&&&&&&
/*对R[s1]到R[t1]做划分*/
(R,s1,i-1);&&&&&&
/*递归处理左区间*/
(R,i+1,t1);&&&&&&
/*递归处理右区间*/
最坏情况是第次划分选取的基准都是当前无序区中关键字最小（或最大）的记录，划分的基准左边的无序子区为空（或右边的无序子区为空），而划分所得的另一个非空的无序子区中记录数目，仅仅比划分前的无序区中记录个数减少一个.因此，快速排序必须做n-1趟，每一趟中需进行n-i次比较，故总手工艺比数次数达到最大值：
(n-i)=n(n-1)/2=O(n2)
显然，如果按上面给出的划分算法，每次取当前无序区的第1个记录为基准，那么当文件的记录已按递增序（或递减序）排列时，每次划分所取的基准就是当前无序区中关键字最小（或最大）的记录，则快速排序所需的比较次数反而最多.
在最好情况下，每次划分所取的基准都是当前无序区的“中值”记录，划分的结果是基准的左、右两个无序子区的长度大致相等地.设C（n）表示对长度为n的文件进行快速排序所需的比较次数，显然，它应该等于对长度为n的无序区进行划分所需的比较次数n-1.加上递归地对划分所得的左、右两个无序子区（长度≤n/2）进行快速排序所需的比较总人数.
假设文件长度n=2k，那么总的比较次数为：
≤n+2C(n/2)
≤n+2[n/2+2C(n/22)]=2n+4C(n/22)
≤2n+4[n/4+2C(n/23)]=3n+8C(n/23)
≤kn+2kC(n/2k)=nlog2n+nC(1)
=O(nlog2n)
注意：式中C（1）为一常数，k=log2n.
因为快速排序的记录移动次数不大于比较的次数，所以，快速排序的最坏时间复杂度应为O（n2），最好时间复杂度O(log2n).为了改善最坏情况下的时间性能，可采用三者取中的规则，即在每一趟划分开始前，首先比较R[1].key，R[h].key和R[[(1+h)/2]].key，令三者中取中值的记录和R[1]交换之.
可以证明：快速排序的平均时间复杂度也是O(nlog2n)，它是目前基于比较的内部排序方法
中速度最快的，快速排序亦因此而得名.
快速排序需要一个栈空间来实现递归.若每次划分均能将文件均匀分割为两部分，则栈的最大深度为[log2n]+1，所需栈空间为O（log2n）.最坏情况下，递归深度为n，所需栈空间为O（n).
快速排序是不稳定的，请读者自行检验.
六、归并排序
归并排序(Merge Sort)是利用“归并”技术来进行排序，所谓归并是指将若干个已排序的子文件合并成一个有序的文件.简单的归并是将两个有序的子文件合并成一个有序的文件.假设R(low)到R[m]和R[m+1]到R[high]是存储在同一个数组中且相邻的两个有序的子文件，要将它们合并为一个有序文件R1[low]到R1[high]，只要设置三个指示器i，j和k，其初值分别是这三个记录区的起始位置.合并时依次比较R[i]和R[j]的关键字，取关键字较小的记录复制到R1[k]中，然后，将指向被复制记录的指示器加1和指向复制位置的指示器K加1，重复这一过程，直至全部记录被复制到R1[low]到R1[high]中为止.
排序（sorting）是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个按关键字有序的序列.本章主要介绍了排序的概念及其基本思想，排序过程和实现算法，简述了各种算法的时间复杂度和空间复杂度.一个好的排序算法所需要的比较次数和存储空间都应该较少，但从本章讨论的各种排序算法中可以看到，不存在“十全十美”的排序算法，各种方法各有优缺点，可适用于不同的场合.由于排序运算在计算机应用问题中经常碰到，读者应重点理解各种排序算法的基本思想，熟悉过程及实现算法，以及对算法的分析方法，从而面对实际问题时能选择合适的算法.排序算法汇总总结_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
27页免费35页免费24页免费16页免费7页免费 6页免费5页免费6页免费9页免费70页1下载券
喜欢此文档的还喜欢3页2下载券1页免费
排序算法汇总总结|排​序​算​法​汇​总​总​结
把文档贴到Blog、BBS或个人站等：
普通尺寸(450*500pix)
较大尺寸(630*500pix)
你可能喜欢一个计算机查找的问题，100分送上，有加分100_百度知道
一个计算机查找的问题，100分送上，有加分100
有1百万个非负的整数的数组，这些数不重复，也没有按照顺序排列储础稜摆溉肢防扮狮堡饯存在一个电脑文件里面，我想往里面存入一个非负的整数，问有什么方法能最快判定这个数不重复？
实际上就想当于在这些数里面加入一个不重复的数，怎么加。。我加入一个数，怎么判断它是否在这100万个数里面就是说一个原理就可以了，大概怎么做础稜摆溉肢防扮狮堡饯，不用实际的程序，我把200分都送上一个个的比当然可以问题是这样比较慢。。。有没有快的方法
提问者采纳
你的数都没排序，线性遍历已经是最快的了，如果发现有重复就不插入，遍历到底都没重复就插入。否则只有一种办法，第一次插入的时候先排序，然后再遵照排序的规则往里面插入你要插入的数（就是说你完成插入之后不能破坏了那种序），这就有础稜摆溉肢防扮狮堡饯很多算法了，比如你把所有的数按递增或递减排序，然后你的插入就可以按照二分法插入，这种插入的算法复杂度是log(n)，其中log以2为底，n是你的数组的元素个数。另外也可以选择建立一棵二叉搜索树，堆排序或者归并排序。但是这些方法都涉及到排序，复杂度也不小，但是一劳永逸的，你第一次完成了排序，后面就只需要插入新的数后仍然维持这个序就可以了，但是序的维护如果算法不当工作量也不会小，甚至还不如线性遍历。所以这个问题本身具有一定的灵活性和多样性。需要针对具体情况做出相应的选择。关于这些排序算法，很多书上都有，或者在网上搜一搜也能搜得到。不过有一点楼主要记住，排序，搜索，插入三者可以说是牵一发动全身的关系，而牵着这一发的正是排序。排序工作做好了，搜索和插入一般情形下相对没排序时效率都会有所提升。而且这三者经常相伴出现，所以不要只想到提高其中一个的效率，而应该同时兼顾三者，考察它们配合时的整体效率！
提问者评价
其他类似问题
按默认排序
其他13条回答
原先的想法是错误的。。刚要提交回答才想到这个想法有问题，原来的想法在下面，可以稍微看下。因为冒泡排序要进行比较的，如果进行比较还不如直接跟原数比较。。由于这些数没有排序。我个人认为要快速算法肯定是要执行遍历的，也就是一个个比较过去。。提高只能提高在快速得到比较结果上，也就是提高比较算法的速度。对比较算法的建议比较2个数字大小，如果是java有直接的比较算法，如果不是Java的话，比较方式应该多样点，先比较长度，然后比较个位，十位这样上去，如果础稜摆溉肢防扮狮堡饯一个不相同程序就可以返回继续执行，这个是个小建议。。/*下面是原先错误的想法*/我个人的想法是这个的编个程序，这个程序声明一个500长度的数组，每次从你的文件中读入500个数字，然后进行排序，如果是JAVA的话可以直接调用排序方法，其他语言可以使用冒泡之类的算法。排序后要查找就比较容易了，使用2分法相信你应该会吧。这样500个数组一次要执行2000次。最坏情况大概要一个小时吧，这个效率跟机子快慢有关系。。/*********************/
我的想法是先将原来的数据排好序.否则,只有线性遍历才能判断是否重复.而你插入的数并不只有一个.所以,最好先将原来的数排好序.排序的方法比较好的是将这一百万个数分成几块或十几块,分别用快速排序,最好用归并将这些小块合并起来.这样应该是比较快的了.
推荐使用二分查法,不推荐使用遍历查找,很慢折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。它的基本思想是，将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止。如果x&a[n/2]，则我们只要在数组a的左半部继续搜索x（这里假设数组元素呈升序排列）。如果x&a[n/2]，则我们只要在数组a的右半部继续搜索x。二分搜索法的应用极其广泛，而且它的思想易于理解，但是要写一个正确的二分搜索算法也不是一件简单的事。第一个二分搜索算法早在1946年就出现了，但是第一个完全正确的二分搜索算法直到1962年才出现。Bentley在他的著作《Writing Correct Programs》中写道，90%的计算机专家不能在2小时内写出完全正确的二分搜索算法。问题的关键在于准确地制定各次查找范围的边界以及终止条件的确定，正确地归纳奇偶数的各种情况，其实整理后可以发现它的具体算法是很直观的，我们可用C++描述如下： template&class Type& int BinarySearch(Type a[],const Type& x,int n) { int left=0; int right=n-1; while(left&=right){ int middle=(left+right)/2; if (x==a[middle]) if (x&a[middle]) left=middle+1; else right=middle-1; } return -1; } 模板函数BinarySearch在a[0]&=a[1]&=...&=a[n-1]共n个升序排列的元素中搜索x,找到x时返回其在数组中的位置，否则返回-1。容易看出，每执行一次while循环，待搜索数组的大小减少一半,因此整个算法在最坏情况下的时间复杂度为O(log n)。在数据量很大的时候，它的线性查找在时间复杂度上的优劣一目了然。
如果仅仅是这一次插入，那么就老老实实地遍历，遇到相同的则break。否则，排序是必不可少的，可以选择链表的插入排序方法。一次排序后，以后插入时用折半查找就能迅速地定位到是否与已有值重复，并且能将新值插入合适的位置。
在电脑上点”开始”－－”搜索”在”搜索结果”窗口左边”包含文字”对话框写上你要存入的那个非负整数点搜索，看结果有没有那个100万个非负的整数数组文件如果有就是重复了如果没有就表示没有重复
&储存在一个电脑文件里面，&,是什么类型的文件?你可以用你要插入的数去逐个与文件里的树相减,若结果为零则取消否则,则添加.
用指针，指针的移动来实现取到数组中的每一个元素来和输入的这个数相比较。如果相等说明重复；不相等则不重复。
一个个的比：时间复杂度 O(n/2)二分检索算法：时间复杂度 O(log2(n))
用C语言编辑一段程序不就可以了
你这100分也太难拿了,你在那文件夹里搜好了,例如搜一个0,如果有,那就搜一个别的数,直到搜不到为止,不就是不重复了?
能不能说的再具体些?
计算机的相关知识
您可能关注的推广
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁直接插入排序_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
2页免费4页1下载券19页1下载券2页1下载券1页免费 44页1下载券1页2下载券1页1下载券2页免费7页1下载券
喜欢此文档的还喜欢2页免费4页免费2页1下载券4页免费5页1下载券
直接插入排序|数​据​结​构​ ​直​接​插​入​排​序​ ​
​
​()​了​解​排​序​的​方​法​、​过​程​及​原​则​。​
​
​()​掌​握​插​入​排​序​的​算​法​思​想​。​
​
​()​掌​握​各​种​算​法​时​间​复​杂​度​的​分​析​算​法​。
把文档贴到Blog、BBS或个人站等：
普通尺寸(450*500pix)
较大尺寸(630*500pix)
你可能喜欢数据结构试题库集及答案_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
33页免费32页免费239页2下载券35页免费33页免费 77页1下载券99页1下载券17页免费99页2下载券10页免费
喜欢此文档的还喜欢40页1下载券100页1下载券21页1下载券33页免费55页免费
数据结构试题库集及答案|
把文档贴到Blog、BBS或个人站等：
普通尺寸(450*500pix)
较大尺寸(630*500pix)
你可能喜欢}