归并排序~

news2024/11/22 9:27:59

将一个无序系列，分成小系列，相邻两个小系列进行排序合并，再将两个相邻小系列排序合并，。。。。

int[] data = {0,5,4,8,9,3,2,67,23}

len = 9

第一次每个元素一组 0,5,4,8,9,3,2,67,23

相邻排序合并 0 5，4 8，3 9，2 67，23

第二次2个元素一组

相邻排序合并 0 4 5 8，2 3 9 67，23

第三次4个元素一组

按思路写。。。。

public static void sort(){
        int[] data = {0,5,4,8,9,3,2,67,23};
        int len = data.length;


        for(int arr_size =1;arr_size<len && len/arr_size>1;arr_size*=2){
            int group_cnt = len/arr_size;
            int group_div = len%arr_size;

            for(int i=0,j=1;i<group_cnt&&j<group_cnt;i+=2,j+=2){
                int first_index = arr_size*i,second_index=arr_size*j;
                ArrayList<Integer> listarr = new ArrayList<>();
                int first_offset = 0,second_offset=0;

                for(;first_offset<arr_size&&second_offset<arr_size;){
                    //sort
                    if(data[first_index+first_offset]<data[second_index+second_offset]){
                        listarr.add(data[first_index+first_offset]);
                        first_offset++;
                    }else{
                        listarr.add(data[second_index+second_offset]);
                        second_offset++;
                    }
                }

                if(first_offset < second_offset){
                    for(;first_offset < arr_size;first_offset++){
                        data[second_index+first_offset] = data[first_index+first_offset];
                    }
                }

                for(int copy =0;copy<listarr.size();copy++){
                    data[first_index+copy]=listarr.get(copy);
                }

            }

            if(group_div == 1){
                //group_cnt * arr_size ~len
                /*int first_index = group_cnt * arr_size;
                for(int start_index =  first_index+ 1;start_index <= len -1;start_index++){
                    int insert_data = data[start_index];
                    for(int i = start_index -1;i >=first_index;i--){
                        if(data[i]>insert_data){
                            data[i+1]=data[i];
                        }else{
                            data[i+1]=insert_data;
                            break;
                        }
                    }
                }*/
                if(group_cnt == 2){
                    //group_cnt * arr_size ~len
                    int first_index = group_cnt * arr_size;
                    for(int start_index =  first_index;start_index <= len -1;start_index++){
                        int insert_data = data[start_index];
                        for(int i = start_index -1;i >=0;i--){
                            if(data[i]>insert_data){
                                data[i+1]=data[i];
                            }else{
                                data[i+1]=insert_data;
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

自底向上，这回溯了

自顶向下分治，递归，才是正解！！！！