字符串排序

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    volatile static String[] str1 = null;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String[] a = in.nextLine().split("");
            List<String> b = new ArrayList<>();
            for (int i = 0 ; i < a.length ; i ++ ) {
                if (a[i].matches("[a-zA-Z]")) {
                    b.add(a[i]);
                }
            }
            mergeSort(b);
            int index = 0 ;
            for (int i = 0 ; i < a.length ; i ++ ) {
                if (a[i].matches("[a-zA-Z]")) {
                     System.out.print(str1[index]);
                     index++;
                }else{
                    System.out.print(a[i]);
                }
            }
        }
    }

    //归并排序
    private static void mergeSort(List<String> list) {

        int length = list.size();
        String[] str = list.toArray(new String[0]);
        str1 = str.clone();
        int left = 0;
        int right = length - 1;
        int mid = (left + right) / 2 ;
        merge(str, left, right, mid);
    }

    private static void merge(String[] str, int left, int mid, int right) {
        //递归深入
        if (left < right ) {
            //向左排序
            merge(str, left, (left + mid) / 2, mid);
            //向右排序
            merge(str, mid + 1, (mid + right) / 2, right);
            //归并算法
            mergeCore(str, left, right, mid);
        }
    };

    private static void mergeCore(String[] str, int left, int right, int mid) {
        int min = left ;
        int max = mid + 1 ;
        int index = left ;
        while (min <= mid && max <= right) {
            if (str1[min].toUpperCase().compareTo(str1[max].toUpperCase()) > 0) {
                str[index] = str1[max];
                max ++ ;
            } else {
                str[index] = str1[min];
                min ++ ;
            }
            index ++ ;
        }
        while (min <= mid) {
            str[index] = str1[min];
            min ++ ;
            index ++ ;
        }
        while (max <= right) {
            str[index] = str1[max];
            max ++ ;
            index ++ ;
        }
        str1 = str.clone();
    }

}

import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        char[] chars = str.toCharArray();
        // 保存其他字符的index
        HashSet<Integer> set = new HashSet<>();
        // 保存英文字符的map,key为每个不分大小写的字符（转成小写）,value为该字符对应的所有字符
        HashMap<Character, ArrayList<Character>> eMap = new HashMap<>();
        char[] resArr = new char[str.length()];
        for (int i = 0; i < chars.length; i++) {
            if (isEnglish(chars[i])) {
                // 英文字符则加到map中的list里
                char c = Character.toLowerCase(chars[i]);
                if (eMap.containsKey(c)) {
                    eMap.get(c).add(chars[i]);
                } else {
                    ArrayList<Character> list = new ArrayList<>();
                    list.add(chars[i]);
                    eMap.put(c, list);
                }
            } else {
                // 其他字符则保存索引,且保存到结果数组中
                set.add(i);
                resArr[i] = chars[i];
            }
        }
        // 根据key排序,将value输出成list
        List<ArrayList<Character>> lists = eMap.entrySet().stream().sorted(
                                               Map.Entry.comparingByKey()).map(Map.Entry::getValue).collect(
                                               Collectors.toList());
        int i = 0;
        // 将英文list输出到结果数组中
        for (ArrayList<Character> list : lists) {
            for (Character character : list) {
                while (set.contains(i)) {
                    i++;
                }
                resArr[i] = character;
                i++;
            }
        }
        for (char c : resArr) {
            System.out.print(c);
        }
    }

    private static boolean isEnglish(char c) {
        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
    }
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        List<Character> list = new ArrayList<>();
        for(char c: str.toCharArray()){
            if(Character.isLetter(c)){
                list.add(c);
            }
        }
        list.sort(new Comparator<Character>(){
            public int compare(Character o1, Character o2){
                return Character.toLowerCase(o1)- Character.toLowerCase(o2);
            }
        });
        StringBuilder builder = new StringBuilder();
        for(int i=0,j=0;i<str.length();i++){
            if(Character.isLetter(str.charAt(i))){
                builder.append(list.get(j++));
            } else {
                builder.append(str.charAt(i));
            }
        }
        System.out.println(builder.toString());
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            char[] charArray = in.nextLine().toCharArray();
            LinkedHashMap<Integer, Character> map = new LinkedHashMap<>();
            ArrayList<Character> arr = new ArrayList<>();
            //将非字母字符存入map中,字母字符存入ArrayList中
            for (int i = 0; i < charArray.length; i++) {
                if ((charArray[i] < 'A' || charArray[i] > 'z') ||((charArray[i] > 'Z') && charArray[i] < 'a' )  ){
                    map.put(i,charArray[i]);
                    continue;
                }
               arr.add(charArray[i]);
            }
            //对ArrayList中的字母忽视大小写排序
            Collections.sort(arr, new Comparator<Character>() {
                @Override
                public int compare(Character x, Character y) {
                    return Character.compare(Character.toLowerCase(x), Character.toLowerCase(y));
                }
            });
            //对结果进行拼接
            StringBuffer stringBuffer = new StringBuffer();
            int index = 0;
            for (int i = 0; i < charArray.length; i++) {
                if (map.get(i) != null  &&map.get(i) == charArray[i]){
                    stringBuffer.append(charArray[i]);
                }else {
                    stringBuffer.append(arr.get(index));
                    index++;
                }
            }
            System.out.println(stringBuffer);
        }
    }
}

    public static String sortWords(String words) {
        char[] c1 = words.toCharArray();
        int k = 0;
        Character[] c = words.replaceAll("[^a-zA-Z]", "")
                        .chars ()
                        .mapToObj (a -> (char) a)
                        .toArray (Character []::new);
        Arrays.sort (c, (x, y) -> {
                return Character.toLowerCase (x) - Character.toLowerCase (y);
        });
        for (int i = 0 ; i < c1.length; i++) {
            if (Character.isLetter(c1[i])) {
                c1[i] = c[k++];
            }
        }
        return new String(c1);
    }

import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();

        String[] strs = new String[str.length()];
        for (int i = 0; i < str.toCharArray().length; i++) {
            strs[i] = String.valueOf(str.toCharArray()[i]);
        }

        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < strs.length; i++) {
            if (!strs[i].matches("[A-Za-z]")) {
                map.put(i, strs[i]);
            } else {
                list.add(strs[i]);
            }
        }

        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = 0; j < list.size() - 1 - i; j++) {
                String tmp = "";
                if (list.get(j).compareToIgnoreCase(list.get(j + 1)) > 0) {
                    tmp = list.get(j);
                    list.set(j, list.get(j + 1));
                    list.set(j + 1, tmp);
                }
            }
        }

        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, String> next = iterator.next();
            list.add(next.getKey(), next.getValue());
        }

        for (String s : list) {
            System.out.print(s);
        }
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String str=in.nextLine();
        int len=0;
        for(int i=0;i<str.length();i++){
            if((str.charAt(i)>='A'&&str.charAt(i)<='Z')||
                    (str.charAt(i)>='a'&&str.charAt(i)<='z')){
                len++;
            }
        }
        String arr[]=new String[len];
        int l=0;
        for(int i=0;i<str.length();i++){
            if((str.charAt(i)>='A'&&str.charAt(i)<='Z')||
                    (str.charAt(i)>='a'&&str.charAt(i)<='z')){
                arr[l]=String.valueOf(str.charAt(i));
                l++;
            }
        }
        String arr2[]=new String[len];
        int index=0;
        for(int i=65;i<=90;i++){
            for(int j=0;j<len;j++){
                if(arr[j].charAt(0)==(char)i||arr[j].charAt(0)==(char)(i+32)){
                    arr2[index]=arr[j];
                    index++;
                }
            }
        }
        int flag=0;
        for(int i=0;i<str.length();i++){
            if((str.charAt(i)>='A'&&str.charAt(i)<='Z')||
                    (str.charAt(i)>='a'&&str.charAt(i)<='z')){
                System.out.print(arr2[flag]);
                flag++;
            }else {
                System.out.print(str.charAt(i));
            }
        }
    }
}

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = br.readLine();
        char[] chars = line.toCharArray();
        StringBuilder sb = new StringBuilder();
        // 按照排序后的字符顺序，在字符串中寻找，如果找到，则添加到sb中
        for (int i = 'A'; i <= 'Z'; i++) {
            char c = (char) i;
            for (int j = 0; j < chars.length; j++) {
                if (c == chars[j] || chars[j] == c - 'A' + 'a') {
                    sb.append(chars[j]);
                }
            }
        }

        // 非字符的插入到对应的位置上
        for (int i = 0; i < chars.length; i++) {
            if (!((chars[i] >= 'a' && chars[i] <= 'z') || (chars[i] >= 'A' &&
                    chars[i] <= 'Z'))) {
                sb.insert(i, chars[i]);
            }
        }

        // 打印输出
        System.out.println(sb.toString());
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
         public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();

        char[] arr = str.toCharArray();
        // 存放排序的char
        LinkedList<Character> list = new LinkedList<>();
        // 存放特殊字符的 下标以及字符
        Map<Integer, Character> map =  new HashMap<>();
        for (int i = 0; i < arr.length; i++) {
            // 确定 是大小写字母
            if (('A' <= arr[i] && arr[i] <= 'Z') || ('a' <= arr[i] && arr[i] <= 'z')) {
                // 如果 list长度为0 直接方第一个
                if (list.size() == 0) {
                     list.add(0, arr[i]);
                    continue;
                }

                // 将大写字母转变为小写字母 (也可以是将小写字母转变为大写字母)
                char c = arr[i];
                if ('A' <= c && c <= 'Z') {
                    c = (char) (c + 32);
                }

                // 从后向前 (也可以是从前往后)
                for (int j= list.size() -1; j >= 0; j--) {

                    // 将List中的大写字母转变为小写字母
                    char c1 = list.get(j);
                    if ('A' <= c1 && c1 <= 'Z') {
                        c1 = (char) (c1 + 32);
                    }

                    // arr 和 list比大小 进行存放
                    if (c >= c1) {
                        int n = 1;
                        list.add(j+n, arr[i]);
                        break;
                    } else if (j == 0 && c1 > c) { 
                        // 如果比较到 j == 0 也没有找到c >= c1
                        // 说明c1最小直接放在第一位
                        list.addFirst(arr[i]);
                    }
                }
            } else {
                // 非 大小写字母进行存储 map
                map.put(i, arr[i]);
            }
        }

        // 特殊字符按照下标排序
        List<Integer> keyList = new ArrayList<>(map.keySet());
        keyList.sort((a, b) -> a.compareTo(b));

        // 将特殊字符放到之前下标的位置  
        keyList.forEach(index -> {
            list.add(index, map.get(index));
        });

        // 输出
        StringBuilder builder = new StringBuilder();
        list.forEach( item -> {
            builder.append(item);
        });

        System.out.print(builder.toString());
    }
}