没有合适的资源?快使用搜索试试~ 我知道了~
数据结构算法大全有代码.pdf
1.该资源内容由用户上传,如若侵权请联系客服进行举报
2.虚拟产品一经售出概不退款(资源遇到问题,请及时私信上传者)
2.虚拟产品一经售出概不退款(资源遇到问题,请及时私信上传者)
版权申诉
18 浏览量
2022-07-14
08:20:51
上传
评论
收藏 846KB PDF 举报
数据结构算法大全有代码.pdf数据结构算法大全有代码.pdf数据结构算法大全有代码.pdf数据结构算法大全有代码.pdf数据结构算法大全有代码.pdf数据结构算法大全有代码.pdf
资源推荐
资源详情
资源评论













排序算法有:插入排序,合并排序,冒泡排序,选择排序,希尔排序,堆排序,快速排序,
计数排序,基数排序,桶排序(没有实现)。比较一下学习后的心得。
我不是很清楚他们的时间复杂度,也真的不知道他们到底谁快谁慢,因为书上的推导我确实
只是小小了解,并没有消化。也没有完全理解他们的精髓,所以又什么错误的还需要高手指
点。呵呵。
1.普及一下排序稳定,所谓排序稳定就是指:如果两个数相同,对他们进行的排序结果为他
们的相对顺序不变。例如 A={1,2,1,2,1}这里排序之后是 A = {1,1,1,2,2} 稳定就是排序后第一个
1 就是排序前的第一个 1,第二个 1 就是排序前第二个 1,第三个 1 就是排序前的第三个 1。
同理 2 也是一样。这里用颜色标明了。不稳定呢就是他们的顺序不应和开始顺序一致。也就
是可能会是 A={1,1,1,2,2}这样的结果。
2.普及一下原地排序:原地排序就是指不申请多余的空间来进行的排序,就是在原来的排序
数据中比较和交换的排序。例如快速排序,堆排序等都是原地排序,合并排序,计数排序等
不是原地排序。
3.感觉谁最好,在我的印象中快速排序是最好的,时间复杂度: n*log(n),不稳定排序。原
地排序。他的名字很棒,快速嘛。当然快了。我觉得他的思想很不错,分治,而且还是原地
排序,省去和很多的空间浪费。速度也是很快的,n*log(n)。但是有一个软肋就是如果已经
是排好的情况下时间复杂度就是 n*n,不过在加入随机的情况下这种情况也得以好转,而且他
可以做任意的比较,只要你能给出两个元素的大小关系就可以了。适用范围广,速度快。
4.插入排序:n*n 的时间复杂度,稳定排序,原地排序。插入排序是我学的第一个排序,速
度还是很快的,特别是在数组已排好了之后,用它的思想来插入一个数据,效率是很高的。
因为不用全部排。他的数据交换也很少,只是数据后移,然后放入要插入的数据。(这里不
是指调用插入排序,而是用它的思想)。我觉得,在数据大部分都排好了,用插入排序会给
你带来很大的方便。数据的移动和交换都很少。
插入排序主要思想是:把要排序的数字插入到已经排好的数据中。(我自己理
解的哈)。例如 12356 是已经排好的序,我们将 4 插入到他们中,时插入之后也是排好序的。
这里显而易见是插入到 3 的后面。变为 123456.
实现思路:插入排序就是先是一个有序的数据,然后把要插入的数据插到指定的位置,而排
序首先给的就是无序的,我们怎么确定先得到一个有序的数据呢?答案就是:如果只有一个,
当然是有序的咯。我们先拿一个出来,他是有序的,然后把数据一个一个插入到其中,那么
插入之后是有序的,所以直到最后都是有序的。。哈哈。结果就出来了!
当然在写的时候还是有一个技巧的,不需要开额外的数组,下标从第二个元素开始遍历直到
最后一个,然后插入到前面已经有序的数据中。这样就不会浪费空间了。插入排序用处还是
很多的,特别是链表中,因为链表是指针存放的,没有数组那么好准确的用下标表示,插入
是简单有效的方法。嘻嘻。。废话少说,
源代码奉上:
1 #include <stdio.h>
2 #include <stdlib.h>
3
4 //插入排序从小到大,nData 为要排序的数据,nNum 为数据的个数,该排序是稳定的排序
5 bool InsertionSort(int nData[], int nNum)
6 {
7 for (int i = 1; i < nNum; ++i) //遍历数组,进行插入排序
8 {
9 int nTemp = nData[i];

10 for (int j = 0; j < i; ++j) //对该数,寻找他要插入的位置
11 {
12 if (nData[j] > nTemp) //找到位置,然后插入该位置,之后的数据后移
13 {
14 for (int k = i; k > j; --k) //数据后移
15 {
16 nData[k] = nData[k -1];
17 }
18 nData[j] = nTemp; //将数据插入到指定位置
19 break;
20 }
21 }
22 }
23
24 return true;
25 }
26
27 int main()
28 {
29 int nData[10] = {4,10,9,8,7,6,5,4,3,2}; //创建 10 个数据,测试
30 InsertionSort(nData, 10); //调用插入排序
31
32 for (int i = 0; i < 10; ++i)
33 {
34 printf("%d ", nData[i]);
35 }
36
37 printf("\n");
38 system("puase");
39 return 0;
40 }
5.冒泡排序,n*n 的时间复杂度,稳定排序,原地排序。冒泡排序的思想很不错,一个一个
比较,把小的上移,依次确定当前最小元素。因为他简单,稳定排序,而且好实现,所以用
处也是比较多的。还有一点就是加上哨兵之后他可以提前退出。
冒泡排序的主要思路:我们把要排序的数组A = {3,4,2,1} 看成一组水泡,就像冒泡一样,轻
的在上面,重的在下面,换成数据,就是小的在上面,大的在下面。 我们先把最轻的冒出
到顶端,然后冒出第二轻的在最轻的下面,接着冒出第三轻的。依次内推。直到所有都冒出
来了为止。
我们怎么做到把最轻的放在顶端呢?我们从最底下的数据开始冒,如果比他上面的数据小,
就交换(冒上去),然后再用第二第下的数据比较(此时他已经是较轻的一个),如果他比他
上面的小,则交换,把小的冒上去。直到比到第一位置,得到的就是最轻的数据咯,这个过
程就像是冒泡一样,下面的和上面的比较,小的冒上去。大的沉下来。呵呵。
画个图先:

最初
3
4
2
1
第一次结果
3
4
1
2
第二次结果
3
1
4
2
第三次结果
1
3
4
2
开始:1 和 2 比,1 比 2 小,浮上,然后1 跟 4 比,再 1 跟 3 比,这样结构就变为1,3,4,
2。最小的位置确定了,然后我们确定第二小的,同理2 vs 4, 2 vs 3 得到 2, 再确定第 3 小
数据,3 vs 4 得到 3,最后就是 4 为最大的数据,我们冒泡就排好了。
注:这里红色的 1,2 是前一次比较 1 vs 2 交换的结构。后面也一样。
大概思路就这样了,奉上源代码:
#include <stdio.h>
#include <stdlib.h>
//冒泡排序, pnData 要排序的数据, nLen 数据的个数
int BubbleSort(int* pnData, int nLen)
{
bool isOk = false; //设置排序是否结束的哨兵
//i 从[0,nLen-1)开始冒泡,确定第 i 个元素
for (int i = 0; i < nLen - 1 && !isOk; ++i)
{
isOk = true; //假定排序成功
//从[nLen - 1, i)检查是否比上面一个小,把小的冒泡浮上去
for (int j = nLen- 1; j > i; --j)
{
if (pnData[j] < pnData[j - 1]) //如果下面的比上面小,交换
{
int nTemp = pnData[j];
pnData[j] = pnData[j - 1];
pnData[j - 1] = nTemp;
isOk = false;
}
}
}
return 1;
}
int main()
{
int nData[10] = {4,10,9,8,7,6,5,4,3,2}; //创建 10 个数据,测试
BubbleSort(nData, 10); //调用冒泡排序

for (int i = 0; i < 10; ++i)
{
printf("%d ", nData[i]);
}
printf("\n");
system("pause");
return 0;
}
我这里用了一个哨兵做标记,就是如果在已经是排好序的情况下我们能检测出来并退出。
随便说一下,冒泡排序是稳定的排序。
6.选择排序,n*n 的时间复杂度, 稳定排序,原地排序。选择排序就是冒泡的基本思想,
从小的定位,一个一个选择,直到选择结束。他和插入排序是一个相反的过程,插入是确定
一个元素的位置,而选择是确定这个位置的元素。他的好处就是每次只选择确定的元素,不
会对很多数据进行交换。所以在数据交换量上应该比冒泡小。
选择排序和冒泡排序思路上有一点相似,都是先确定最小元素,再确定第二笑元素,最后确
定最大元素。他的主要流程如下:
1.加入一个数组 A = {5,3,6,2,4,7},我们对他进行排序
2.确定最小的元素放在 A[0]位置,我们怎么确定呢,首先默认最小元素为 5,他的索引为 0,
然后用它跟 3 比较,比他打,则认为最小元素为3,他的索引为 1,然后用 3 跟 6 比,发现比
他小,最小元素还是 3,然后跟 2 比,最小元素变成了 2,索引为 3,然后跟 4 比,跟 7 比。
当比较结束之后,最小元素也尘埃落定了。就是 2,索引为 3,然后我们把他放在 A[0]处。
为了使 A[0]原有数据部丢失,我们使 A[0](要放的位置) 与 A[3](最小数据的位置)交换。这
样就不可以了吗?
3.然后我们在来找第二小元素,放在 A[1],第三小元素,放在 A[2]。。当寻找完毕,我们排
序也就结束了。
4.不过,在找的时候要注意其实位置,不能在找A[2]的时候,还用 A[2]的数据跟已经排好的
A[0],A[1]比,一定要跟还没有确定位置的元素比。还有一个技巧就是我们不能每次都存元素
值和索引,我们只存索引就可以了,通过索引就能找到元素了。呵呵。
5.他和冒泡的相似和区别,冒泡和他最大的区别是他发现比他小就交换,把小的放上面,而
选择是选择到最小的在直接放在确定的位置。选择也是稳定的排序。
基本思路就这样了,奉上源代码:
#include <stdio.h>
#include <stdlib.h>
//选择排序, pnData 要排序的数据, nLen 数据的个数
int SelectSort(int* pnData, int nLen)
{
//i 从[0,nLen-1)开始选择,确定第 i 个元素
for (int i = 0; i < nLen - 1; ++i)
{
int nIndex = i;
剩余18页未读,继续阅读
资源评论

a66889999
- 粉丝: 5
- 资源: 1万+

上传资源 快速赚钱
我的内容管理 收起
我的资源 快来上传第一个资源
我的收益
登录查看自己的收益我的积分 登录查看自己的积分
我的C币 登录后查看C币余额
我的收藏
我的下载
下载帮助

会员权益专享
安全验证
文档复制为VIP权益,开通VIP直接复制
