比较冒泡法，选择法以及二叉树排序的性能区别

创建4万个随机数，然后用分别用冒泡法，选择法，二叉树3种排序算法进行排序，比较哪种更快

排序：选择排序和冒泡排序

package collection;
  
import java.util.ArrayList;
import java.util.List;
  
public class Node {
    
    
    // 左子节点
    public Node leftNode;
    // 右子节点
    public Node rightNode;
    // 节点值
    public Object value;
      
    // 插入数据
    public void add(Object v) {
    
    *}
      
    // 中序遍历所有节点，从左到右排列
    public List<Object> values() {
    
     *}
      
    public void nums(List<Integer> a){
    
    
        // 随机生成4万个数
        for (int i = 0; i <40000; i++) {
    
    
            int num = (int) (Math.random()*(999 + 1));
            a.add(num);
        }   
    }
      
    // 冒泡排序
    public void mpNums(List<Integer> a) {
    
    
        for (int n = 0; n < a.size(); n++)
                for (int m = 0; m < a.size()-n-1; m++){
    
    
                        if (a.get(m) > a.get(m+1)){
    
     
                            Integer t = a.get(m);
                            a.set(m, a.get(m+1));
                            a.set(m + 1, t);
                            }
                }
    }
      
    // 选择排序
    public void xzNums(List<Integer> a) {
    
    
        for (int k = 0;k < a.size(); k++)
            for(int l = k + 1; l < a.size(); l++)
                if (a.get(k) > a.get(l)){
    
     
                    Integer t = a.get(k);
                    a.set(k, a.get(l));
                    a.set(l, t);
                    }
    }
      
    public static void main(String[] args) {
    
    
        Node node = new Node(); 
        List<Integer> a = new ArrayList<>();
        // 插入数据
        node.nums(a);
          
        for (int c: a)
            node.add(c);    
        // 二叉树排序性能
        node.values();
          
        // 冒泡排序性能
        node.mpNums(a);
          
        // 选择排序性能
        node.xzNums(a);
    }
}

package JiHe;

import java.util.ArrayList;
import java.util.List;

public class Node3 {
    
    
    //左子节点
    public Node3 leftNode;
    //右子节点
    public Node3 rightNode;

    //值
    public Object value;

    //插入数据
    public void add(Object v) {
    
    
        //如果当前节点没有值，就把数据放在当前节点上
        if (null == value)
            value = v;

            //如果当前节点有值，就进行判断，新增的值与当前值的大小关系
        else {
    
    
            //新增的值，比当前的值小或者相同
            if ((Integer) v - ((Integer) value) <= 0) {
    
    
                if (null == leftNode) {
    
    
                    leftNode = new Node3();
                    leftNode.add(v);//左小右大
                }
            }
            //新增的值，比当前值大
            else {
    
    
                if (null == rightNode)
                    rightNode = new Node3();
                rightNode.add(v);
            }
        }
    }

    //中序遍历所有的节点
    public List<Object> values(){
    
    
        List<Object> values=new ArrayList<>();

        //左节点的遍历结果
        if (null!=leftNode)
            values.addAll(leftNode.values());

        //当前节点
        values.add(value);

        //右节点的遍历
        if(null!=rightNode)
        {
    
    values.addAll(rightNode.values());}

        return values;


    }

    public void nums(List<Integer> a) {
    
    
        // 随机生成4万个数
        for (int i = 0; i < 40000; i++) {
    
    
            int num = (int) (Math.random() * (999 + 1));
            a.add(num);
        }
    }

    //冒泡排序
    public void mpNums(List<Integer> a){
    
    
        long start = System.currentTimeMillis();
        for(int n=0;n<a.size();n++)
            for(int m=0;m<a.size()-n-1;m++){
    
    
                if (a.get(m) > a.get(m+1)){
    
    
                    Integer t = a.get(m);
                    a.set(m, a.get(m+1));
                    a.set(m + 1, t);
                }
            }
        long end=System.currentTimeMillis();
        System.out.println("冒泡排序耗费时间:"+(end-start));
    }

    // 选择排序
    public void xzNums(List<Integer> a) {
    
    
        long start = System.currentTimeMillis();
        for (int k = 0;k < a.size(); k++)
            for(int l = k + 1; l < a.size(); l++)
                if (a.get(k) > a.get(l)){
    
    
                    Integer t = a.get(k);
                    a.set(k, a.get(l));
                    a.set(l, t);
                }
        long end = System.currentTimeMillis();
        System.out.println("选择排序耗费时间:"+(end-start));
    }

    public static void main(String[] args) {
    
    
        Node3 node3=new Node3();
        List<Integer> a=new ArrayList<>();

        long start=System.currentTimeMillis();
        //插入数据
        node3.nums(a);
        for (int c: a)
            node3.add(c);

        // 二叉树排序性能
        node3.values();
        long end=System.currentTimeMillis();
        System.out.println("二叉树耗费时间:"+(end-start));
        // 冒泡排序性能
        node3.mpNums(a);

        // 选择排序性能
        node3.xzNums(a);

    }

    }