文章目录
 
sort
默认排序sort file
忽略文本里面的相同行 -u
指定排序时所用的栏位分隔字符-t -k
将第二列按照数字从小到大顺序排列 -n
将第二列按照数字从大到小顺序排列(反序排序) -r
将排序结果写入文件 -o
 

 
sort
 
NAME
       sort - sort lines of text files
       对文本文件里面的行 进行排序

SYNOPSIS
       sort [OPTION]... [FILE]...
       sort [OPTION]... --files0-from=F

DESCRIPTION
       Write sorted concatenation of all FILE(s) to standard output.
       将所有文件的排序连接写入标准输出。

   With no FILE, or when FILE is -, read standard input.
   如果没有文件，或者当文件为-时，读取标准输入。
 
默认排序sort file
 
sort将文件/文本的每一行作为一个单位，相互比较，比较原则是从首字符向后，依次按ASCII码值进行比较，最后将他们按升序输出。
 先创建一个无序文本
 
 对比
 
 
忽略文本里面的相同行 -u
 
  -u, --unique
          with -c, check for strict ordering; without -c, output only the first of an equal run
 

 uniq sort.txt 也可以
 
 
指定排序时所用的栏位分隔字符-t -k
 
 -t, --field-separator=SEP
          use SEP instead of non-blank to blank transition
       
 -k, --key=KEYDEF
          sort via a key; KEYDEF gives location and type
          通过键排序;KEYDEF给出位置和类型
 
 
 
从公司英文名称的第二个字母开始进行排序
 
 先是指定空格将每行分为三个域，使用了-k 1.2，表示对第一个域的第二个字符开始到本域的最后一个字符为止的字符串进行排序。你会发现baidu因为第二个字母是a而名列榜首。sohu和 google第二个字符都是o，但sohu的h在google的o前面，所以两者分别排在第二和第三。guge只能屈居第四了。
 
 
只针对公司英文名称的第二个字母进行排序，如果相同的按照员工工资进行降序排序
 
 

 由于只对第二个字母进行排序，所以我们使用了-k 1.2,1.2的表示方式，表示我们“只”对第二个字母进行排序。
 （如果你问“我使用-k 1.2怎么不行？”，当然不行，因为你省略了End部分，这就意味着你将对从第二个字母起到本域最后一个字符为止的字符串进行排序）。
 对于员工工资进行排 序，我们也使用了-k 3,3，这是最准确的表述，表示我们“只”对本域进行排序，因为如果你省略了后面的3，就变成了我们“对第3个域开始到最后一个域位置的内容进行排序” 了。
 
将第二列按照数字从小到大顺序排列 -n
 
   -n, --numeric-sort
              compare according to string numerical value
              根据字符串数值进行比较
 
先创建测试文本
 
 
 
和默认排序对比
 测试文本
 
 
 出现第一种情况是由于排序程序将这些数字按字符来排序了，排序程序会先比较第一个字符，再比较第二个字符。这也是sort的一贯作风。
 
将第二列按照数字从大到小顺序排列(反序排序) -r
 
-r, --reverse
          reverse the result of comparisons
 
 
将排序结果写入文件 -o
 
   -o, --output=FILE
          write result to FILE instead of standard output
          将结果写入文件而不是标准输出
 
 
   -b, --ignore-leading-blanks
          ignore leading blanks
          忽略主要空白

   -c, --check, --check=diagnose-first
          check for sorted input; do not sort

   -d, --dictionary-order
          consider only blanks and alphanumeric characters
          只考虑空格和字母数字字符

   -f, --ignore-case
          fold lower case to upper case characters
          将小写字符折叠为大写字符

   -g, --general-numeric-sort
          compare according to general numerical value

   -i, --ignore-nonprinting
          consider only printable characters

   -h, --human-numeric-sort
          compare human readable numbers (e.g., 2K 1G)

 
 
最近在刷ACM经常用到排序，以前老是写冒泡，可把冒泡带到OJ里后发现经常超时，所以本想用快排，可是很多学长推荐用sort函数，因为自己写的快排写不好真的没有sort快，所以毅然决然选择sort函数
 
 
用法
 
 
 
1、sort函数可以三个参数也可以两个参数，必须的头文件#include < algorithm>和using namespace std;
 2、它使用的排序方法是类似于快排的方法，时间复杂度为n*log2(n)
 
 
 
 
3、Sort函数有三个参数：（第三个参数可不写）
 
 
 
 
（1）第一个是要排序的数组的起始地址。
 
 
 
 
（2）第二个是结束的地址（最后一位要排序的地址）
 
 
 
 
（3）第三个参数是排序的方法，可以是从大到小也可是从小到大，还可以不写第三个参数，此时默认的排序方法是从小到大排序。
 
 
两个参数用法
 
#include <iostream>
#include <algorithm>
int main()
{
 int a[20]={2,4,1,23,5,76,0,43,24,65},i;
 for(i=0;i<20;i++)
  cout<<a[i]<<endl;
 sort(a,a+20);
 for(i=0;i<20;i++)
 cout<<a[i]<<endl;
 return 0;
}
 
 
 
输出结果是升序排列。（两个参数的sort默认升序排序）
 
 
 
三个参数
 
// sort algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::sort
#include <vector>       // std::vector

bool myfunction (int i,int j) { return (i<j); }//升序排列
bool myfunction2 (int i,int j) { return (i>j); }//降序排列

struct myclass {
  bool operator() (int i,int j) { return (i<j);}
} myobject;

int main () {
    int myints[8] = {32,71,12,45,26,80,53,33};
  std::vector<int> myvector (myints, myints+8);               // 32 71 12 45 26 80 53 33

  // using default comparison (operator <):
  std::sort (myvector.begin(), myvector.begin()+4);           //(12 32 45 71)26 80 53 33

  // using function as comp
  std::sort (myvector.begin()+4, myvector.end(), myfunction); // 12 32 45 71(26 33 53 80)
    //std::sort (myints,myints+8,myfunction);不用vector的用法
    
  // using object as comp
  std::sort (myvector.begin(), myvector.end(), myobject);     //(12 26 32 33 45 53 71 80)

  // print out content:
  std::cout << "myvector contains:";
  for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)//输出
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}
 
 
string 使用反向迭代器来完成逆序排列
 
#include <iostream>
using namespace std;
int main()
{
     string str("cvicses");
     string s(str.rbegin(),str.rend());
     cout << s <<endl;
     return 0;
}
//输出：sescivc

 
文章目录
 
sort()简介
为什么选择使用sort()
sort()函数的实现原理
  
sort()的使用方法
头文件
sort()基本使用方法
自定义排序准则
对结构体进行排序
 

 
sort()简介
 
为什么选择使用sort()
 
 在刷题的时候我们经常会碰到排序的问题，如果我们不使用一些排序的方法那我们只能手撕排序，这样就会浪费一些时间。而且我们还需要根据需要去选择相关的排序方法：冒泡排序、快速排序、插入排序、希尔排序、归并排序、选择排序、堆排序、基数排序、桶排序。在选择的过程中也需要我们花费一些时间，所以在明白这些经典排序的情况下再一遍一遍的手写就有点浪费时间啦！
  如果我们使用sort()方法就可以只需要一条语句就可以实现排序，这样就极大的节省了我们在刷题中所花费的时间。当然如果对这些经典的排序方法不熟悉的话还是建议大家去了解一下这些方法，比较一下这些方法的优劣以及使用的情景。
 
sort()函数的实现原理
 
 也许你会疑问，我使用sort方法对数据进行排序就一定合适吗？sort()可以根据我的需要对数据进行排序吗？其实sort()函数还是一个比较灵活的函数。很多解释是：sort()函数是类似于快速排序的方法，时间复杂度为n*log2(n)，执行效率较高。
  其实STL中的sort()并非只是普通的快速排序，除了对普通的快速排序进行优化，它还结合了插入排序和堆排序。根据不同的数量级别以及不同情况，能自动选用合适的排序方法。当数据量较大时采用快速排序，分段递归。一旦分段后的数据量小于某个阀值，为避免递归调用带来过大的额外负荷，便会改用插入排序。而如果递归层次过深，有出现最坏情况的倾向，还会改用堆排序。所以说sort()是一个比较灵活的函数，它也会根据我们数据的需要进行排序，所以我们就不用担心以上的问题了。对于大部分的排序需求，sort()都是可以满足的。
 
sort()的使用方法
 
头文件
 
 在C++中使用sort()函数需要使用#include<algorithm>头文件。algorithm意为"算法",是C++的标准模版库（STL）中最重要的头文件之一，提供了大量基于迭代器的非成员模版函数。该头文件的详细使用方法以及包含的函数请参考：C++API之algorithm。
 
sort()基本使用方法
 
 sort()函数可以对给定区间所有元素进行排序。它有三个参数sort(begin, end, cmp)，其中begin为指向待sort()的数组的第一个元素的指针，end为指向待sort()的数组的最后一个元素的下一个位置的指针，cmp参数为排序准则，cmp参数可以不写，如果不写的话，默认从小到大进行排序。如果我们想从大到小排序可以将cmp参数写为greater<int>()就是对int数组进行排序，当然<>中我们也可以写double、long、float等等。如果我们需要按照其他的排序准则，那么就需要我们自己定义一个bool类型的函数来传入。比如我们对一个整型数组进行从大到小排序：
 
#include<iostream>
#include<algorithm>
using namespace std;

int main(){
	int num[10] = {6,5,9,1,2,8,7,3,4,0};
	sort(num,num+10,greater<int>());
	for(int i=0;i<10;i++){
		cout<<num[i]<<" ";
	}//输出结果:9 8 7 6 5 4 3 2 1 0
	
	return 0;
	
} 
 
自定义排序准则
 
 上面我们说到sort()函数可以自定义排序准则，以便满足不同的排序情况。使用sort()我们不仅仅可以从大到小排或者从小到大排，还可以按照一定的准则进行排序。比如说我们按照每个数的个位进行从大到小排序，我们就可以根据自己的需求来写一个函数作为排序的准则传入到sort()中。
 我们可以将这个函数定义为：
 
bool cmp(int x,int y){
	return x % 10 > y % 10;
}
 
然后我们将这个cmp函数作为参数传入sort()中即可实现了上述排序需求。
 
#include<iostream>
#include<algorithm>
using namespace std;

bool cmp(int x,int y){
	return x % 10 > y % 10;
}

int main(){
	int num[10] = {65,59,96,13,21,80,72,33,44,99};
	sort(num,num+10,cmp);
	for(int i=0;i<10;i++){
		cout<<num[i]<<" ";
	}//输出结果：59 99 96 65 44 13 33 72 21 80
	
	return 0;
	
} 
 
对结构体进行排序
 
 sort()也可以对结构体进行排序，比如我们定义一个结构体含有学生的姓名和成绩的结构体Student，然后我们按照每个学生的成绩从高到底进行排序。首先我们将结构体定义为：
 
struct Student{
	string name;
	int score;
	Student() {}
	Student(string n,int s):name(n),score(s) {}
};
 
根据排序要求我们可以将排序准则函数写为：
 
bool cmp_score(Student x,Student y){
	return x.score > y.score;
}
 
完整代码：
 
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

struct Student{
	string name;
	int score;
	Student() {}
	Student(string n,int s):name(n),score(s) {}
};

bool cmp_score(Student x,Student y){
	return x.score > y.score;
}

int main(){
	Student stu[3];
	string n;
	int s;
	for(int i=0;i<3;i++){
		cin>>n>>s;
		stu[i] = Student(n,s);
	}
	
	sort(stu,stu+3,cmp_score);
	
	for(int i=0;i<3;i++){
		cout<<stu[i].name<<" "<<stu[i].score<<endl;
	}
	
	return 0;
}
 
 
再比如每一个学生有四科成绩，我们需要根据学生的四科成绩的平均分高低进行排名，那么这个cmp函数我们就可以定义为：
 
bool cmp_score(Student x,Student y){
	double average_x,average_y;
	average_x = (x.score[0]+x.score[1]+x.score[2]+x.score[3])/4;
	average_y = (y.score[0]+y.score[1]+y.score[2]+y.score[3])/4;
	return average_x > average_y;
}
 
完整代码：
 
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

struct Student{
	string name;
	double score[4];
};

bool cmp_score(Student x,Student y){
	double average_x,average_y;
	average_x = (x.score[0]+x.score[1]+x.score[2]+x.score[3])/4;
	average_y = (y.score[0]+y.score[1]+y.score[2]+y.score[3])/4;
	return average_x > average_y;
}

int main(){
	Student stu[3];
	string n;
	int s;
	for(int i=0;i<3;i++){
		cin>>stu[i].name;
		for(int j=0;j<4;j++){
			cin>>stu[i].score[j];
		}
	}
	
	sort(stu,stu+3,cmp_score);
	
	for(int i=0;i<3;i++){
		cout<<stu[i].name<<" ";
		for(int j=0;j<4;j++){
			cout<<stu[i].score[j]<<" ";
		}
		cout<<endl;
	}
	
	return 0;
}
 
 
 
 
 以上就是对于sort()用法的详解了。如果你觉得我的文章对你有用请点个赞支持一下吧，喜欢我写的文章那么请点个关注再走鸭，您的关注是对我最大的支持。如果此文章有错误或者有不同的见解欢迎评论或者私信。
  
 我是ACfun：一个成长中的程序猿，感谢大家的支持。
 

 
 
一、sort_values()函数用途
 
 
pandas中的sort_values()函数原理类似于SQL中的order by，可以将数据集依照某个字段中的数据进行排序，该函数即可根据指定列数据也可根据指定行的数据排序。
 
 
 
二、sort_values()函数的具体参数
 
 
 
用法：
 DataFrame.sort_values(by=‘##’,axis=0,ascending=True, inplace=False, na_position=‘last’)
 
 
参数说明
 
 
参数
说明
by
指定列名(axis=0或’index’)或索引值(axis=1或’columns’)
axis
若axis=0或’index’，则按照指定列中数据大小排序；若axis=1或’columns’，则按照指定索引中数据大小排序，默认axis=0
ascending
是否按指定列的数组升序排列，默认为True，即升序排列
inplace
是否用排序后的数据集替换原来的数据，默认为False，即不替换
na_position
{‘first’,‘last’}，设定缺失值的显示位置
 
 
三、sort_values用法举例
 
 
创建数据框
 
#利用字典dict创建数据框
import numpy as np
import pandas as pd
df=pd.DataFrame({'col1':['A','A','B',np.nan,'D','C'],
                 'col2':[2,1,9,8,7,7],
                 'col3':[0,1,9,4,2,8]
})
print(df)

>>>
  col1  col2  col3
0    A     2     0
1    A     1     1
2    B     9     9
3  NaN     8     4
4    D     7     2
5    C     7     8
 
依据第一列排序，并将该列空值放在首位
 
#依据第一列排序，并将该列空值放在首位
print(df.sort_values(by=['col1'],na_position='first'))
>>>
  col1  col2  col3
3  NaN     8     4
0    A     2     0
1    A     1     1
2    B     9     9
5    C     7     8
4    D     7     2
 
依据第二、三列，数值降序排序
 
#依据第二、三列，数值降序排序
print(df.sort_values(by=['col2','col3'],ascending=False))
>>>
  col1  col2  col3
2    B     9     9
3  NaN     8     4
5    C     7     8
4    D     7     2
0    A     2     0
1    A     1     1
 
根据第一列中数值排序，按降序排列，并替换原数据
 
#根据第一列中数值排序，按降序排列，并替换原数据
df.sort_values(by=['col1'],ascending=False,inplace=True,
                     na_position='first')
print(df)
>>>
  col1  col2  col3
3  NaN     8     4
4    D     7     2
5    C     7     8
2    B     9     9
1    A     1     1
0    A     2     0
 
按照索引值为0的行，即第一行的值来降序排序
 
x = pd.DataFrame({'x1':[1,2,2,3],'x2':[4,3,2,1],'x3':[3,2,4,1]}) 
print(x)
#按照索引值为0的行，即第一行的值来降序排序
print(x.sort_values(by =0,ascending=False,axis=1))
>>>
   x1  x2  x3
0   1   4   3
1   2   3   2
2   2   2   4
3   3   1   1
   x2  x3  x1
0   4   3   1
1   3   2   2
2   2   4   2
3   1   1   3