基础算法之冒泡排序Bubble Sort

原理

将相邻的数据两两进行比较,按照从小到大或者从大到小的顺序进行位置交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后从头开始再次进行两两比较交换,直到倒数第二位时结束。按照此规则，若干趟数据便按照了从小到大或者从大到小完成了排序。

例子

将数组[3,6,4,2,5,1]进行从大到小排序

第一趟排序

第一次两两比较，3<6 交换

交换前：| 3 | 6 | 4 | 2 | 5 | 1 |

交换后：| 6 | 3 | 4 | 2 | 5 | 1 |

第二次两两比较，3<4 交换

交换前：| 6 | 3 | 4 | 2 | 5 | 1 |

交换后：| 6 | 4 | 3 | 2 | 5 | 1 |

第三次两两比较，3>2 不交换

交换前：| 6 | 4 | 3 | 2 | 5 | 1 |

交换后：| 6 | 4 | 3 | 2 | 5 | 1 |

第四次两两比较，2<5交换

交换前：| 6 | 4 | 3 | 2 | 5 | 1 |

交换后：| 6 | 4 | 3 | 5 | 2 | 1 |

第五次两两比较，2>1不交换

交换前：| 6 | 4 | 3 | 2 | 2 | 1 |

交换后：| 6 | 4 | 3 | 5 | 2 | 1 |

 

第二趟排序

第一次两两比较，6>4不交换

交换前：| 6 | 4 | 3 | 5 | 2 | 1 |

交换后：| 6 | 4 | 3 | 5 | 2 | 1 |

第二次两两比较，4>3不交换

交换前：| 6 | 4 | 3 | 5 | 2 | 1 |

交换后：| 6 | 4 | 3 | 5 | 2 | 1 |

第二次两两比较，3<5交换

交换前：| 6 | 4 | 3 | 5 | 2 | 1 |

交换后：| 6 | 4 | 5 | 3 | 2 | 1 |

第三次两两比较，3>2不交换

交换前：| 6 | 4 | 5 | 3 | 2 | 1 |

交换后：| 6 | 4 | 5 | 3 | 2 | 1 |

 

第三趟排序

第一次两两比较，6>4不交换

交换前：| 6 | 4 | 5 | 3 | 2 | 1 |

交换后：| 6 | 4 | 5 | 3 | 2 | 1 |

第二次两两比较，4<5交换

交换前：| 6 | 4 | 5 | 3 | 2 | 1 |

交换后：| 6 | 5 | 4 | 3 | 2 | 1 |

第三次两两比较，4>3不交换

交换前：| 6 | 5 | 4 | 3 | 2 | 1 |

交换后：| 6 | 5 | 4 | 3 | 2 | 1 |

 

第四趟排序无交换

第五趟排序无交换

至此，排序完毕,输出最终结果6 5 4 3 2 1

动画演示

代码参考

        static void Main(string[] args)

        {

            int[] intArray = { 3, 6, 4, 2, 5, 1 };

            Bubble_Sort(intArray);



            foreach (var item in intArray)

            {

                Console.WriteLine(item);

            }

            Console.ReadLine();

        }



        static void Bubble_Sort(int[] unsorted)

        {

            int temp;

            for (int i = 0; i < unsorted.Length - 1; i++)

            {

                for (int j = 0; j < unsorted.Length - 1 - i; j++)

                {

                    if (unsorted[j] < unsorted[j + 1])

                    {

                        temp = unsorted[j];

                        unsorted[j] = unsorted[j + 1];

                        unsorted[j + 1] = temp;

                    }

                }

            }

        }

算法优化

假如一个数组进行很少趟就能排成有序数组，那么运行上面的代码就有点浪费了。对算法进行优化，详情请看一下代码

　　　　　static void Bubble_Sort(int[] unsorted)

        {

            int temp;

            bool flag; //新增标志位

            for (int i = 0; i < unsorted.Length - 1; i++)

            {

                flag = false;

                for (int j = 0; j < unsorted.Length - 1 - i; j++)

                {

                    if (unsorted[j] < unsorted[j + 1])

                    {

                        temp = unsorted[j];

                        unsorted[j] = unsorted[j + 1];

                        unsorted[j + 1] = temp;

                        flag = true;  //发生交换，则标志位改变

                    }

                }



                //数据未发生1次交换，标志位不变，表示数组已为有序装态，可提前结束外层循环

                if (!flag)

                {

                    break;

                }

            }

        }

参考资料

http://www.blogjava.net/todayx-org/archive/2012/01/08/368091.html