八大排序之冒泡排序;

/*八种排序之冒泡排序*/
//冒泡排序的原理是:从左到右,相邻元素进行比较。每次比较一轮,
//就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。
/*  1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
  2. 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
  3. 针对所有的元素重复以上的步骤,除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。*/
/*双向链表过程:
1、从存储n个待排序元素的表尾开始,并令j=n;
2、若j<2,则排序结束;
3、从第一个元素开始进行两两比较,令i=1;
4、若i>=j,则一趟冒泡排序结束,j=j-1;待排序表的记录数-1,转step2;
5、比较array[i].key与array[i+1].key,若array[i].key<=array[i+1].key,则不交换,转step7;
6、array[i].key>array[i+1].key,将array[i].key于array[i+1].key交换;
7、i = i+1,转step4继续比较
*/

#include <stdio.h>
#define N 8
void BubbleSort(int array[N]) {
    for (int i = 1; i < N; i++)            //问题1、i为什么从1开始
                                       /*
                                       一共只需排N-1趟,最小的数字在最左边,不用排序;
                                       */
                                        //问题2、为什么只排序了N-1趟
                                        /*
                                        冒泡排序每趟需要将最大的数移动到最右边,
                                        (以max+下标表示这个数的大小排名,如最大的为MAX1)
                                        第一趟将数MAX1移动到底N-0个数的位置,
                                        第二趟将数MAX2移动到第N-1个数的位置
                                        第三趟将数MAX3移动到第N-2个数的位置
                                        ....
                                        第N-1趟将数MAX(n-1)移动到第N-((N-1)-1))==2个位置,
                                        此时仅剩下最小的数排在第一个位置,所以不用再排序了
                                        即一共排序了N-1趟;
                                        */
    {
        for (int j = 0; j < N - i; j++) {
                                        //问题3、j为什么等于N-i
                                         /*
                                         第i趟将数MAXi排在第N-(i-1)个位置上,而从第N-(i-1)往后
                                         的数字都已经排好序了,
                                         即后面的数字无需再排
                                         */
            if (array[j] > array[j + 1])
            {
                int t = array[j];
                array[j] = array[j + 1];
                array[j + 1] = t;

}

}
        printf("第%d趟排序", i);
        for (int a = 0; a < N; a++)
        {

printf("%d ",array[a]);
        }

printf("\n");
    }
}
int main() {
    int array[N];
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &array[i]);
    }
    printf("排序前");
    for (int i = 0; i < N; i++)
    {
        printf("%d ", array[i]);
    }
    printf("\n");
    BubbleSort(array);
    printf("排序后\n");
    for (int i = 0; i < N; i++)
    {
        printf("%d ", array[i]);
    }
    return 0;
}
//实例:
//1,排序问题
//时间限制 : 1Sec 内存限制 : 128MB
//    题目描述
//    将四个整数进行从小到大的顺序排列,
//
//    输入
//    四个整数
//
//    输出
//    从小到大输出这四个数
//
//    样例输入
//    5 3 4 2
//    样例输出
//    2 3 4 5

#include <stdio.h>
#define N 4
void BubbleSort(int array[N]) {
    for (int i = 1; i < N; i++)
    {
        for (int j = 0; j < N - i;j++) {
            if (array[j]>array[j+1])
            {
                int t = array[j];
                array[j] = array[j + 1];
                array[j + 1] = t;
            }
        }
    }
    for (int i = 0; i < N; i++)
    {
        printf("%d ", array[i]);
    }    
}
void main() {
    int array[N];
    for (int i = 0; i < N; i++)
    {
        scanf("%d",&array[i]);
    }
    BubbleSort(array);
}

原文地址:https://www.cnblogs.com/destiny-2015/p/11784158.html

时间: 2025-01-08 07:10:24

八大排序之冒泡排序;的相关文章

八大排序算法——冒泡排序(动图演示 思路分析 实例代码java 负杂度分析)

一.动图演示 二.思路分析 1.  相邻两个数两两相比,n[i]跟n[j+1]比,如果n[i]>n[j+1],则将连个数进行交换, 2.  j++, 重复以上步骤,第一趟结束后,最大数就会被确定在最后一位,这就是冒泡排序又称大(小)数沉底, 3.  i++,重复以上步骤,直到i=n-1结束,排序完成. 三.负杂度分析 1.  不管原始数组是否有序,时间复杂度都是O(n2), 因为没一个数都要与其他数比较一次,(n-1)2次,分解:n2+2n-1,  去掉低次幂和常数,剩下n2,所以最后的时间复杂

Java实现八大排序之冒泡排序

冒泡排序 冒泡排序的定义: 冒泡排序(Bubble Sort)它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成. 这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端.(定义来自百度百科).简单的说就是持续交换两个元素,直到数列变有序. 冒泡排序的算法思想: 比较相邻的元素,如果第一个比第二个元素要大,则交换这两个数.对每对相邻的元素进行同样的工作,从第一对到最后一对

八大排序之冒泡排序

一.基本思想 冒泡排序是一种基于数值交换的排序,从第一个元素开始,与后面紧接着的一个元素比较,如果当前这个数更大,则交换两者的数值,那么值更大的元素就像泡泡一样往后走.第n趟排序即可使第n大元素从前往后走.进行n-1次这样的"冒泡操作"后,整个序列就有序了. 二.实现代码 public class BubbleSort implements ISort{ public void sort(int[] a) { for(int i = 0; i <= a.length - 3; i

八大排序算法学习笔记:冒泡排序

冒泡排序(Bubble Sort,台湾译为:泡沫排序或气泡排序)是一种简单的排序算法. 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端. 算法原理: 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的数. 针对所有

Python八大算法的实现,插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序、归并排序、基数排序。

Python八大算法的实现,插入排序.希尔排序.冒泡排序.快速排序.直接选择排序.堆排序.归并排序.基数排序. 1.插入排序 描述 插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的.个数加一的有序数据,算法适用于少量数据的排序,时间复杂度为O(n^2).是稳定的排序方法.插入算法把要排序的数组分成两部分:第一部分包含了这个数组的所有元素,但将最后一个元素除外(让数组多一个空间才有插入的位置),而第二部分就只包含这一个元素(即待插入元素).在第一部分排序完成后,再将这

八大排序算法的python实现(三)冒泡排序

代码: #coding:utf-8 #author:徐卜灵 #交换排序.冒泡排序 L = [1, 3, 2, 32, 5, 4] def Bubble_sort(L): for i in range(len(L)): for j in range(i+1,len(L)): if L[i]>L[j]: # temp = L[j] # L[j] = L[i] # L[i] = temp L[i], L[j] = L[j], L[i]#交换顺序 print L Bubble_sort(L) 冒泡排序应

八大排序算法

转载:http://blog.csdn.net/hguisu/article/details/7776068 目录(?)[+] 概述 排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存. 我们这里说说八大排序就是内部排序. 当n较大,则应采用时间复杂度为O(nlog2n)的排序方法:快速排序.堆排序或归并排序序. 快速排序:是目前基于比较的内部排序中被认为是最好的方法,当待排序的关键字是随机分布时,快速

谈谈八大排序算法问题

排序算法可以说是算法的入门以及算法学习阶段的基石,排序算法显得那么的基础又是非常重要的一种算法.排序算法常常作为一些高阶算法的数据处理中间过程在实际的问题处理中被应用的最为广泛,因此算法选将阶段就从八大排序算法开始.在本节内容中既可以看到一般性的比如插入排序,冒泡排序等基础算法又可以看到比如基数排序,位图排序,快速排序等等比较难理解的算法,算法之门从排序算法说起. 1.插入排序 插入排序算法的原理很简单,默认A中有一部分数据已经排好序了,后续只要从没有排好序的序列里面每拿出一个数字就在排好序的序

八大排序算法源码 + 耗时长度比较(看到好东西转下)

八大排序算法的排序时间长度的比较,测试数据10000000时部分结果如下 输入测试数据长度: 10000000数据初始化中...数据初始化完成!        堆排序用时:    8秒 499毫秒      快速排序用时:   22秒  35毫秒      归并排序用时:   34秒 473毫秒 另外五种排序本人并未等待结果,读者可自行测试 测试时请注意内存消耗,以免数据太大,内存不够,可自行测试单一算法以便增加可测试数据数目 #include <iostream> #include <