[javaSE] 数组（排序-冒泡排序）

两层嵌套循环，外层控制循环次数，内层循环进行比较

for(int x=0;x<arr.length-1;x++){
            int y=0;y<arr.length;y++){
                if(arr[y]>arr[y+1]){
                    
                }
            }
        }

此时的代码有问题，内层循环多比较了已经排好序的部分，都在最后面，需要去掉

        int y=0;y<arr.length-x;y++]){
                    
                }
            }
        }

此时的代码有问题，内层循环最后一个元素，无法和它后面的比较，应该去掉

        int y=0;y<arr.length-x-1;y++]){
                    
                }
            }
        }

判断完后，两个变量交换位置，利用第三方变量

        ]){
                    int temp=arr[y];
                    arr[y]=arr[y+1];
                    arr[y+1]=temp;
                }
            }
        }

java版：

public class ArrayDemo {

    /**
     * @param args
     */
    static void main(String[] args) {
        int[] arr=new int[]{2,5,4,1};
        int[] newArr=bubbleSort(arr);
        int x:newArr){
            System.out.print(x);
        }
    }

    
     * 冒泡排序（正序）
     *  arr
     * @return
     int[] bubbleSort([] arr){
        temp;
                }
            }
        }
        return arr;
    }
}

PHP版：

<?PHP
 ArrayDemo{
    function main(){
        $arr=array(2,1)">);
        print_r(ArrayDemo::bubbleSort($arr));//输出 Array ( [0] => 1 [1] => 2 [2] => 4 [3] => 5 )
    }
    
    /**
     * 冒泡排序（正序）
     * @param arr
     * @return
     function bubbleSort($arr){
        for($x=0;$x<count($arr)-1;$x++$y=0;$y<$arr)-$x-1;$y++if($arr[$y]>$y+1]){
                    $temp=$y];
                    $y]=$y+1]=$temp;
                }
            }
        }
        return ;
    }

}

ArrayDemo::main();

选择排序和冒泡排序性能都很低，提高性能的方法，当需要换位置的时候，先不换，先把需要换位置的角标放到栈内存中，等最后一次性在堆内存中交换

排序中最快的是希尔排序

[javaSE] 数组（排序-冒泡排序）

猜你在找的Java SE相关文章