rust 版本：

fn merge_sort<T: Ord + Debug + Copy>(array: &mut [T], start: usize, end: usize) {    
    if start >= end {        
        return;    
    }    
    let mid = start + (end - start) / 2;    
    merge_sort(array, start, mid);    
    merge_sort(array, mid + 1, end);    
    merge(array, start, end);
}

fn merge<T: Ord + Debug + Copy>(array: &mut [T], start: usize, end: usize) {    
    println!("{array:?}");    
    let mut temp_array = Vec::with_capacity(end - start + 1);    
    for i in start..=end {        
        temp_array.push(array[i]);    
    }    
    let new_start = 0;    
    let new_end = temp_array.len() - 1;    
    let new_mid = (new_end - new_start) / 2;    
    let mut left_index = new_start;    
    let mut right_index = new_mid + 1;    
    let mut array_index = start;    
    while left_index <= new_mid && right_index <= new_end {        
        if temp_array[left_index] <= temp_array[right_index] {            
            array[array_index] = temp_array[left_index];            
            left_index += 1;        
        } else {            
            array[array_index] = temp_array[right_index];            
            right_index += 1;        
        }        
        array_index += 1;    
    }    
    while left_index <= new_mid {        
        array[array_index] = temp_array[left_index];        
        left_index += 1;        
        array_index += 1;    
    }    
    while right_index <= new_end {        
        array[array_index] = temp_array[right_index];        
        right_index += 1;        
        array_index += 1;    
    }
}

C#递归版本，仅供参考：

//归并排序算法类
class MergeTest
{
    //方法-：归并排序的如果，提供了辅助数组，调用了后续方法
    public void MergeSort(float[] arr)
    {
        if( arr.Length <= 1 ) return;

        float[] temp = new float[arr.Length];  //辅助数组

        if (temp != null)  MSort(arr, temp, 0, arr.Length - 1);  //调用递归拆分
       
    }


    //方法二： 递归拆分数组 ，并且调用合并的方法
    private void MSort(float[] arr , float[] temp ,int left , int right)  
    {
        if( left < right) //最终会使得递归得到一个元素为一组的多数组
        {
            int mid = (left+right)/2;  //left为原数组左边第一个元素下标（就是0），right是原数组右边最大下标（n-1）,mid用于拆分数组

            MSort(arr, temp, left, mid); //通过递归划分左半区
            MSort(arr, temp, mid+1, right);  //递归划分右半区

            Merge(arr, temp, left, mid, right); //调用排序并合并的方法
        }
    }

    //方法三：排序合并拆分的数组
    private void Merge(float[] arr, float[] temp , int left , int mid , int right)
    {
        int l_pos = left;  //左半区第一个未排序的元素
        int r_pos = mid + 1; //右半区第一个未排序的元素
        int pos = left;  //辅助数组的起点下标

        while(l_pos <= mid && r_pos <= right)
        {
            if(arr[l_pos] < arr[r_pos])   //逐一比较大小
            {
                temp[pos++] = arr[l_pos++]; //左边区域元素更小，就把它放入辅助数组的第一个位置，然后左边区域与辅助数组的下标向后移动一位
            }
            else temp[pos++] = arr[r_pos++]; //若右边区域元素更小，将其放入辅助数组，下标后移

        } //跳出循环就代表左右中的一边已经全部放入辅助数组了

        while( l_pos <= mid)
        {
            temp[pos++] = arr[l_pos++]; //若左区域下标还没有到达最大处，说明有剩余，直接全部复制到辅助数组最后边
        }
        while( r_pos <= right)
        {
            temp[pos++] = arr[r_pos++];//若右区域下标还没有到达最大处，说明有剩余，直接全部复制到辅助数组最后边
        }

        while(left <= right)
        {
            arr[left] = temp[left];  //从第一个下标到最后一个下标，把辅助数组的元素全部复制到原来的数组z

            left++;
        }
    }
}