首页 > 试题广场 >

字符串排序

[编程题]字符串排序

热度指数：550704 时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++ 32M，其他语言64M
算法知识视频讲解

$\hspace{15pt}$ 对于给定的由大小写字母混合构成的 $n$ 个单词，输出按字典序从小到大排序后的结果。

$\hspace{15pt}$ 从字符串的第一个字符开始逐个比较，直到找到第一个不同的位置，通过比较这个位置字符对应的 $\sf Ascii$ 码（ $\tt A < \cdots < Z < a < \cdots < z$ ）得出字符串的大小，称为字典序比较。

$1 \le n \le 1000 \$ $1 \le len \le 100 \$

输入描述:

第一行输入一个整数  代表给定的单词个数。
此后  行，每行输入一个长度  ，由大小写字母混合构成的字符串  ，代表一个单词。

输出描述:

输出  行，每行输出一个字符串，代表排序后的结果。第一行输出字典序最小的单词。

示例1

输入

11
cap
to
cat
card
two
too
up
boat
boot
AA
Aa

输出

AA
Aa
boat
boot
cap
card
cat
to
too
two
up

算法知识视频讲解

Javascript_V8

咱们不气

let num = readline()
const arr = []
while(line = readline()){
    arr.push(line)
}
arr.sort()
arr.forEach(item=>{
    console.log(item)
})

发表于 2022-06-13 21:01:12 回复(0)

Java

牛客367012050号

import java.util.*;

public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
ArrayList<String> strings = new ArrayList<>();
while (in.hasNext()) {
int a = Integer.parseInt(in.nextLine());
for(int i=0;i<a;i++){
String b = in.nextLine();
strings.add(b);
}
Collections.sort(strings);
strings.forEach((k)->System.out.println(k));
}
}
}

发表于 2021-10-14 13:38:39 回复(0)

Python3

Mr丶赵雨櫹

# -*- coding: utf-8 -*-
# @Time : 2021/9/18 22:28
# @Author : zhaow
# @Email : 401407793@qq.com
# @File : HJ14 字符串排序.py
# @Project : PyCharm Project

if __name__ == '__main__':
    count = int(input(''))
    # 方法一
    # resa = [input('') for w in range(count)]
    # resa.sort()
    # res = sorted(resa)
    # ----------------------------------------

    # 方法二
    # res = sorted([input('') for w in range(count)])
    # ----------------------------------------

    # 方法三
    res = []
    for w in range(count):
        res.append(input())
        # res.sort()
    # ----------------------------------------

    # for r in res:
    #     print(r)

    for r in sorted(res):
        print(r)

发表于 2021-09-18 22:43:29 回复(0)

小明很狂躁

利用map的性质，代码简洁

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n; cin >> n;
    string s;
    map<string, int> map;
    for (int i = 0; i < n; i++) {
        cin >> s;
        map[s] += 1;
    }
    for (auto i : map) {
        for (int k = 0; k < i.second; k++) {
            cout << i.first << endl;
        }
    }
    return 0;
}

发表于 2021-06-19 23:02:38 回复(0)

Python

活跃的沉默者

看了前面用c++写的大佬，突然感觉python太香了

def rankarr(list):
    list.sort()
    for item in list:
        print(item)
arr = []
num = input()
for i in range(int(num)):
    arr.append(input())
rankarr(arr)

发表于 2021-05-19 16:26:25 回复(0)

Python

牛客659977316号

一堆人直接调用sort函数有个屁用

本质就是用快速排序,然后用比较字符串函数替换掉比较数字大小的部分

lists = []

def cmp(s1, s2):
    l = len(s2)
    if s1 == s2:
        return True
    for i, c1 in enumerate(s1):
        if i >= l:
            return 1
        c2 = s2[i]
        if c1 != c2:
            return ord(c1) - ord(c2)
    return len(s1) - len(s2)

def fun2(s1, s2):
    l = len(s2)
    if s1 == s2:
        return True
    for i, c1 in enumerate(s1):
        if i >= l:
            return False
        c2 = s2[i]
        if c1 > c2:
            return False
        elif c1 < c2:
            return True
    return False

def quick_sort(i, j):
    if i >= j:
        return lists
    low, high = i, j
    p = lists[i]
    while i<j:
        while i < j and cmp(lists[j], p) >= 0:
            j -= 1
        lists[i] = lists[j]
        while i < j and cmp(lists[i], p) <= 0:
            i += 1
        lists[j] = lists[i]
    lists[i] = p
    quick_sort(low, i-1)
    quick_sort(i+1, high)


while True:
    try:
        n = int(input())
        lists = []
        for i in range(n):
            lists.append(input())
        quick_sort(0, len(lists) - 1)
        for s in lists:
            print(s)
    except EOFError:
        break

发表于 2021-03-12 00:48:44 回复(0)

C/C++

已注销

不用直接交换字符串，可以设置一个指针数组指向每一个串的首地址，然后对这个指针数组进行排序即可。使用快速排序算法：

#include <stdio.h>
#include <string.h>

char ss[1000][101];
char* ps[1000];

void swap(int i, int j)
{
    char* tmp = ps[i];
    ps[i] = ps[j];
    ps[j] = tmp;
}

int partition(int p, int r)
{
    char* pivot = ps[r];
    int i = p - 1, j;

    for (j = p; j <= r - 1; ++j) {
        if (strcmp(ps[j], pivot) <= 0) {
            ++i;
            if (i != j) swap(i, j);
        }
    }

    swap(i + 1, j);

    return i + 1;
}

void qsort(int p, int r)
{
    if (p >= r) return;

    int q = partition(p, r);

    qsort(p, q - 1);
    qsort(q + 1, r);
}

int main()
{
    int n;

    scanf("%d", &n);

    for (int i = 0; i < n; ++i) {
        scanf("%s", ss[i]);
        ps[i] = ss[i];
    }

    qsort(0, n - 1);

    for (int i = 0; i < n; ++i) printf("%s\n", ps[i]);

    return 0;
}

发表于 2021-02-24 22:32:38 回复(0)

Python

鹿鸣松

n=int(input())
s=[]
for i in range(n):
s+=[input()]
s2=sorted(s)
for i in s2:

print(i)

读完之后用内置的sorted函数排序一下，然后遍历输出

发表于 2020-12-26 23:15:17 回复(0)

Python

destpaci

输入保存到列表，排序好，按行输出

使用列表生成式

n = int(input())
str_list = [input() for i in range(n)]
for i in sorted(str_list):
    print(i)

发表于 2020-10-04 15:58:13 回复(0)

Java

牛客421441678号

import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()) {
int n = sc.nextInt();
List<String> list = new ArrayList<String>();
for(int i=0; i<n; i++) {
String str = sc.next();
list.add(str);
}
// 按字符串升序排序
list.sort(new Comparator<String>() {
@Override
public int compare(String str1, String str2) {
// TODO Auto-generated method stub
return str1.compareTo(str2);
}
});
//用这个也可以
// Collections.sort(list);

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

发表于 2020-09-19 00:40:16 回复(0)

C/C++

时光长城

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

using namespace std;
int main()
{
    int n;
    string s;
    vector<string> v;
    cin >> n;
    while(n-- && cin >> s)
        v.push_back(s);
    sort(v.begin(), v.end());
    for(auto it=v.begin();it!=v.end();it++)
        cout<< *it << endl;
    return 0;
}

我承认不应该用泛型算法，但是sort()函数真香！

发表于 2020-09-16 15:50:25 回复(0)

C/C++

虹色萤火虫

纯C

快排

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define N_STRS 1000
#define STR_LEN 100

void str_quick_sort(char str[N_STRS][STR_LEN], int low, int high)
{
    char *temp = (char *)malloc(sizeof(char) * STR_LEN);
    int i=low, j=high;
    if(low < high)
    {
        strcpy(temp, str[low]);
        while(i != j)
        {
            while(j>i && strcmp(str[j], temp)>0) --j;
            if(i<j)
            {
                strcpy(str[i],str[j]);
                ++i;
            }
            while(i<j && strcmp(str[i], temp)<0) ++i;
            if(i<j)
            {
                
                strcpy(str[j],str[i]);
                --j;
            }
        }
        strcpy(str[i],temp);
        str_quick_sort(str, low, i-1);
        str_quick_sort(str, i+1, high);
    }
}

int main()
{
    char str[N_STRS][STR_LEN] = {'\0'};
    int n;
    scanf("%d\n", &n);
    for(int i=0; i<n; i++)
    {
        scanf("%s\n", str[i]);
    }
    str_quick_sort(str, 0, n-1);
    for(int i=0; i<n; i++)
    {
        printf("%s\n", str[i]);
    }
    return 0;
}

编辑于 2020-08-24 11:35:35 回复(0)

Python

Aaron_c

import sys
n = int(sys.stdin.readline().strip())
a, result = [], []
for i in range(n):
    a.append(sys.stdin.readline().strip())
for n1 in range(n,1,-1):
    for i in range(n1-1):
        j = 1
        pos1, pos2 = ord(a[i][0]), ord(a[i+1][0])
        while pos1 == pos2 and j<min(len(a[i]),len(a[i+1])):
            pos1, pos2 = ord(a[i][j]), ord(a[i+1][j])
            j += 1
        if pos1 == pos2:
            pos1, pos2 = len(a[i]), len(a[i+1])
        if pos1 > pos2:
            a[i:i+2] = [a[i+1],a[i]]
for i in range(n):
    print(a[i])

用C的思路写的python，然而实际python一个函数就能搞定

发表于 2020-08-21 16:12:20 回复(0)

tigg_ZZ

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        List<String> result = new ArrayList<>();
        for (int i = 0; i < num; i++){
            result.add(scanner.next());
        }
        Collections.sort(result);
        for (int j = 0; j < result.size(); j++){
            System.out.println(result.get(j));
        }
    }
}

发表于 2020-08-18 18:32:01 回复(0)

算法，对我好点！

采用Java解答

1.字典的排序规则，是看了网友的解决，调用函数Collections.sort()

2.第二种采用TreeSet的方法，自动进行排序

import java.util.Scanner;
import java.util.TreeSet;

/**
 * 字符串的连接最长路径查找
 * 给定n个字符串，请对n个字符串按照字典序排列。
 * 输入描述:
 * 输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
 * 输出描述:
 * 数据输出n行，输出结果为按照字典序排列的字符串
 */
public class Main {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()){
            int n = Integer.parseInt(sc.nextLine());
            String[] strs = new String[n];
            for(int i = 0;i<n;i++){
                String s = sc.nextLine();
                strs[i] = s;
            }
            sortDict(strs);
        }
    }

    public static void sortDict(String[] strings){
        if(strings==null||strings.length<=0){
            return;
        }

        TreeSet<String> treeSet = new TreeSet<>();
        for(int i = 0;i<strings.length;i++){
            treeSet.add(strings[i]);
        }
        for (String s:treeSet){
            System.out.println(s);
        }
    }
}

但是这个代码的通过率只有60%，有大佬可以帮忙看下吗，我自己按照题目给的出错案例，出来的结果是没有问题，但是牛客说我的输出是有问题。。。。我就不明白了

编辑于 2020-10-13 17:13:25 回复(0)

翟爸爸

#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    int N;
    cin >> N;
    vector<string>sset;
    string aa;
    cin.get();
    while (N--)
    {
        string temp;
        getline(cin, temp);
        sset.push_back(temp);
    }
    sort(sset.begin(), sset.end());
for(int i=0;i<sset.size();i++)
cout<<sset[i]<<endl;
    return 0;
}

发表于 2020-08-11 19:52:46 回复(0)

Java

丛林守望者

import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int size = scanner.nextInt();
            List<String> wordList = new ArrayList<>();
            for (int i = 0; i <= size; i++) {
                String word = scanner.nextLine().trim();
                if (!word.matches("[a-zA-Z].*")) {
                    continue;
                }
                if (!word.isEmpty()) {
                    wordList.add(word);
                }
            }
            Collections.sort(wordList);
            wordList.forEach(System.out::println);
        }
    }
}

编辑于 2020-08-09 00:04:37 回复(0)

奋斗ing_QT

#include <bits/stdc++.h>
using namespace std;
int main(){
    int n;
    while(cin >> n){
        vector<string> vec(n);
        for(int i=0;i<n;++i) cin>>vec[i];
        stable_sort(vec.begin(), vec.end(),
                   [](const string& s1,const string& s2){return s1 < s2;});
        for(auto i:vec) cout << i << endl;
    }
    return 0;
}

13行搞定😑

发表于 2020-06-23 14:47:41 回复(1)

C/C++

眼睛眨啊眨

使用可重复集合multiset

#include <iostream>
#include <set>
using namespace std;
int main()
{
    ios::sync_with_stdio(false);
    string strInput;
    multiset<string> setStr;
    size_t sizeStr;
    cin >> sizeStr;
    for (size_t counter = 0; counter < sizeStr; ++counter) {
        cin >> strInput;
        setStr.insert(strInput);
    }
    for (auto const &elem : setStr)
        cout << elem << '\n';
    return 0;
}

编辑于 2020-04-21 13:56:40 回复(0)

Mysf

#include <iostream>
#include <algorithm>
#include <string>

using namespace std;

int main()
{
    vector<string> v;
    int n;
    string s;
    cin>>n;
    for(int i=0; i<n;i++)
    {
        cin>>s;
        v.push_back(s);
    }
    sort(v.begin(),v.end());
    for(auto it:v)
        cout<<it<<endl;
    return 0;
}

编辑于 2020-04-12 11:38:35 回复(0)

提交观点

问题信息

字符串排序

难度：

1377条回答 2868收藏 105533浏览

通过挑战的用户

查看代码

牛客35700...

2023-02-20 16:48:45
樱の雨

2023-01-18 14:43:39
Tangeri...

2023-01-11 20:50:26
のどの

2022-11-24 11:54:48
想吃烤肉的小狐...

2022-11-16 02:46:13

字符串排序

输入描述:

输出描述:

输入

输出

输入保存到列表，排序好，按行输出

纯C

13行搞定😑

使用可重复集合multiset

问题信息

热门推荐

通过挑战的用户

相关试题