父子树递归和冒泡、快速排序

1、递归遍历设置树结构

// 递归遍历设置树结构
    public List<XfDictStatisticModel> buildSourceChildren(List<XfDictStatisticModel> sourceTreeList, String fatherId){
        List<XfDictStatisticModel> resultList = new ArrayList<>();
        List<XfDictStatisticModel> childrenList = sourceTreeList.stream().filter(streamSource->fatherId.equals(streamSource.getParentId())).collect(Collectors.toList());
        for(XfDictStatisticModel child : childrenList){
            child.setChildren(buildSourceChildren(sourceTreeList, child.getSourceId()));
            resultList.add(child);
        }
        return resultList;
    }

找出第一层遍历，在内部递归，递归完了再add进集合

2、递归找出当前节点所有子节点

// 递归找出当前节点所有子节点
                recursiveGetAllSons(sourceTreeList, sourceNode.getSourceId());

// 递归获取某节点下的所有子节点
    public void recursiveGetAllSons(List<XfDictStatisticModel> sourceTreeList, String fatherId ){
        List<XfDictStatisticModel> childrenList = sourceTreeList.stream()
                .filter(streamSourceTree->fatherId.equals(streamSourceTree.getParentId()))
                .collect(Collectors.toList());
        if(childrenList != null && childrenList.size()!=0){
            this.allSonsSourceList.addAll(childrenList);
            for(XfDictStatisticModel child : childrenList){
                recursiveGetAllSons(sourceTreeList, child.getSourceId());
            }
        }
    }

sourceTreeList是所有值一起的数据源，不动

3、冒泡排序

// 指数转换成对数 2^m = n -> m = log(2)n （循环m次，每次乘以2，最后值为n）
    // 时间复杂度基本操作执行的次数
    @Test // 冒泡排序
    public void a (){
        int[] intArr = {1,9,9,5,0,1,1,3,0,9,22};
        for(int i=0; i<intArr.length-1; i++){ // 比的趟数
            for(int j=0; j<intArr.length-1-i; j++){ // 每一趟少比一个数，真正比较的操作
                if(intArr[j]<intArr[j+1]){
                    int temp = intArr[j];
                    intArr[j] = intArr[j+1];
                    intArr[j+1] = temp;
                }
            }
        }
        for(int a : intArr){
            System.out.print(a+",");
        }
    }

4、快速排序

// 快速排序
    // 获取基数索引
    private static int getPivotIndex(int[] arr, int start, int end){
        int pivot = arr[start]; // 基数值设置为第一个数
        while(start<end){
            while((start<end)&&(arr[end]>=pivot)){
                end--;
            }
            arr[start] = arr[end];
            while((start<end)&&(arr[start]<=pivot)){
                start++;
            }
            arr[end] = arr[start];
        }
        arr[start] = pivot; // 分两边之后基数的正确索引
        return start;
    }

    private static void quickSort(int[] arr, int start, int end){
        if(start<end){
            int pivotIndex = getPivotIndex(arr, start, end);
            quickSort(arr, start, pivotIndex-1);
            quickSort(arr, pivotIndex+1, end);
        }
    }

    @Test
    public void testQuickSort(){
        int arr[] = new int[]{3,3,3,7,9,122344,4656,34,34,4656,5,6,7,8,9,343,57765,23,12321};
        quickSort(arr,0,arr.length-1);
        for (int i:arr) {
            System.out.print(i+"	");
        }
    }

5、