首页 > 试题广场 >

字符串排序

[编程题]字符串排序
  • 热度指数:271770 时间限制:C/C++ 1秒,其他语言2秒 空间限制:C/C++ 32M,其他语言64M
  • 算法知识视频讲解

编写一个程序,将输入字符串中的字符按如下规则排序。

规则 1 :英文字母从 A 到 Z 排列,不区分大小写。

如,输入: Type 输出: epTy

规则 2 :同一个英文字母的大小写同时存在时,按照输入顺序排列。

如,输入: BabA 输出: aABb

规则 3 :非英文字母的其它字符保持原来的位置。

如,输入: By?e 输出: Be?y

数据范围:输入的字符串长度满足


输入描述:
输入字符串


输出描述:
输出字符串
示例1

输入

A Famous Saying: Much Ado About Nothing (2012/8).

输出

A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8).
let line =''
while(line = readline()){
const reg = new RegExp(/[a-zA-Z]/)
const str = line
const list = str.split('').filter(item=>{
    return reg.test(item)
}).map(item=>item.toLowerCase()) // 求出整个字符串中出现的字母,并转化为小写之后去重
const strset = Array.from(new Set(list)).sort()
const res = []
for(let i of strset){
    for(let j in str){
        if(str[j].toLowerCase().charCodeAt() == i.charCodeAt()){
            res.push(str[j])
        }
    }
}
for(let u in str){
    if(!reg.test(str[u])){
        res.splice(u,0,str[u])
    }
}
console.log(res.join(''))
}



发表于 2022-04-14 15:26:28 回复(0)
将字符串中所有字母取出存储,然后排序,将排序后的字母数组替换到原字符串对应的字母位置。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            String s = sc.nextLine();
            System.out.println(order(s));
        }
    }

    public static String order(String s) {
        int n = s.length();
        // 存储所有字母
        List<Character> list = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            if (Character.isLetter(s.charAt(i))) {
                list.add(s.charAt(i));
            }
        }
        // 排序list
        list.sort(Comparator.comparingInt(Character::toLowerCase));
        // 拼接结果字符串
        StringBuilder sb = new StringBuilder();
        // 用于取字符数组
        int index = 0;
        for (int i = 0; i < n; i++) {
            char c = s.charAt(i);
            if (Character.isLetter(c)) {
                sb.append(list.get(index++));
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }
}


发表于 2021-08-04 16:49:30 回复(0)
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

/**
 * 字符串排序
 */
public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String str = scanner.nextLine();
            System.out.println(sort(str));
        }
    }

    public static String sort(String str){
        ArrayList<Character> characters = new ArrayList<>();
        //添加所有的字母,其他字符不添加
        for (int i = 0; i<str.length();i++){
            if (Character.isLetter(str.charAt(i))){
                characters.add(str.charAt(i));
            }
        }
        characters.sort(new Comparator<Character>() {
            @Override
            public int compare(Character o1, Character o2) {
                return Character.toLowerCase(o1) - Character.toLowerCase(o2);
            }
        });

        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0, j = 0; i < str.length();i++){
            if (Character.isLetter(str.charAt(i))){
                stringBuilder.append(characters.get(j++));
            }else {
                stringBuilder.append(str.charAt(i));
            }
        }
        return stringBuilder.toString();
    }

}

发表于 2021-07-24 14:38:52 回复(0)
#include<iostream>

using namespace std;

int main(){
    string Message;
    while(getline(cin,Message)){
        string Removed = "";
        for(int i=0; i<Message.size(); i++){
            if(isalpha(Message[i])) Removed+=Message[i];
        }
        for(int i=0;i<Removed.size()-1;i++){
            for(int j=0; j<Removed.size()-i-1;j++){
                if(tolower(Removed[j])>tolower(Removed[j+1])) swap(Removed[j], Removed[j+1]);
            }
        }
        
        for(int i=0; i<Message.size(); i++){
            if(!isalpha(Message[i])){
                Removed.insert(i,1,Message[i]);
            }
        }
        
        cout<<Removed<<endl;
    }
}

发表于 2021-07-22 11:27:00 回复(0)
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		while(in.hasNext()){
			String str=in.nextLine();
			Character[] s=new Character[str.length()];
			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')){
					s[l]=str.charAt(i);
					l++;
				}
			}
			Arrays.sort(s,0,l,new Comparator<Character>(){
				public int compare(Character o1, Character o2) {
	                return Character.toLowerCase(o1) - Character.toLowerCase(o2);
	            }
			});
			int i=0;
			for(int j=0;j<str.length();j++){
				if((str.charAt(j)>='A'&&str.charAt(j)<='Z')||(str.charAt(j)>='a'&&str.charAt(j)<='z'))
					System.out.print(s[i++]);
				else
					System.out.print(str.charAt(j));
					
			}
            System.out.println();
		}
	}
}

发表于 2021-06-25 13:34:07 回复(0)
没想到啥快捷的法子,只写了这么繁琐的代码。大体思路是,先把是字母的提取出来,然后对这些字母归并排序,再一一替换掉之前的。
#include<iostream>
#include<stdio.h>
#include<cstring>
#include<string.h>
using namespace std;
int val(char ch) {
    if(ch>='a' && ch<='z') {
        return ch-'a';
    } 
    return ch-'A';
}
void mergesort(string& s,int left, int right) {
    if(left>=right) {
        return ;
    }
    int mid=left+((right-left)>>1);
    mergesort(s, left, mid);
    mergesort(s,mid+1,right);
    string tem="";
    int i=left,j=mid+1;
    while(i<=mid || j<=right) {
        if(i>mid) {
            tem+=s[j];
            ++j;
        } else if(j>right) {
            tem+=s[i];
            ++i;
        } else {
            if(val(s[i])<=val(s[j])) {
                tem+=s[i];
                ++i;
            } else {
                tem+=s[j];
                ++j;
            }
        }
    }
    for(int i=left;i<=right;++i)
        s[i]=tem[i-left];
}
int main() {
    string s;
    while(getline(cin,s)) {
        int len=s.size();
        string tem="";
        for(char ch:s) {
            //将字母提取出来
            if(ch>='a' && ch<='z' || ch>='A' && ch<='Z')
                tem+=ch;
        }
        mergesort(tem,0,tem.size()-1); //对tem中的字母排序(归并排序)
        int id=0;
        for(int i=0;i<len;++i) {
            if(s[i]>='a' && s[i]<='z' || s[i]>='A' && s[i]<='Z') {
                s[i]=tem[id++];
            }
        }
        cout<<s<<endl;
    }
    return 0;
}
发表于 2021-06-24 10:25:51 回复(0)
C++简洁代码
思路:
1 用一个vector1装原始字符,用vector2装纯字母字符
2 利用插入排序对vector2排序,插入排序最合适
3 循环遍历vector1,如果是字母字符,直接用vector2中字符替换,如果是非字母字符,保持不变
代码如下:
#include<iostream>
#include<vector>
using namespace std;
void m_sort(vector<char>&v)
{
    for (int i=1;i<v.size();i++)
    {
        int key = v[i];
        int j=i-1;
        while( j>=0 && tolower(v[j]) > tolower(key))
        {
            v[j+1] = v[j];
            j--;
        }
        v[j+1] = key;
    }
}
int main(void)
{

    char ch;
    vector<char>m_vector;
    vector<char>sort_vector;
    while(cin.get(ch))
    {
        //读取字符
        m_vector.push_back(ch);
        if(isalpha(ch))sort_vector.push_back(ch);
        if(ch=='\n')
        {
            //排序
            m_sort(sort_vector);
            //插入
            int j=0;
            for(int i=0;i<m_vector.size();i++)
            {
                if(isalpha(m_vector[i]))
                    m_vector[i]=sort_vector[j++];
            }
            //输出
            for(auto it:m_vector)cout << it;
            //清除
            m_vector.clear();
            sort_vector.clear();
        }
    }
    return 0;
}


发表于 2021-04-01 18:43:54 回复(0)
25行C++极短代码
#include <bits/stdc++.h>
using namespace std;
bool cmp(const char& c1,const char& c2){
    const char tmp1 = toupper(c1);
    const char tmp2 = toupper(c2);
    return tmp1<tmp2;
}
int main(){
    string s;
    while(getline(cin, s)){
        string ss="";
        map<int,char> mp;
        for(int i=0;i<s.size();i++){
            if(!isalpha(s[i])) mp[i] = s[i];
            else ss += s[i];
        }
        stable_sort(ss.begin(), ss.end(),cmp);
        for(auto p:mp){
            auto it = ss.begin()+p.first;
            ss.insert(it, p.second);
        }
        cout<<ss<<endl;
    }
    return 0;
}



编辑于 2021-03-29 21:47:24 回复(0)
先把字母字符拎出来组成列表,对其进行二次排序(首先全部转化为小写按字典序排,这样就忽略了大小写,字典序相同就按索引序,这样就保持了原来的顺序)。然后准备个空结果列表,遍历原始的字符串:如果当前字符是非字母,就直接加入列表,使其保持原来的位置;否则就从排好序的字母字符列表的队头弹出一个字母字符加入到结果列表中,保证字母字符按题意的顺序。
将结果列表中的字符拼接成字符串输出即可。
while True:
    try:
        s = input()
        str_list = [(i, c) for i, c in enumerate(list(s)) if c.isalpha()]
        sorted_list = sorted(str_list, key=lambda c: (c[1].lower(), c[0]))
        n = len(s)
        res = [""]*n
        startIdx = 0
        while startIdx < n:
            if s[startIdx].isalpha():
                # 这个位置在原来的位置上本来就是字母,就复制为排序后的字母
                res[startIdx] = sorted_list.pop(0)[1]
            else:
                # 否则此位置仍然是原来的字符
                res[startIdx] = s[startIdx]
            startIdx += 1
        print(''.join(res))
    except:
        break


编辑于 2021-03-21 15:51:06 回复(0)
从左往右冒泡排序:
1. 先从最后一个位置开始往前循环,判断该位置是否是字母,可以作为冒泡的最终目标位,直到找到字母才正式开始冒泡。
2. 从0开始确定left,遇到非字母的继续往右找,找到以后再向右找字母right。
3. 如果left大于right,交换,然后将right的位置赋值给left,继续循环步骤2。
import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String input;
        while ((input = reader.readLine()) != null) {
            int size = input.length();
            InputChar[] array = new InputChar[size];
            for (int i = 0; i < size; i++) {
                array[i] = new InputChar(input.charAt(i));
            }
            // 冒泡
            for (int target = size-1; target > 0; target--) {
                if (array[target].isAlphabet) {
                    // 冒泡目标位是字母,可交换
                    int left = 0;
                    int right = 0;
                    while (left < target) {
                        while (!array[left].isAlphabet && left < target) {
                            left += 1;
                        }
                        if (left == target) {
                            // 只剩target一个字母,直接结束
                            break;
                        }
                        right = left + 1;
                        while (!array[right].isAlphabet && right <= target) {
                            right += 1;
                        }
                        if (array[left].weight > array[right].weight) {
                            // 交换
                            InputChar temp = array[right];
                            array[right] = array[left];
                            array[left] = temp;
                            left = right;
                        } else {
                            // 不需要交换,往后移动1位继续循环找下一个字母
                            left += 1;
                        }
                    }
                }
            }
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < size; i++) {
                sb.append(array[i].input);
            }
            System.out.println(sb.toString());
        }
    }
    
    public static class InputChar {
        public boolean isAlphabet = false;
        public int weight;
        public char input;
        public InputChar(char input) {
            this.input = input;
            if (input >= 65 && input <= 90) {
                // 大写字母
                this.isAlphabet = true;
                this.weight = input + 32;
            } else if (input >= 97 && input <= 122) {
                // 小写字母
                isAlphabet = true;
                this.weight = input;
            }
        }
    }
}


发表于 2021-03-18 02:32:25 回复(0)
#include <iostream>
using namespace std;
int main(){
    string s;
    while(getline(cin,s)){
        int len=s.size();
        for(int i=0;i<len-1;i++){
            for(int j=0;j<len-i-1;j++){
                if(tolower(s[j])>='a'&&tolower(s[j])<='z'){
                    int k=j+1;
                    while(!(tolower(s[k])>='a'&&tolower(s[k])<='z')&&k<=len-1) k++;
                    if(k==len) break;
                    if(tolower(s[j])>tolower(s[k]))
                        swap(s[j],s[k]);
                    j=k-1;
                }
            }
        }
        cout<<s<<endl;
    }
    return 0;
}//用了一个冒泡排序,感觉自己想复杂了QAQ


#include <iostream>
#include <vector>
using namespace std;

int main(){
    string s;
    while(getline(cin,s)){
        int len=s.size();
        vector<char> vec;
        for(int i=0;i<26;i++){
            for(int j=0;j<len;j++){
                if(s[j]=='a'+i||s[j]=='A'+i)
                    vec.push_back(s[j]);
            }
        }
        int k=0;
        for(int i=0;i<len;i++){
            if(tolower(s[i])>='a'&&tolower(s[i])<='z')
                cout<<vec[k++];
            else
                cout<<s[i];
        }
        cout<<endl;
    }
    return 0;
}//这个是仿照其他人的做法


编辑于 2021-02-28 13:52:03 回复(0)
纯C的噩梦 
#include "string.h"
#include <stdio.h>
#include <stdbool.h>
#include "stdlib.h"
char buf[1000]={0};
int k=0;
void trans( char *a) //把字符串里的字母按照规则1 2 排列放在buf里
{
    int len=strlen(a);
    int i,j;
    for (i=0;i<26;i++)
    {
        for (j=0;j<len;j++)
        {
            if (a[j]=='a'+i || a[j]=='A'+i)
            {
                buf[k++]=a[j];
            }
        }
    }
}

int main ()
{
    char str[1000];
    while (gets(str)!=NULL)
    {
        int len=strlen(str);
        int i,j=0;
        k=0;
        trans(str);
        for (i=0;i<len;i++)
        {
            if (islower(str[i]) || isupper(str[i])) printf("%c",buf[j++]); //是字母就输出buf里的
             else  printf("%c",str[i]); //规则3
        }
        printf("\r\n");
    }

}


发表于 2020-09-14 19:36:01 回复(0)
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()){
            List<String> list = Arrays.asList(scanner.nextLine().split(""));
            String[] alphabet = "abcdefghijklmnopqrstuvwxyz".split("");
            int[] pointers = new int[26];
            char[] temp = new char[list.size()];
            char[] result = new char[list.size()];
            int prev = 0;
            for (int j = 0; j < alphabet.length; j++){
                int num = Collections.frequency(list,alphabet[j]);
                num += Collections.frequency(list,alphabet[j].toUpperCase());
                if (j < alphabet.length-1){
                    pointers[j+1] = prev + num;
                    prev += num;
                }
                    }
            for (int i = 0; i < list.size(); i++){
                if (!Character.isLetter(list.get(i).charAt(0))){
                    result[i] = list.get(i).charAt(0);
                }else{
                    int idx = (list.get(i).toLowerCase().charAt(0)) - 'a';
                    temp[pointers[idx]] = list.get(i).charAt(0);
                    pointers[idx] += 1;
                }
            }
            int iter = -1;
            for (char c : temp){
                while (iter < result.length-1){
                    iter += 1;
                    if (result[iter] == 0){
                        result[iter] = c;
                        break;
                    }
                }
            }
            System.out.println(String.valueOf(result));
        }
    }
}

发表于 2020-08-21 01:35:59 回复(0)
#include <stdio.h> 
#include <ctype.h>

int main(void)
{
    char s[1000];
    while(gets(s) != 0)
    {
        char alpha[1000];
        int pos = 0;

        for (int i = 0; i < 26; i++)
        {
            for (int j = 0; s[j] != '\0'; j++)
            {
                if (('A' + i) == toupper(s[j])) { alpha[pos++] = s[j]; }
            }
        }
        
        pos = 0;
        for (int i = 0; s[i] != '\0'; i++)
        {
            if (isalpha(s[i])) { s[i] = alpha[pos++]; }
        }
        
        printf("%s\n", s);
    }
    return 0;
}

发表于 2020-08-15 04:21:25 回复(0)
#include<iostream>
#include<string>
#include<vector>
#include<queue>
using namespace std;
bool cmp(const char a, const char b)
{
	return tolower(a) < tolower(b);
}
string sort1(string vec)
{
	stable_sort(vec.begin(), vec.end(), cmp);
	return vec;
}
int main()
{
	string str;
	while (getline(cin, str))
	{
		string vec="";
		for (int i = 0;i < str.size();i++)
		{
			if ((str[i] >= 'a'&&str[i] <= 'z') || (str[i] >= 'A'&&str[i] <= 'Z'))
			{
				vec += str[i];
			}
		}
		vec = sort1(vec);
		queue<char>q;
		for (int i = 0;i < vec.size();i++)
		{
			q.push(vec[i]);
		}
		for (int i = 0;i < str.size();i++)
		{
			if ((str[i] >= 'a'&&str[i] <= 'z') || (str[i] >= 'A'&&str[i] <= 'Z'))
			{
				str[i] = q.front();
				q.pop();
			}
		}
		cout << str << endl;

	}
	return 0;
}

发表于 2020-08-10 17:32:26 回复(0)
很笨的方法,写起来特别长,但是思路很简单。
建立26个字母队列,从头遍历字符串,对应字母进入对应队列,非字母跳过。
然后输出时,遇到非字母直接输出该位置字符,如果是字母就从字母队列(从A-Z顺序)里输出一个字母即可。
#include <iostream>
#include <queue>
using namespace std;
//判断是否是字母,以及哪一类字母
int CisA(char c){
    int i;
    if (c>='A'&&c<='Z'){
        i=c-'A';
    }else if (c>='a'&&c<='z'){
        i=c-'a';
    }else{
        i=-1;
    }
    return i;
}

int main(){
    string ins;
    while(cin>>ins){
        int l=ins.size(),i,j,n1,n2;
        char temp;
        queue<char> A; //建立各种字母的队列
        queue<char> B;
        queue<char> C;
        queue<char> D;
        queue<char> E;
        queue<char> F;
        queue<char> G;
        queue<char> H;
        queue<char> I;
        queue<char> J;
        queue<char> K;
        queue<char> L;
        queue<char> M;
        queue<char> N;
        queue<char> O;
        queue<char> P;
        queue<char> Q;
        queue<char> R;
        queue<char> S;
        queue<char> T;
        queue<char> U;
        queue<char> V;
        queue<char> W;
        queue<char> X;
        queue<char> Y;
        queue<char> Z;
        
        for (i=0;i<l;i++){
            int n = CisA(ins[i]);
            if (n==-1){
                continue;//非字母跳过
            }else{
                switch (n){//字母进相应队列
                    case 0:
                        A.push(ins[i]);
                        break;
                    case 1:
                        B.push(ins[i]);
                        break;
                    case 2:
                        C.push(ins[i]);
                        break;
                    case 3:
                        D.push(ins[i]);
                        break;
                    case 4:
                        E.push(ins[i]);
                        break;
                    case 5:
                        F.push(ins[i]);
                        break;
                    case 6:
                        G.push(ins[i]);
                        break;
                    case 7:
                        H.push(ins[i]);
                        break;
                    case 8:
                        I.push(ins[i]);
                        break;
                    case 9:
                        J.push(ins[i]);
                        break;
                    case 10:
                        K.push(ins[i]);
                        break;
                    case 11:
                        L.push(ins[i]);
                        break;
                    case 12:
                        M.push(ins[i]);
                        break;
                    case 13:
                        N.push(ins[i]);
                        break;
                    case 14:
                        O.push(ins[i]);
                        break;
                    case 15:
                        P.push(ins[i]);
                        break;
                    case 16:
                        Q.push(ins[i]);
                        break;
                    case 17:
                        R.push(ins[i]);
                        break;
                    case 18:
                        S.push(ins[i]);
                        break;
                    case 19:
                        T.push(ins[i]);
                        break;
                    case 20:
                        U.push(ins[i]);
                        break;
                    case 21:
                        V.push(ins[i]);
                        break;
                    case 22:
                        W.push(ins[i]);
                        break;
                    case 23:
                        X.push(ins[i]);
                        break;
                    case 24:
                        Y.push(ins[i]);
                        break;
                    case 25:
                        Z.push(ins[i]);
                        break;
                }
            }
        }
           
            for (i=0;i<l;i++){
                if (CisA(ins[i])==-1){
                    cout<<ins[i];//非字母直接输出
                }else{
                    if (!A.empty()){//遇到字母从队列取字符
                        cout<<A.front();
                        A.pop();
                    }else if (!B.empty()){
                        cout<<B.front();
                        B.pop();
                    }else if (!C.empty()){
                        cout<<C.front();
                        C.pop();
                    }else if (!D.empty()){
                        cout<<D.front();
                        D.pop();
                    }else if (!E.empty()){
                        cout<<E.front();
                        E.pop();
                    }else if (!F.empty()){
                        cout<<F.front();
                        F.pop();
                    }else if (!G.empty()){
                        cout<<G.front();
                        G.pop();
                    }else if (!H.empty()){
                        cout<<H.front();
                        H.pop();
                    }else if (!I.empty()){
                        cout<<I.front();
                        I.pop();
                    }else if (!J.empty()){
                        cout<<J.front();
                        J.pop();
                    }else if (!K.empty()){
                        cout<<K.front();
                        K.pop();
                    }else if (!L.empty()){
                        cout<<L.front();
                        L.pop();
                    }else if (!M.empty()){
                        cout<<M.front();
                        M.pop();
                    }else if (!N.empty()){
                        cout<<N.front();
                        N.pop();
                    }else if (!O.empty()){
                        cout<<O.front();
                        O.pop();
                    }else if (!P.empty()){
                        cout<<P.front();
                        P.pop();
                    }else if (!Q.empty()){
                        cout<<Q.front();
                        Q.pop();
                    }else if (!R.empty()){
                        cout<<R.front();
                        R.pop();
                    }else if (!S.empty()){
                        cout<<S.front();
                        S.pop();
                    }else if (!T.empty()){
                        cout<<T.front();
                        T.pop();
                    }else if (!U.empty()){
                        cout<<U.front();
                        U.pop();
                    }else if (!V.empty()){
                        cout<<V.front();
                        V.pop();
                    }else if (!W.empty()){
                        cout<<W.front();
                        W.pop();
                    }else if (!X.empty()){
                        cout<<X.front();
                        X.pop();
                    }else if (!Y.empty()){
                        cout<<Y.front();
                        Y.pop();
                    }else if (!Z.empty()){
                        cout<<Z.front();
                        Z.pop();
                    }
                }
                if (i==l-1){//输出结束
                    cout<<endl;
                }
            }
      

    }
}



发表于 2020-05-28 14:50:17 回复(0)

由于排序只针对字母进行,因此可以预先存储字母的下标,然后对该下标数组进行冒泡排序。当然,排序的内容不是下标数组的值,而是其指向的输入字符串的字符。根据规则2,得知排序算法还必须是稳定的。

#include <iostream>
#include <string>
#include <vector>

using namespace std;

const string transform_string(string str)
{
    vector<size_t> alpha_indexs;
    for (size_t i = 0; i < str.size(); ++i) {
        const char ch = str[i];
        if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
            alpha_indexs.push_back(i);
        }
    }

    for (size_t i = 0; i < alpha_indexs.size(); ++i) {
        for (size_t j = 0; j < alpha_indexs.size()-1; ++j) {
            if (std::toupper(str[alpha_indexs[j + 1]])
                < std::toupper(str[alpha_indexs[j]])) {
                std::swap(str[alpha_indexs[j + 1]],
                          str[alpha_indexs[j]]);
            }
        }
    }

    return str;
}

int main()
{
    string line;
    while (getline(cin, line)) {
        cout << transform_string(line) << endl;
    }
    return 0;
}
编辑于 2020-04-06 17:10:15 回复(0)
while True:
    try:
        a = input()
        result = [False] * len(a)  #最终返回值,先初始化
        chr_list = []   #接受字母的列表
        for i,v in enumerate(a):
            if v.isalpha():
                chr_list.append(v)
            else:
                result[i] = v
        chr_list.sort(key= lambda x: x.lower()) #将有字母的列表按序排列(大写全变为小写,方便排列,如果字母相同不影响本来输入的数据的顺序)
        for i,v in enumerate(result):
            if not v:       #如果result列表索引i值为False,则将字母列表的数据添加
                result[i] = chr_list[0]     #将字母列表的数据一一导入最终列表
                chr_list.pop(0)     #每循环导入一个字母,删除字母列表第一个数据
        print(''.join(result))
    except:
        break
不是原创,学了大神的,自己理解慢慢做的,希望能融会贯通吧
编辑于 2020-03-23 00:22:41 回复(0)

字母按序入队列,然后输出的时候按原始串输出,遇符号输出原始串的符号,否则队列出队~

#include<queue>
(789)#include<iostream>
#include<string>

using namespace std;

int main() {
    string str;
    while(getline(cin, str)) {
        queue<char> qc;
        for(int i = 0; i < 26; ++i) {
            for(auto st : str) {
                if((st-'a' == i) || (st-'A' == i)) {
                    qc.push(st);
                }
            }
        }
        for(auto st : str) {
            if((st >= 'a' && st <= 'z') || (st >= 'A' && st <= 'Z')) {
                cout << qc.front();
                qc.pop();
            }
            else
                cout << st;
        }
        cout << endl;
    }

    return 0;
}
发表于 2020-02-21 19:44:25 回复(0)
import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine())
        {
            String s = sc.nextLine();
            char[] ch = s.toCharArray();
            bubbleSort(ch);
            for(char c : ch)
            {
                System.out.print(c);
            }
            System.out.println();
        }
        sc.close();
    }
    // 选择排序:不稳定,会破坏同样元素的相对位置关系
    // 冒泡排序:稳定
    public static void bubbleSort(char[] c)
    {
        int len = c.length;
        for(int i = 0; i < len-1; i++)
        {
            boolean nochange = true;
            for(int j = 0; j < len-1-i; j++)
            {
                // 如果是字母
                if(Character.isLetter(c[j])) 
                {
                    int k = j+1;
                    // 找到一个字符是字母
                    while(k < len-i && !Character.isLetter(c[k]))
                    {
                        k++;
                    }
                    // 如果一直没找到字母,那么本轮就不比较了
                    if(k >= len-i)
                    {
                        nochange = false;
                        continue;
                    }
                    // 跟最近的一个字母比较
                    if(Character.toUpperCase(c[j]) > Character.toUpperCase(c[k]))
                    {
                        char tmp = c[j];
                        c[j] = c[k];
                        c[k] = tmp;
                        nochange = false;
                    }
                }
            }
            if(nochange) break;
        }
    }
}
带间隔判断的冒泡排序。冒泡排序算法稳定,选择排序思路简单,但是不稳定
编辑于 2020-02-19 14:35:26 回复(1)