基础算法之冒泡排序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