冒泡排序、选择排序及插入算法

一、冒泡排列

冒泡排序的原理如下,以8个数由大到小排列为例,进行说明,数据存放在数组a[8]中。

假如8个数分别为4、9、10、3、2、14、11、5。

a[0]<a[1]即4<9,故交换位置,9、4、10、3、2、14、11、5

a[1]<a[2]即4<10,故交换位置,9、10、4、3、2、14、11、5

a[2]>a[3]即4>3,位置不变,继续比较

a[3]>a[4]即3>2,位置不变,继续比较

a[4<a[5]即2<14,故交换位置,9、10、4、3、14、2、11、5

a[5]<a[6]即2<11,故交换位置,9、10、4、3、14、11、2、5

a[6]<a[7]即2<5,故交换位置,9、10、4、3、14、11、5、2

由以上比较过程可知,通过7次比较,可以确定最小的数2,并放到末尾。

同理循环这个过程,经过6次比较可以确定3,数列变为:………3、2

经过5次比较可以确定4,数列变为:………4、3、2

经过4次比较可以确定5,数列变为:………5、4、3、2

经过3次比较可以确定9,数列变为:………9、5、4、3、2

经过2次比较可以确定10,数列变为:………10、9、5、4、3、2

经过1次比较可以确定11,数列变为:…………11、10、9、5、4、3、2 同时最大的数也就确定了,数列变为14、11、10、9、5、4、3、2

总结:要比排列出8个数的顺序,要循环7次才能做到,每次循环的比较次数分别为7、6、5、4、3、2、1。

下面是将8个数从大排列到小的程序代码:

 1 #include<stdio.h>
 2 int main()
 3 {
 4     int arr[8];
 5     int i,j,temp;
 6     for(i=0;i<8;i++)  //利用for循环手动输入8个数,并存放到数组arr[i]
 7        {
 8             printf("请输入第%d个数据:\n",i+1);
 9         scanf("%d",&arr[i]);
10     }
11     for(i=0;i<7;i++)   //i从0~6,要经过7次循环才能排出顺序
12     {
13         for(j=0;j<7-i;j++)   //7次循环,每次分别比较次数7、6、5、4、3、2、1
14         {
15             if(arr[j]<arr[j+1])
16             {
17                 temp=arr[j];    //交换位置
18                 arr[j]=arr[j+1];
19                 arr[j+1]=temp;
20             }
21         }
22     }
23     printf("由大到小排列为:\n");   //利用for循环,将数组输出
24     for(i=0;i<8;i++)
25     {
26         printf("%d ",arr[i]);
27     }
28     return 0;
29 } 

注:若要一组数由小到大排列,将if中的条件语句改变即可,arr[j]>arr[j+1]。

二、选择排序

选择排序原理如下,同样以8个数由大到小排列为例,进行说明,数据存放在数组a[8]中。

假如8个数分别为4、9、10、3、2、14、11、5。第一次以a[0]为定点开始比较。

a[0]<a[1]即4<9,故交换位置:9、4、10、3、2、14、11、5

a[0]<a[2]即9<10,故交换位置:10、4、9、3、2、14、11、5

a[0]>a[3]即10>3,位置不变

a[0]>a[4]即10>2,位置不变

a[0]<a[5]即10<14,故交换位置:14、4、9、3、2、10、11、5

a[0]>a[6]即14>11,位置不变

a[0]>a[7]即14>5,位置不变

由以上比较过程可知,通过7次比较,可以确定最大的数2,并放到首位。

同理循环这个过程,以a[1]为定点,经过6次比较可以确定11,数列变为:14、11………

以a[2]为定点, 经过5次比较可以确定10,数列变为:14、11、10………

以a[3]为定点,经过4次比较可以确定9,数列变为:14、11、10、9………

以a[4]为定点,经过3次比较可以确定5,数列变为:14、11、10、9、5………

以a[5]为定点,经过2次比较可以确定4,数列变为:14、11、10、9、5、4………

以a[6]为定点, 经过1次比较可以确定3,数列变为:14、11、10、9、5、4、3………… 同时最小的数2也就确定了,数列变为14、11、10、9、5、4、3、2

总结:要比排列出8个数的顺序,要循环7次才能做到,每次循环的比较次数分别为7、6、5、4、3、2、1

 1 #include<stdio.h>
 2 int main()
 3 {
 4     int arr[8];
 5     int i,j,temp;
 6     for(i=0;i<8;i++)    //利用for循环手动输入8个数,并存到数组arr[i]中
 7     {
 8             printf("请输入第%d个数据:\n",i+1);
 9         scanf("%d",&arr[i]);
10     }
11     for(i=0;i<7;i++)       //i从0~6,7次循环方能将8个数排列起来
12     {
13         for(j=i;j<8;j++)      //7次循环,每次循环比较的次数7、6、5、4、3、2、1
14         {
15             if(arr[i]<arr[j])
16             {
17                 temp=arr[i];
18                 arr[i]=arr[j];
19                 arr[j]=temp;
20             }
21         }
22     }
23     printf("由大到小排列为:\n");
24     for(i=0;i<8;i++)
25     {
26         printf("%d ",arr[i]);
27     }
28     return 0;
29 }

注:若要一组数由小到大排列,将if中的条件语句改变即可,arr[i]>arr[j]。

三、插入算法

在一组有序(由大到小或由小到大排列)的数列中,插入一个数,保持原有顺序。程序代码如下:

 1 #include<stdio.h>
 2 int main()
 3 {
 4     int arr[11]={3,5,6,8,15,17,20,21,45,50,0};
 5     int num;
 6     int i;
 7     int biaoji=0; //保存找到的下表,默认最小下标
 8     printf("请输入一个数据:\n");
 9     scanf("%d",&num);
10     for(i=0;i<=8;i++)   //循环找到要插入的位置下标
11     {
12         if(num>=arr[i]&&num<=arr[i+1])
13         {
14             biaoji=i+1;
15              break;
16          }
17         if(num>arr[9])
18         {
19             biaoji=10;
20             break;
21         }
22     }
23     for(i=10;i>biaoji;i--)  //把后面的数依次往后移,空出下标位置
24     {
25         arr[i]=arr[i-1];
26     }
27     arr[biaoji]=num;   //把num的值赋给找到的下标处
28     for(i=0;i<11;i++)   //显示结果
29     {
30         printf("%d ",arr[i]);
31     }
32
33     return 0;
34 } 
时间: 2024-08-28 14:30:45

冒泡排序、选择排序及插入算法的相关文章

算法 排序lowB三人组 冒泡排序 选择排序 插入排序

参考博客:基于python的七种经典排序算法   [经典排序算法][集锦]     经典排序算法及python实现 首先明确,算法的实质 是 列表排序.具体就是操作的列表,将无序列表变成有序列表! 一.排序的基本概念和分类 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法. 排序的稳定性: 经过某种排序后,如果两个记录序号同等,且两者在原无序记录中的先后秩序依然保持不变,则称所使用的排序方法是稳定的,反之是不稳定

C# 插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序

以下列出了数据结构与算法的八种基本排序:插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序,然后是測试的样例.代码位置:http://download.csdn.net/detail/luozuolincool/8040027 排序类: public class Sortings { //插入排序 public void insertSort(int[] array) { int temp = 0; int index = 0; for (int i = 0; i <

C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序

下面列出了数据结构与算法的八种基本排序:插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序,然后是测试的例子.代码位置:http://download.csdn.net/detail/luozuolincool/8040027 排序类: public class Sortings { //插入排序 public void insertSort(int[] array) { int temp = 0; int index = 0; for (int i = 0; i <

排序系列 之 简单选择排序及其改进算法 —— Java实现

简单选择排序算法: 基本思想: 在待排序数据中,选出最小的一个数与第一个位置的数交换:然后在剩下的数中选出最小的数与第二个数交换:依次类推,直至循环到只剩下两个数进行比较为止. 实例: 0.初始状态 3,1,5,7,2,4,9,6(共8个数) 1.n=8 个数中,最小数值为1,与第一个数交换:1,3,5,7,2,4,9,6 2.剩下 n-1=7 个数中,最小数值为2,与第二个数交换:1,2,5,7,3,4,9,6 3.剩下 n-2=6 个数中,最小数值为3,与第三个数交换:1,2,3,7,5,4

经典排序:冒泡排序+选择排序 小结

经典排序:冒泡排序+选择排序 例 FJUTOJ 1842 冒泡排序 原理是取相邻两个数进行大小比较,判断是否交换. 以从小到大排序为例,冒泡排序就像气泡一样,最小的数慢慢浮上来,最大的数慢慢沉下去.那么完整从头到尾做一次之后最后一位就是原序列中最大的数字了.然后只需要对1~(n-1)个数字进行排序,完成后倒数第二个数字也为原序列的1~n-1元素中最大的值.如此重复,进行n-1次一定能完成排序.参考代码: 1 #include <stdio.h> 2 void BubbleSort(int *,

【算法】插入排序/冒泡排序/选择排序

插入排序 插入排序的思想为:从数组的第二个元素开始遍历整个数组.针对每个元素,依次将其前面的所有元素和他进行比较,大于它的元素均向后移动,最后将该元素插入. 插入排序是一种稳定的排序算法. 时间复杂度T(n)=O(n^2) 最好情况下已排好序,T(n)=O(n) private void swap(int[] a, int i, int j) { int temp = a[j]; a[j] = a[i]; a[i] = temp; } 插入排序的关键代码 private void insertS

简单排序算法 冒泡排序 选择排序 插入排序

冒泡排序: 总体思路:对未排序的各个元素,依次比较两个元素,如果这两个元素为逆序(与想要的顺序相反),则交换这两个元素. 这样可以有两种排序的思路: 思路一: 固定位置排序:比如有一个未排序队列,下标依次为0,1,2,.....N-1, 第一轮排序:首先固定位置0,将下标为0的元素依次和下标为1.下标为2.....下标为N-1的元素相比较,若相比较的两个元素为逆序,则交换这两个元素,这样第一轮排序完之后,位置为0的元素,就是最大的(最小的). 第二轮排序:首先固定位置1,将下标为1的元素依次和下

算法_基本排序算法之冒泡排序,选择排序,插入排序和希尔排序

排序的元素实现了Comparable接口,以达到对于通用性. 最基础的排序是冒泡排序,下面是其思路: 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数. 针对所有的元素重复以上的步骤,除了最后一个. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. 下面是其实现代码: public class Maopao { public void sort(Comparable[]

基本排序算法(冒泡排序 选择排序 插入排序 快速排序 归并排序 基数排序 希尔排序)

冒泡排序 public static void bubbleSort(int[] arr){ int lgn = arr.length; for (int i = 0; i < lgn - 1; i++) { for (int j = 0; j < lgn - 1 - i; j++) { if(arr[j] > arr[j + 1]){ int temp = arr[j + 1]; arr[j + 1] = arr[j]; arr[j] = temp; } } } } 选择排序 publ