计算机算法设计与分析——最优合并问题

计算机算法设计与分析（算法实现题4）

4-2 最优合并问题

• 问题描述：
  给定k个排好序的序列s1，s2，s3，…，sk，用2路合并算法将这k个序列合并成一个序列。假设采用的2路合并算法合并2个长度分别为 m 和 n 的序列需要m+n-1次比较。试设定一个算法确定合并这个序列的最优合并顺序，使所需的总比较次数最少。
  为了进行比较，还需要确定合并这个序列的最差合并序列，使所需的总比较次数最多。
• 算法设计：
  对于给定的k个待合序列，计算最多比较次数和最少比较次数合并方案。

具体代码实现：分为一个主方法，一个随机数产生方法，两个排序方法，两个合并序列方法

import java.util.Random;
import java.util.Scanner;

/**
 * @Author: 小场面
 * @Date: 20/10/27
 */
public class Realize4_2 {
    public static void main(String[] args) {
        Integer[] produceNum = produceNum();
        // 最差序列
        Integer[] sortMaxToMinArr = sortMaxToMinArr(produceNum);
        designFormulasMax(sortMaxToMinArr);
        // 最优序列
        Integer[] sortMinToMaxArr = sortMinToMaxArr(produceNum);
        designFormulasMin(sortMinToMaxArr);
    }

    /**
     * 产生序列数组
     */
    public static Integer[] produceNum(){
        System.out.println("请输入需要合并序列的个数 k：");
        // 创建输入对象
        Scanner scanner = new Scanner(System.in);
        // 创建属性，并获取输入的数据
        Integer num = Integer.valueOf(scanner.next());
        // 创建整型数组
        Integer[] arr = new Integer[num];
        for (int i = 0; i < num; i++) {
            // 创建随机函数对象
            Random random = new Random();
            // 判断随机数是否为0
            if (random.nextInt(101)!=0){
                // 随机创建1-100的数，并赋给数组
                arr[i] = random.nextInt(101);
                System.out.print(arr[i]+" ");
            }else {
                i--;
            }
        }
        System.out.println();
        return arr;
    }
    /**
     * 数组排序：从大到小
     * @param arr
     */
    public static Integer[] sortMaxToMinArr(Integer[] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = i+1; j < arr.length; j++) {
                // 如果arr数组后一个数据 > 前一个数据，这两个数据则交换位置
                if (arr[j]>arr[i]){
                    Integer temp;
                    temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        return arr;
    }
    /**
     * 数组排序：从小到大
     * @param arr
     */
    public static Integer[] sortMinToMaxArr(Integer[] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = i+1; j < arr.length; j++) {
                // 如果arr数组后一个数据 < 前一个数据，这两个数据则交换位置
                if (arr[j]<arr[i]){
                    Integer temp;
                    temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        return arr;
    }

    /**
     * 计算最差合并序列
     * design formulas：计算公式
     * @param arr
     */
    public static void designFormulasMax(Integer[] arr){
        // 创建整型数组，把每次相加的和放入数组中
        Integer[] sumArr = new Integer[arr.length-1];
        // 创建整型属性，用于存放当前两个数相加的和，并初始化数据为arr数组中的第一个数据
        Integer sum = arr[0];
        for (int i = 1; i < arr.length; i++) {
            // 计算数组中最大两个数的和
            sum = sum+arr[i]-1;
            // 把相加的和放入数组中，应为i从1开始，所以这里要-1
            sumArr[i-1] = sum;
        }
        int sums=0;
        for (int i = 0; i < sumArr.length; i++) {
            // 把数组中的数据相加，求得最多比较的次数
            sums = sums+sumArr[i];
//            System.out.print(sumArr[i]+" ");
        }
        System.out.println("最多比较的次数为："+sums);
    }

    /**
     * 计算最优合并顺序
     * @param arr
     */
    public static void designFormulasMin(Integer[] arr){
        // 创建整型数组，把每次相加的和放入数组中，这里数组长度-1是因为arr数组中每两个数相加的和放入sumArr数组后要少1
        Integer[] sumArr = new Integer[arr.length-1];
        // 创建整型属性，用于存放当前两个数相加的和
        Integer sum;
        // 创建整型属性，用于判断循环是否该结束，以及向sumArr第n-1位置添加数据
        Integer n=1;
        // 循环arr数组中的数据
        for (int i = 1; i < arr.length; i++) {
            // 计算arr数组中第1、2和数据的和，然后-1，并存入sum中
            sum = arr[i]+arr[i-1]-1;
            // 把得到的和存入sumArr数组中
            sumArr[n-1] = sum;
            // 创建一个临时数组， 和
            Integer[] tempArr = new Integer[arr.length-n];
            // 把相加的和放入临时数组的第一个位置
            tempArr[0] = sum;
            // 把arr数组中剩余的数据赋值给临时数组
            for (int j = 1; j < tempArr.length; j++) {
                tempArr[j] = arr[j+1];
            }
            // 对临时数组tempArr进行按从小到大的顺序重排序
            Integer[] toMinArr = sortMinToMaxArr(tempArr);
            // 把arr数组中的数据清空
            for (int j = 0; j < arr.length; j++) {
                arr[j] = 0;
            }
            // 把toMinArr数组中的数据赋值给arr数组，用于下次循环
            for (int j = 0; j < toMinArr.length; j++) {
                arr[j] = toMinArr[j];
            }
            // 把i赋值为0，让循环一直在arr数组的第1、2个数据进行求和，即求arr数组中最小两个数的和
            i=0;
            n++;
            // 判断arr数组长度是否为0，是则结束此循环
            if (arr.length-n == 0){
                break;
            }
        }
        int sums = 0;
        // 对sumArr数组中的数据进行求和
        for (int i = 0; i < sumArr.length; i++) {
            // 把数组中的数据相加，求得最少比较的次数
            sums = sums + sumArr[i];
//            System.out.print(sumArr[i]+" ");
        }
        System.out.println("最少比较的次数为："+sums);
    }
}

运行结果