为了13行冒泡排序代码，写了235行，还没写完 - 编程导航 | 一线开发者编程经验和技术实战分享

▼
text
复制代码
/**
 * 输入N个套餐价格存入数组→手写冒泡排序→从低到高输出→输出最划算套餐及其序号
 * <p>
 * 注意：
 * 1  提示“请输入一个或多个装修套餐的金额（0金额为免费套餐，空格或逗号分开，输入：exit，回车退出）：”
 * 2  接收输入
 * 2.1  检查是否输入了 exit，是就提示”谢谢您，See you next.”结束，不是就进行 2.2
 * 2.2  检查是否空输入，空输入就提示“空数据，请重新输入！”，不是就进行 3
 * 3  拆解成段，每段 strip()，保存到数组 originalValues[](原始数据的数组）、originalIndexs[](序号数据的数组）
 * 3.1  每段检查是否为空、空的就丢弃,进行 3.3.2
 * 3.2  检查是否为数字，不是数字就丢弃，进行 3.3.2
 * 3.3  转换成 double类型，检查数字是否有效（负数、大于 10000的都是无效）
 * 3.3.1  有效数据保存到新数组 validValues[](有效数据的数组）validIndexs[](有效序号的数组，序号按照保存的顺序）
 * 3.3.2  无效数据保存到新数组 invalidValues[]（无效数据的数组）
 * 4  有效数据和无效数据输出
 * 4.1  只有无效数据：输出“您输入的有效数据有 0 个”“您输入的无效数据有……个”“请重新输入！“，进行 1
 * <p>
 * 4.2  只有有效数据：
 * 4.2.1  没有重复数据：
 * 输出“您输入的有效数据有……个“
 * 提示”确定保存吗（Y-保存 N-重新输入）？“
 * 4.2.1.1  Y-保存，保存到新数组 cleanedValues[]、cleanedIndexs[]（拷贝validIndexs[]）,进行 5
 * 4.2.1.2  N-重新输入，进行 1
 * <p>
 * 4.2.2  有重复数据：
 * 输出““您输入的数据有……个，其中……个是重复数据“，
 * 提示”重复数据只保留第一个，顺序自动更改，确定保存吗（Y-保存 N-重新输入）？”
 * 4.2.2.1  Y-保存，去重，保留第一个重复的，保存到新数组 cleanedValues[]、cleanedIndexs[]（序号按照保存的顺序）,进行 5
 * 4.2.2.2  N-重新输入，进行 1
 * <p>
 * 4.3  有有效数据和无效数据：
 * 4.3.1  有效数据无重复：
 * 输出“您输入的有效数据有……个“，“您输入的无效数据有……个“，
 * 提示“无效数据将被丢弃，确定保存吗（Y-保存 N-重新输入）？“
 * 4.3.1.1  Y-保存，保存到新数组 cleanedValues[]、cleanedIndexs[]（拷贝validIndexs[]）,进行 5
 * 4.3.1.2  N-重新输入，进行 1
 * 4.3.2  有效数据有重复：
 * 输出“您输入的有效数据有……个“，“您输入的无效数据有……个“，空的无效数据要翻译输出（显示“空”）
 * 提示“无效数据将被丢弃，重复数据只保留第一个，顺序自动更改，确定保存吗（Y-保存 N-重新输入）？“
 * 4.3.2.1  Y-保存，保存到新数组 cleanedValues[]、cleanedIndexs[]（序号按照保存的顺序）,进行 5
 * 4.3.2.2  N-重新输入，进行 1
 * <p>
 * 5  排序
 * 5.1  只有一个数据，不排序，直接输出，进行 6
 * 5.2  两个或两个以上的数据，排序后输出
 * 5.2.1  cleanedValues[]元素 1和后面的数据敝比较，大的是元素 1就交换位置，最终不交换位置了，记下下标
 * 5.2.2  cleanedIndexs[]元素 1转换到 cleanedValues[]元素 1最后位置的下标
 * 5.2.3  重复 5.2.1和 5.2.2
 * 5.3  保存到新数组 tempValues[]、tempfirmIndexs[]
 * <p>
 * 6  格式化输出
 * 6.1  ”您输入的装修套餐金额是：……“
 * “套餐金额对应的序号是：……”
 * "最划算的金额是：……【序号……】
 * 6.2  金额和序号左对齐
 * 6.3  提示”还要再输入一组套餐金额吗？（Y-再来一组 N-退出“
 * 6.3.1  Y-再来一组，进行 1
 * 6.3.2  N-退出
 * <p>
 * 7  测试：（正常/空输入/含字母/含负数/超10000/全重复/单个0）
 *
 */

import java.util.Scanner;

public class Day20PackagePriceSort {
    private static final String IN_TIP = "请输入一个或多个装修套餐的金额（0金额为免费套餐，空格或逗号分开，输入：exit，回车退出）：";
    private static final String EMPTY_TIP = "空数据，请重新输入！";

    private static final String DUPLICATE_DATA_CONFIRM_TIP = "重复数据只保留第一个，顺序自动更改，确定保存吗（Y-保存 N-重新输入）？";
    private static final String INVALID_DATA_CONFIRM_TIP = "无效数据将被丢弃，确定保存吗（Y-保存 N-重新输入）？";
    private static final String CONFIRM_TIP = "确定保存吗（Y-保存 N-重新输入）？";
    private static final String AGAIN_TIP = "还要再输入一组套餐金额吗？（Y-再来一组 N-退出）";
    private static final String EXIT_TIP = "谢谢您，See you next.";
    private static final String PRINT_PRICE_TIP = "有效装修套餐的金额是：";
    private static final String PRINT_PRICE_INDEX_TIP = "套餐金额对应的序号是：";
    private static final String PRINT_INDEX_TIP = "有效数据对应的序号是：";
    private static final String INVALID_TIP = "您输入的数据无效，请重新输入！";
    private static final String PRINT_LINE = "----------------------------------------------------------------------------------------------------------";

    private static final String VALID_DATA_FMT = "【您输入的有效数据有 %3d 个】";
    private static final String INVALID_DATA_FMT = "【您输入的无效数据有 %3d 个】";
    private static final String NO_DUPLICATE_FMT = "【重复的数据有 %3d 个】";
    private static final String UNIT_FMT = " + %,8.2f 元/m²    ";
    private static final String PRINT_BEST_FMT = "最划算的套餐：序号 %,-2d，套餐金额 %,8.2f 元/m²";

    private static final double MIN_PACKAGE_PRICE = 0;//  套餐金额的最小值（包含）
    private static final double MAX_PACKAGE_PRICE = 10000;  //  套餐金额的最大值（不包含）


    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (true) {
            System.out.println("\n\n");
            System.out.print(IN_TIP);
            String line = in.nextLine();

            if (line == null || line.isBlank()) {    //检查是否空输入，空输入就提示“空数据，请重新输入！”
                System.out.println(EMPTY_TIP);
            } else {
                if ("exit".equals(line.strip()) || "EXIT".equals(line)) {
                    System.out.println(EXIT_TIP);
                    return;   //  exit或EXIT退出
                } else {
                    //  第三步：拆解成段，每段 strip()
                    String[] parts = line.split("[,，\\s]+");   //  以中英文逗号或空格为标志拆解

                    double[] validValues = new double[parts.length];
                    int[] validIndexs = new int[parts.length];
                    String[] invalidValues = new String[parts.length];

                    int validCount = 0;
                    int invalidCount = 0;

                    //  每段检查是否为空、非数字，无效数据保存到invalidValues[],该数组不需要保存序号”
                    for (int i = 0; i < parts.length; i++) {
                        String segment = parts[i].strip();
                        //  段的数据为空或非数字或负数，保存到invalidValues[]
                        if (!segment.matches("\\d+(\\.\\d+)?")) {
                            invalidValues[invalidCount++] = segment;
                            continue;
                        }
                        //  判断数字是否有效（大于10000的无效），无效数据保存到invalidValues[]
                        double v = Double.parseDouble(segment);
                        if (v > 10000) {
                            invalidValues[invalidCount++] = segment;
                            continue;
                        }
                        //  有效数据保存到validValues[],同时保存序号到validIndexs[]，序号从1开始
                        validValues[validCount] = v;
                        validIndexs[validCount] = i + 1;
                        validCount++;
                    }

                    //  第四步：有效数据和无效数据输出，用户确定后进行排序
                    //  TODO: 没有有效数据，直接输出
                    if (validCount == 0) { }
                    //TODO:只有一个有效数据，直接输出
                    if (validCount == 1) { }

                    //  TODO:去重,两个或以上的有效数据
                    int cleanedCount = 0;   //  去重计数器
                    double[] cleanedValidValues = new double[validCount];   //  有效数据去重后的数组
                    int[] cleanedIndexs = new int[validCount];
                    if (validCount >= 1) {

                        for (int i = 0; i < validCount; i++) {
                            boolean isDuplicate = false;
                            for (int j = 0; j < cleanedCount; j++) {
                                if (cleanedValidValues[j] == validValues[i]) {
                                    isDuplicate = true;
                                    break;
                                }
                            }
                            if (!isDuplicate) {
                                cleanedValidValues[cleanedCount] = validValues[i];
                                cleanedIndexs[cleanedCount] = validIndexs[i];
                                cleanedCount++;
                            }
                        }
                    }
                    System.out.println("拆解后的有效数据：");
                    for (int i = 0; i < cleanedCount; i++) {
                        System.out.print(validValues[i] + "    ");
                    }
                    System.out.println();
                    System.out.println("去重后的有效数据：");
                    for (int i = 0; i < cleanedCount; i++) {
                        System.out.print(cleanedValidValues[i] + "    ");
                    }
                    System.out.println();
                    System.out.println("去重后的原始下标：");
                    for (int i = 0; i < cleanedCount; i++) {
                        System.out.print(cleanedIndexs[i] + "    ");
                    }

                    //第五步：排序
                    System.out.println("\n" + CONFIRM_TIP);
                    line = in.nextLine();
                    String selection = line.strip().toUpperCase();
                    if ("N".equals(selection)) {
                        System.out.println(EXIT_TIP);
                        continue;
                    }
                    if ("Y".equals(selection)) {
                        //  如果只有一个数据，及直接输出，不用排序
                        //  TODO:
                        //  排序操作,用第一个元素和第二个比较，1>2,即2 = 1，以此类推
                        for (int i = 0; i < cleanedValidValues.length; i++) {
                            for (int j = i + 1; j < cleanedCount; j++) {
                                if (cleanedValidValues[i] > cleanedValidValues[j]) {
                                    double tempValue = cleanedValidValues[j];
                                    cleanedValidValues[j] = cleanedValidValues[i];
                                    cleanedValidValues[i] = tempValue;

                                    int tempIdx = cleanedIndexs[j];
                                    cleanedIndexs[j] = cleanedIndexs[i];
                                    cleanedIndexs[i] = tempIdx;
                                }
                            }
                        }

                        //  第六步：格式化输出排序数据和最划算金额及其序号
                        //  获取最大金额的数据，千分位输出后获取长度
                        double max = cleanedValidValues[cleanedCount - 1];
                        String maxStr = String.format("%,.2f", max);
                        int maxLength = maxStr.length();
                        System.out.printf("\n" + PRINT_LINE);
                        System.out.print("\n" + PRINT_PRICE_TIP);
                        for (int i = 0; i < cleanedCount; i++) {
                            System.out.printf("%," + maxLength + ".2f    ", cleanedValidValues[i]);
                        }

                        System.out.print("\n" + PRINT_PRICE_INDEX_TIP);
                        for (int i = 0; i < cleanedCount; i++) {
                            System.out.printf("%" + maxLength + "d    ", cleanedIndexs[i]);
                        }

                        System.out.println("\n" + PRINT_LINE);
                        System.out.printf(PRINT_BEST_FMT, cleanedIndexs[0], cleanedValidValues[0]);

                        //第七步：继续还是返回
                        System.out.println("\n" + AGAIN_TIP);
                        line = in.nextLine();
                        String again = line.strip().toUpperCase();
                        if ("N".equals(again)) {
                            System.out.println(EXIT_TIP);
                            return;
                        }
                    }
                }
            }
        }
    }
}