排序——1.冒泡排序

冒泡排序

正在学习算法,然而起来的时候感觉理解起来其实挺别扭的,于是就想写一个能让人看一眼就能明白算法原理的东西,其实也是自己整理和沉淀自己的所学到的知识,要把算法写到让人一看就能明白的确挺难的感觉自己在说大话,毕竟能力有限,尽量吧。

在我最早开始接触排序算法的时候就是从冒泡排序开始的,虽然冒泡法在处理大量数据的时候基本不用(效率低下),但冒泡法容易理解,基本上是所有程序员接触的第一个排序算法。废话少说吧,开始:

假设有一个包含10个数据的数组a[9]={8,4,6,3,2,1,8,5,11,25}

算法概括:

1.从头开始,选择一个元素和它后面的元素比较,谁大就把谁放到后面。例如数组a中,先选择a[0],比较他和他后面的元素(也就是a[1]),很明显8>4,也就是a[0]>a[1]。于是把大的那个元素放到后面,在这里就是把8和4调换。这样就完成一次排序,再进行下一次,这次选择a[1],把a[1]和它后边的元素a[2]进行比较,以此类推到比较到最后一个元素。因为每次比较都把两个数中较大的那个放到后面,所以遍历一遍之后,最后那个元素一定是当前数组中最大的。

2.再从a[0]开始比较,这一次就不再需要再和a[9]比较了,因为他已经是最大的那个了,当这一次比较完的时候,数组中倒数第二个元素a[8]就是整个数组中除了a[9](他是整个数组中最大的)最大的元素了。

3.重复上一步直到没有数据可以比较。

代码入下:

</pre><pre name="code" class="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 冒泡排序
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] a = new int[] { 8, 4, 6, 3, 2, 1, 8, 5, 11, 25 };
            Console.WriteLine("未排序之前的顺序:");
            foreach (int s in a)
            { Console.WriteLine("    {0}",s); }
            for (int i=0;i<a.Length;i++)
            {
                for (int j=0 ;j<a.Length-i-1;j++)
                {
                    int Temp;
                    if (a[j]>a[j+1])
                    {
                        Temp = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = Temp;
                    }
                }
            }
            Console.WriteLine("排序之后的顺序:");
            foreach (int s in a)
            { Console.WriteLine("    {0}", s); }
            Console.ReadKey();
        }
    }
}

运行结果:

时间: 2024-07-31 00:36:49

排序——1.冒泡排序的相关文章

内部排序:冒泡排序和选择排序

前言 之所以把冒泡排序和选择排序放在一起,是因为二者的实现代码很相似,而且都是最基本的排序方式,非常容易理解和实现.当然,如果仅仅是为了讲述这两种排序方式,那也根本没必要写这篇博文了.和上篇博文一样,我会在冒泡排序和选择排序原始代码的基础上给出一些改进和优化,这才是本文的重点所在. 原始冒泡排序 冒泡排序的思想很简单,如果要求排序后序列中元素按照从小到大的顺序排列,则冒泡排序的步骤如下: 1.依次比较序列中相邻的两个元素,将较大的放在后面,这样一趟比较后,最大的元素就放在了最后的一个位置: 2.

Java选择排序和冒泡排序示例

package cc.test; /** * Demo描述: * 选择排序和冒泡排序 */ public class TestSort { public static void main(String[] args) { TestSort testSort=new TestSort(); int intArray []=new int []{11,3,-2,4,8,7}; testSort.selectSort(intArray); testSort.bubbleSort(intArray);

选择排序与冒泡排序

/// <summary> /// 选择排序 /// </summary> /// <param name="arr"></param> static void Sort1(int[] arr) { int len = arr.Length; for (var i = 0; i < arr.Length; i++) { int min = i; for (var n = i + 1; n < arr.Length; n++)

C语言实现选择排序、冒泡排序和快速排序的代码示例_C 语言

选择和冒泡 #include<stdio.h> void maopao(int a[],int len){ int i,j,temp; for(i = 0;i < len - 1 ; i ++){//从第一个到倒数第二个 for (j = 0 ; j < len - 1 - i ; j ++)//排在后的是已经排序的 { if (a[j] > a[j + 1])//大的数换到后面去 { temp = a[j]; a[j] = a[j + 1]; a [j + 1] = tem

Python选择排序、冒泡排序、合并排序代码实例_python

前两天刚装了python 3.1.1, 禁不住技痒写点code.1.选择排序 复制代码 代码如下: >>> def SelSort(L):     length=len(L)     for i in range(length-1):         minIdx=i         minVal=L[i]         j=i+1         while j<length:             if minVal>L[j]:                 min

Java中简单的2个排序(冒泡排序,选择排序)

用Arrays带有的排序方法快速排序  代码如下 复制代码 import java.util.Arrays; public class Test2{         public static void main(String[] args){                 int[] a={5,4,2,4,9,1};                 Arrays.sort(a);  //进行排序                 for(int i: a){                  

内部排序算法:冒泡排序

基本思想 将被排序的记录数组R[0..n-1]垂直排列,每个记录R[i]看作是重量为R[i].key的气泡.根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R:凡扫描到违反本原则的轻气泡,就使其 向上"飘浮".如此反复进行,直到最后任何两个气泡都是轻者在上,重者在下为止. 具体过程,如下所示: 初始状态:R[0..n-1]为无序区. 第一趟扫描:从无序区底部向上依次比较相邻的两个气泡的重量,若发现轻者在下.重者 在上,则交换二者的位置,即依次比较(R[n-1], R[n-2]).(R

C#的四种排序算法:冒泡排序、选择排序、插入排序和希尔排序

插入|排序|算法 本文介绍了C#的四种排序算法:冒泡排序.选择排序.插入排序和希尔排序 冒泡排序 using System: namespace BubbleSorter { public class BubbleSorter { public void Sort(int [] list) { int i,j,temp: bool done=false: j=1: while((j<list.Length)&&(!done)) { done=true: for(i=0:i<li

我的Java开发学习之旅------&amp;gt;Java经典排序算法之冒泡排序

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