内部排序->交换排序->起泡排序

文字描述

  首先将第一个记录的关键字和第二个记录的关键字进行比较,若为逆序(L.r[1].key>L.r[2].key),则将两个记录交换位置,然后比较第二个记录和第三个记录的关键字。依次类推,直至第n-1个记录和第n个记录的关键字进行过比较为止。上述过程称为第一趟起泡排序,其结果使得关键字最大的记录被安置到最后一个记录的位置上。

  整个起泡排序过程需进行k(k大于等于1且小于n)趟起泡排序,显然判别起泡排序结束的条件应该是排序过程中没有进行过交换记录的操作。

示意图

算法分析

  如果待排序序列为“正序”序列,只需进行一趟排序,在排序过程中进行n-1次关键字间的比较,且不移动记录;

  如果待排序序列为“逆序”序列,则需进行n-1趟排序,需进行n(n-1)/2次比较,并作等数量级的记录移动。

  因此,总的时间复杂度为n*n, 辅助空间为1,是稳定的排序方法。

代码实现

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3
 4 #define DEBUG
 5
 6 #define EQ(a, b) ((a) == (b))
 7 #define LT(a, b) ((a) <  (b))
 8 #define LQ(a, b) ((a) <= (b))
 9
10 #define DEBUG
11
12 #define MAXSIZE 20
13 typedef int KeyType;
14 typedef char InfoType;
15 typedef struct{
16     KeyType key;
17     InfoType otherinfo;
18 }RedType;
19
20 typedef struct{
21     RedType r[MAXSIZE+1];
22     int length;
23 }SqList;
24
25 void PrintList(SqList L){
26     int i = 0;
27     printf("下标值:");
28     for(i=0; i<=L.length; i++){
29         printf("[%d] ", i);
30     }
31     printf("\n关键字:");
32     for(i=0; i<=L.length; i++){
33         printf(" %-3d", L.r[i].key);
34     }
35     printf("\n其他值:");
36     for(i=0; i<=L.length; i++){
37         printf(" %-3c", L.r[i].otherinfo);
38     }
39     printf("\n\n");
40     return ;
41 }
42
43 /*起泡排序*/
44 void BubbleSort(SqList *L)
45 {
46     int i = 0, j = 0, isswap = 0;
47     RedType tmp;
48     for(i=1; i<=L->length; i++){
49         isswap = 0;
50         for(j=1; j<(L->length-i+1); j++){
51             if(!LQ(L->r[j].key, L->r[j+1].key)){
52                 tmp = L->r[j];
53                 L->r[j] = L->r[j+1];
54                 L->r[j+1] = tmp;
55                 isswap = 1;
56             }
57         }
58 #ifdef DEBUG
59         printf("起泡排序第%d趟:\n", i);
60         PrintList(*L);
61 #endif
62         if(!isswap)
63             break;
64     }
65 }
66
67 int  main(int argc, char *argv[])
68 {
69     if(argc < 2){
70         return -1;
71     }
72     SqList L;
73     int i = 0;
74     for(i=1; i<argc; i++){
75         if(i>MAXSIZE)
76             break;
77         L.r[i].key = atoi(argv[i]);
78         L.r[i].otherinfo = ‘a‘+i-1;
79     }
80     L.length = (i-1);
81     L.r[0].key = 0;
82     L.r[0].otherinfo = ‘0‘;
83     printf("输入数据:\n");
84     PrintList(L);
85     BubbleSort(&L);
86     return 0;
87 }

起泡排序

运行

原文地址:https://www.cnblogs.com/aimmiao/p/9367633.html

时间: 2024-11-05 19:35:40

内部排序->交换排序->起泡排序的相关文章

类模板,链表,直接插入排序,选择排序,起泡排序

类模板:使用户可以为类声明一种模式,使类中某些数据成员,某些成员函数的参数,某些成员函数的返回值,能取任意类型. 类模板中,类名后必须跟<模板参数标识符列表> 在主程序中定义对象时,类需说明对象是什么类型,同样用<>括号,在<>尖括号中指定所需类模板的类型. 类模板: template<模板参数表> class 类名 { 类成员声明} 在类模板以外定义成员函数,都要带上template<模板参数表>,指定成员函数属于哪个类时,模板类名后必须跟&l

内部排序-&gt;交换排序-&gt;快速排序

文字描述  快速排序是对起泡排序的一种改进.它的基本思想是,通过一趟排序将待排序记录分割成独立的两部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序. 一趟快速排序描述:假设待排序的序列为{L.r[s], L.r[s+1], - , L.r[t]},首先任意选取一个记录(通常选第一个记录L.r[s])作为枢轴(pivot), 然后按下述原则重新排列其余记录:将所有关键字较它小的记录都安置在它的位置之前,将所有关键字较它大的记录都安置在它

排序——交换排序

三.交换排序 ①冒泡排序 1.基本思想:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒.即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换. 2.实例 3.java实现 复制代码 package com.sort; //稳定 public class 冒泡排序 { public static void main(String[] args) { int[] a={49,38,65,97,76,13,

改进的起泡排序算法--java

一.基本思路: 冒泡排序是一种简单的交换类排序.其基本思路是从头开始扫描待排序的元素,在扫描过程中依次对相邻元素进行比较,将关键字值大的元素后移.每经过一趟排序后,关键字值最大的元素将移到末尾,此时记下该元素的位置,下一趟排序只需要比较到此位置为止,直到所有元素都已有序排列. 一般地,对n个元素进行冒泡排序,总共需要进行n-1趟.第1趟需要比较n-1次,第2趟需要比较n-2次,......第i趟需要比较n-i次. 二.算法 2.1原始起泡排序算法 public static int[] bubb

从起泡排序探究算法正确性证明的一般规律

起泡排序 问题:该算法必然会结束?至少需要迭代多少趟? 不变性:经k 轮扫描交换后,最大的k 个元素必然就位 单调性:经k 轮扫描交换后,问题规模缩减至n-k 正确性:经至多n 趟扫描后,算法必然终止,且能给出正确解答

排序 起泡排序(bubble sort),归并排序(merge sort)

1,起泡排序(bubble sort),大致有三种算法 基本版,全扫描. 提前终止版,如果发现前区里没有发生交换,就说明前区已经有序了,直接终止了.但是有个效率低下的地方,就是右边界hi是每次循环向前移动一个单元 跳跃版,在提前终止版的基础上,解决右边界hi移动效率低下的问题.解决思路:每次循环后,记录下最后一次的交换位置A,然后让hi=交换位置A,所以hi就可以跳跃移动多个单元了. 基本版代码实现 //冒泡排序(基本版 效率低下) template<typename T> void Vect

内部排序-&gt;选择排序-&gt;树形选择排序

文字描述 树形选择排序又称锦标赛排序; 比如,在8个运动员中决出前3名至多需要11场比赛, 而不是7+6+5=18场比赛(它的前提是甲胜乙,乙胜丙,则甲必能胜丙) 首先对n个记录的关键字进行两两比较,然后在(n/2)个较小者之间再进行两两比较,直至选出最小关键字的记录为止,这个过程可用一颗有n个叶子结点的完全二叉树表示.关于完全二叉树的定义和与本排序算法用到的性质见附录1 示意图 算法分析 由于含n个叶子结点的完全二叉树的深度为[log2n]+1, 则在树形选择排序中,除了最小关键字外,每选择一

排序之分治排序

本算法是笔者研读算法导论分治内容伪代码所写,俗话说,它山之石,可以攻玉.算导对排序有非常详细的解释,而分治排序更是其中巧妙的一种排序算法.分治排序先把数组分成[l,mid]与(mid,r]两部分,多次划分直到每个部分只有1个元素.然后把这两部分进行比较排序.(由于上一次的排序,这两个分数组内部是有序的); 举例说数组:[7,3,5,4,6,2,1],定义INF = 100,大于数组每个元素 (1).第一次划分 [7,3,5,4] , [6,2,1] (2).对[7,3,5,4]进行第二次划分 [

【排序】选择排序算法

特别说明 对于算法,重在理解其思想.解决问题的方法,思路.因此,以下内容全都假定待排序序列的存储结构为:顺序存储结构. 选择排序思想 选择排序又称为简单选择排序,主要思想描述如下: 01.假设待排序列表为 .选择排序将  划分为由已排序好序的  部分 以及 未排序的  部分: 注意:刚开始时  部分其实可认为只有一个元素,即: 元素 02.每次从  部分中选出最小(或最大)的那个元素,将其放在  的末尾位置: 03.重复02步骤,直到  部分为空为止: 编码参考 简单选择排序是非常简单的一种排序