冒泡排序原理，php冒泡排序，golang冒泡排序

要写出冒泡排序，首先要知道冒泡排序的原理，参考这篇文章：http://c.biancheng.net/view/6506.html

根据需要排序的数组，遍历这个数组的长度的同时比较前后两个数的值大小，交换这两个值的位置

假设待排序序列为 (5,1,4,2,8)，如果采用冒泡排序对其进行升序（由小到大）排序，则整个排序过程如下所示：
1) 第一轮排序，此时整个序列中的元素都位于待排序序列，依次扫描每对相邻的元素，并对顺序不正确的元素对交换位置，整个过程如下图所示。

从图 1 可以看到，经过第一轮冒泡排序，从待排序序列中找出了最大数 8，并将其放到了待排序序列的尾部，并入已排序序列中。

 

2) 第二轮排序，此时待排序序列只包含前 4 个元素，依次扫描每对相邻元素，对顺序不正确的元素对交换位置，整个过程如下图所示。

可以看到，经过第二轮冒泡排序，从待排序序列中找出了最大数 5，并将其放到了待排序序列的尾部，并入已排序序列中。

 

3) 第三轮排序，此时待排序序列包含前 3 个元素，依次扫描每对相邻元素，对顺序不正确的元素对交换位置，整个过程如下图所示。

经过本轮冒泡排序，从待排序序列中找出了最大数 4，并将其放到了待排序序列的尾部，并入已排序序列中。

4) 第四轮排序，此时待排序序列包含前 2 个元素，对其进行冒泡排序的整个过程如图 4 所示。

经过本轮冒泡排序，从待排序序列中找出了最大数 2，并将其放到了待排序序列的尾部，并入已排序序列中。

5) 当进行第五轮冒泡排序时，由于待排序序列中仅剩 1 个元素，无论再进行相邻元素的比较，因此直接将其并入已排序序列中，此时的序列就认定为已排序好的序列（如图下图 所示）。

 

PHP版冒泡排序：

<?php
//冒泡排序法,升序排序,降序排序
function maopaoSort($maopao,$sort="up"){
    $maopaoLen = count($maopao)-1;
    for($j=0;$j<$maopaoLen;$j++){
        for($i=0;$i<$maopaoLen;$i++){
            $now  = $maopao[$i];//当前数的值
            $next = $maopao[$i+1];//下一个数的值

            if($sort=="up"){
                //冒泡升序排序：如果当前数大于下一个数,则交换位置,让当前的数值变成下一位数值,下一位数值变成当前数值
                if($now>$next){
                    $maopao[$i]   = $next;
                    $maopao[$i+1] = $now;
                }
            }else{
                //冒泡降序排序：如果当前数小于下一个数,则交换位置,让当前的数变成下一位数的值,下一位数变成当前数的值
                if($now<$next){
                    $maopao[$i]   = $next;
                    $maopao[$i+1] = $now;
                }
            }
            $temp = implode(",",$maopao);
            echo PHP_EOL." 第{$j}轮,第{$i}次排序 {$temp}".PHP_EOL;
        }
    }
    return $maopao;
}

$maopao = array(30,100,90,20,10,80,50,60,70);
$sortUp = maopaoSort($maopao,"up");
$down = maopaoSort($maopao,"down");
$res = PHP_EOL."冒泡排序法：".implode(",",$maopao).PHP_EOL;
$res.="冒泡升序：".implode(",",$sortUp)." 冒泡降序：".implode(",",$down);
echo $res;

排序结果：冒泡升序：10,20,30,50,60,70,80,90,100 冒泡降序：100,90,80,70,60,50,30,20,10

golang版冒泡排序：

package main

import (
	"fmt"
)

func main() {
	var array = []int{90, 100, 10, 40, 20, 30, 50, 70, 80, 60}
	fmt.Println("需排序的数组:", array)

	//这里传递的是切片,默认是引用传递,因为我在函数里面是copy了切片,所以不会更改原始数据
	up := maopaoSort("up", array)
	fmt.Println("冒泡升序排序", up)

	down := maopaoSort("down", array)

	fmt.Println("冒泡降序排序", down)

	mp := maopaoSortDefault("up", array)
	fmt.Println("冒泡升序排序", mp, "原数据跟着改变", array)
}

//二分法查找,支持升序排序，降序排序
func maopaoSort(sort string, arraySource []int) []int {
	arrayLen := len(arraySource) //总长度
	maopaoLen := arrayLen - 1    //遍历长度

	newArray := make([]int, arrayLen) //用copy是为了不改变外面传递进来的切片
	copy(newArray, arraySource)       //把切片的值拷贝给新新创建的切片

	for i := 0; i < maopaoLen; i++ {

		for j := 0; j < maopaoLen; j++ {
			now := newArray[j]
			next := newArray[j+1]

			if sort == "up" {
				if now > next { //冒泡升序排序
					newArray[j] = next
					newArray[j+1] = now
				}
			} else {
				if now < next { //冒泡降序排序
					newArray[j] = next
					newArray[j+1] = now
				}
			}
		}
	}
	return newArray
}

//直接更改切片的数据,会影响外面的切片,因为切片是引用传递
func maopaoSortDefault(sort string, arraySource []int) []int {
	maopaoLen := len(arraySource) - 1

	for i := 0; i < maopaoLen; i++ {

		for j := 0; j < maopaoLen; j++ {
			now := arraySource[j]
			next := arraySource[j+1]

			if sort == "up" {
				if now > next { //冒泡升序排序
					arraySource[j] = next
					arraySource[j+1] = now
				}
			} else {
				if now < next { //冒泡降序排序
					arraySource[j] = next
					arraySource[j+1] = now
				}
			}
		}
	}
	return arraySource
}

运行结果：需排序的数组: [90 100 10 40 20 30 50 70 80 60]
冒泡升序排序 [10 20 30 40 50 60 70 80 90 100] 冒泡降序排序 [100 90 80 70 60 50 40 30 20 10]