山东科技大学 PTA(Java)身份证排序

  1. 输入n,然后连续输入n个身份证号。
  2. 然后根据输入的是sort1还是sort2,执行不同的功能。输入的不是sort1或sort2,则输出exit并退出。
    输入sort1,将每个身份证的年月日抽取出来,按年-月-日格式组装,然后对组装后的年-月-日升序输出。
    输入sort2,将所有身份证按照里面的年月日升序输出。

注意:处理输入的时候,全部使用ScannernextLine()方法,以免出错。

输入样例:

6
410425198309308225
320203197206115011
431227196108033146
330226196605054190
34080019810819327X
320111197112301539
sort1
sort2
e

输出样例:

1961-08-03
1966-05-05
1971-12-30
1972-06-11
1981-08-19
1983-09-30
431227196108033146
330226196605054190
320111197112301539
320203197206115011
34080019810819327X
410425198309308225
exit

 

import java.util.*;

public class Main
{
    public static void main(String []args)
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        String[] ids = new String[n];
        long[] values = new long[n];
        for(int i=0;i<n;i++)
        {
            ids[i] = sc.nextLine();
            values[i] = Long.parseLong(ids[i].substring(6,14));
        }
        for(int i=0;i<n-1;i++)
        {
            for(int j=0;j<n-i-1;j++)
            {
                if(values[j]>values[j+1])
                {
                    long temp = values[j];
                    String t = ids[j];
                    values[j] = values[j+1];
                    ids[j] = ids[j+1];
                    values[j+1] = temp;
                    ids[j+1] = t;
                }
            }
        }
        while(true)
        {
            String line = sc.nextLine();
            if(line.equals("sort1"))
            {
                for(int i=0;i<n;i++)
                {
                    System.out.println(ids[i].substring(6,10)+"-"+ids[i].substring(10,12)+"-"+ids[i].substring(12,14));
                }
            }
            else if(line.equals("sort2"))
            {
                for(int i=0;i<n;i++)
                {
                    System.out.println(ids[i]);
                }
            }
            else
            {
                System.out.println("exit");
                break;
            }
        }
    }
}
输入输出:

 对sc的理解不够,nextInt不消耗换行符。

nextLine返回字符串

if里写nextLine会吃掉输入,造成sort2读不到输入

排序:

sort排序忘记交换id了

数据处理:

排序标准没想清楚,看清楚排序数据,看好交换内容,选对数据结构。

### 回答1: 以下是使用 Java 实现快速排序的示例代码: ``` public class QuickSort { public static void quickSort(int[] arr, int left, int right) { if (left < right) { int partitionIndex = partition(arr, left, right); quickSort(arr, left, partitionIndex - 1); quickSort(arr, partitionIndex + 1, right); } } private static int partition(int[] arr, int left, int right) { int pivot = left; int index = pivot + 1; for (int i = index; i <= right; i++) { if (arr[i] < arr[pivot]) { swap(arr, i, index); index++; } } swap(arr, pivot, index - 1); return index - 1; } private static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } public static void main(String[] args) { int[] arr = {4, 6, 2, 9, 1, 5, 8, 3, 7}; quickSort(arr, 0, arr.length - 1); System.out.println(Arrays.toString(arr)); } } ``` 在这个示例中,我们使用了经典的 Lomuto 分区方案,也可以使用 Hoare 分区方案或其他方法。快速排序的时间复杂度为 O(nlogn),空间复杂度为 O(logn)。 ### 回答2: 快速排序是一种常用的排序算法,其基本思想是通过分治的方式将待排序的数组分成两部分,一部分的元素都小于等于基准元素,另一部分的元素都大于等于基准元素,然后递归地对这两部分进行排序,最终得到一个有序的数组。 在快速排序中,首先需要选择一个基准元素,一般选择数组的第一个元素。接下来,需要定义两个指针i和j,分别指向数组的起始位置和末尾位置。然后,通过不断地移动指针i和j,将数组中比基准元素小的元素移到基准元素的左边,大于等于基准元素的元素移动到基准元素的右边。最后,将基准元素放到合适的位置,以使得左半边的元素都小于等于基准元素,右半边的元素都大于等于基准元素。 接着,使用递归的方式对基准元素左边和右边的子数组进行排序,直到全部的子数组长度为1或者0时终止递归。最终,当递归返回时,整个数组就变为有序的。 快速排序的时间复杂度为O(nlogn),其中n是待排序数组的大小。虽然其最坏情况下的时间复杂度为O(n^2),但是在大部分情况下,快速排序的效率非常高。 在Java中实现快速排序可以通过以下代码实现: ```java public class QuickSort { public static void quickSort(int[] arr, int low, int high) { if (low < high) { int pivotIndex = partition(arr, low, high); // 获取基准元素的位置 quickSort(arr, low, pivotIndex - 1); // 对基准元素的左边子数组进行排序 quickSort(arr, pivotIndex + 1, high); // 对基准元素的右边子数组进行排序 } } public static int partition(int[] arr, int low, int high) { int pivot = arr[low]; // 选择数组第一个元素作为基准元素 int i = low, j = high; while (i < j) { // 从右往左找到第一个小于基准元素的元素 while (i < j && arr[j] >= pivot) { j--; } if (i < j) { arr[i] = arr[j]; // 将小于基准元素的元素移到左边 i++; } // 从左往右找到第一个大于基准元素的元素 while (i < j && arr[i] <= pivot) { i++; } if (i < j) { arr[j] = arr[i]; // 将大于基准元素的元素移到右边 j--; } } arr[i] = pivot; // 将基准元素放到合适的位置 return i; // 返回基准元素的位置 } public static void main(String[] args) { int[] arr = {5, 3, 8, 6, 2, 7, 1, 4}; // 待排序的数组 int len = arr.length; quickSort(arr, 0, len-1); // 调用快速排序函数 System.out.println("排序后的数组:"); for (int i = 0; i < len; i++) { System.out.print(arr[i] + " "); } } } ``` 以上就是使用Java实现快速排序的代码。该代码首先定义了`QuickSort`类,其中包含了两个函数`quickSort`和`partition`。通过调用`quickSort`函数,传入待排序数组和起始位置和结束位置,即可完成快速排序。最后,排序后的数组结果。 ### 回答3: 快速排序(Quick Sort)是一种常用的排序算法,它的实现思想是通过分治法将一个大问题分解为若干个小问题进行处理,最终将这些小问题的解合并起来得到整体的解。 在 Java 中实现快速排序需要用到递归和分治的技巧。具体步骤如下: 1. 在选择用来划分子数组的元素时,我们通常选择一个称为“枢纽元”的值。一种常见的选择方法是选择子数组的第一个元素作为枢纽元。 2. 然后,我们将数组划分为两个子数组,将小于或等于枢纽元的元素放在左侧子数组中,将大于枢纽元的元素放在右侧子数组中。 3. 在划分子数组后,我们对左侧子数组和右侧子数组分别递归地应用快速排序算法,直到子数组的大小为1或0时停止递归。 4. 最后,将所有子数组按照顺序合并起来,得到已排序的整个数组。 下面是一个简单的使用 Java 实现快速排序的代码示例: ```java public class QuickSort { public static void quickSort(int[] array, int start, int end) { if (start < end) { int pivotIndex = partition(array, start, end); quickSort(array, start, pivotIndex - 1); quickSort(array, pivotIndex + 1, end); } } private static int partition(int[] array, int start, int end) { int pivot = array[start]; int i = start + 1; for (int j = start + 1; j <= end; j++) { if (array[j] < pivot) { swap(array, i, j); i++; } } swap(array, start, i - 1); return i - 1; } private static void swap(int[] array, int i, int j) { int temp = array[i]; array[i] = array[j]; array[j] = temp; } public static void main(String[] args) { int[] array = {5, 2, 9, 1, 7, 6, 3}; quickSort(array, 0, array.length - 1); System.out.println(Arrays.toString(array)); } } ``` 以上就是使用 Java 实现快速排序的基本步骤和一个简单的代码示例。快速排序的平均时间复杂度为 O(nlogn),但在最坏情况下可能会达到 O(n²)。它是一种高效的排序算法,在实际应用中非常常见。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值