字符串排序

#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;
    }
}

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();
		}
	}
}

#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;
}//这个是仿照其他人的做法

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));
        }
    }
}

#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;
}

#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;
}

由于排序只针对字母进行，因此可以预先存储字母的下标，然后对该下标数组进行冒泡排序。当然，排序的内容不是下标数组的值，而是其指向的输入字符串的字符。根据规则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;
}

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

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

#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;
}

#include <iostream>
#include <string>
#include <cctype> //for isalpha()

using namespace std;

int main(){
    string input;
    while(getline(cin,input)){
        //对冒泡排序进行修改
        int len = input.size();        
        //最多len轮
        for(int i=0; i<len; i++){
            bool completed = false;
            
            //每一轮的结束位置不同
            for(int j=0; j<len-1-i; ){
                //注意这里下一轮的结束位置与原始冒泡排序不同
                while((j<len-1-i) && (!isalpha(input[j])) ){
                    //当不是字母时,直接跳过
                    j++;
                }
                
                int next = j+1;
                while((next<len-i) && (!isalpha(input[next])) ){
                    next++;
                }
                
                if(j>=len-1-i || next>=len-i){
                    break;
                }
                
                //若能运行到这里，则说明input[j]和input[next]均为字母
                if(tolower(input[j])>tolower(input[next])){
                    char temp = input[j];
                    input[j] = input[next];
                    input[next] = temp;
                    
                    completed = true; //该轮有元素交换
                }
                
                j++; //进行下一个字符的比较
            }
            
            //这一轮没有元素交换，说明排序已经完成
            if(!completed){
                break;
            }
        }
        
        cout<<input<<endl;
    }
}

#include<iostream>
#include<string>
#include<cctype>
#include<algorithm>
using namespace std;
bool compare(const char &a1, const char &a2)
{
    return tolower(a1) < tolower(a2);
}
int main(){
    string s;
    while(getline(cin,s)){
    string c;
    
    for(int i=0;i<s.size();i++){
        if(toupper(s[i])>='A'&&toupper(s[i])<='Z')
            c.push_back(s[i]);
    }
    stable_sort(c.begin(),c.end(),compare);
    string::iterator ite=c.begin();
    for(int i=0;i<s.size();i++){
        if(toupper(s[i])>='A'&&toupper(s[i])<='Z')
            cout<<*ite++;
        else cout<<s[i];
    }
        cout<<endl;
    }
}

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

bool mysort(char a,char b) //由于大小写顺序不变，所以全部按照小写排序
{
    return (tolower(a)<tolower(b));
}

int main()
{
    string strIn;
    while(getline(cin,strIn))
    {
        string alphaStr;
        for(char c:strIn)
        {
            if(isalpha(c)) alphaStr.push_back(c);
        }
        stable_sort(alphaStr.begin(),alphaStr.end(),mysort); //稳定排序
        for(int i=0,j=0;i<strIn.size();++i) //如果是字母则输出alphaStr，否则输出strIn
        {
            if(isalpha(strIn[i]))
            {
                cout<<alphaStr[j];
                j++;
            }
            else
                cout<<strIn[i];
        }
        cout<<endl;
    }
    return 0;
}

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

void swap(char &a, char &b) {
    char temp = a;
    a = b;
    b = temp;
}

void Insert_sort(vector <char> &char_s) {
    for(int i = 1; i < char_s.size(); i++){
        for(int ii = i; ii > 0; ii --) {
            if(toupper(char_s[ii]) < toupper(char_s[ii - 1])) {
                swap(char_s[ii], char_s[ii - 1]);
            }
            else {
                break;
            }
        }
    }
}

int main() {
    string str_in;
    while(getline(cin, str_in)){
        vector <char> char_s;
        for(int i = 0; i < str_in.length(); i++) {
            if(isalpha(str_in[i])) {
                char_s.push_back(str_in[i]);
            }
        }
        Insert_sort(char_s);
        for(int i = 0; i < str_in.length(); i++) {
            if(!isalpha(str_in[i])) {
                cout << str_in[i];
            }
            else{
                cout << char_s[0];
                char_s.erase(char_s.begin());
            }
        }
        cout << endl;
    }
    system("pause");
    return 0;
}
//保持非字母符号位置不变 vector
//排序保持稳定性 同字母大小写顺序一致 插入排序 Insert Sort