最近在刷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 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)

 

Comparator是个接口，可重写compare()及equals()这两个方法,用于比价功能；如果是null的话，就是使用元素的默认顺序，如a,b,c,d,e,f,g，就是a,b,c,d,e,f,g这样，当然数字也是这样的。

 

compare（a,b）方法:根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

equals（obj）方法：仅当指定的对象也是一个 Comparator，并且强行实施与此 Comparator 相同的排序时才返回 true。

 

Collections.sort(list, new PriceComparator());的第二个参数返回一个int型的值，就相当于一个标志，告诉sort方法按什么顺序来对list进行排序。

具体实现代码方法如下：

Book实体类：

 

package com.tjcyjd.comparator;

import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.TreeMap;

/**
 * 书实体类
 * 
 * @author yjd
 * 
 */
public class Book implements Comparable { // 定义名为Book的类，默认继承自Object类
	public int id;// 编号
	public String name;// 名称
	public double price; // 价格
	private String author;// 作者
	public GregorianCalendar calendar;// 出版日期

	public Book() {
		this(0, "X", 0.0, new GregorianCalendar(), "");
	}

	public Book(int id, String name, double price, GregorianCalendar calender,
			String author) {
		this.id = id;
		this.name = name;
		this.price = price;
		this.calendar = calender;
		this.author = author;
	}

	// 重写继承自父类Object的方法，满足Book类信息描述的要求
	public String toString() {
		String showStr = id + "\t" + name; // 定义显示类信息的字符串
		DecimalFormat formatPrice = new DecimalFormat("0.00");// 格式化价格到小数点后两位
		showStr += "\t" + formatPrice.format(price);// 格式化价格
		showStr += "\t" + author;
		SimpleDateFormat formatDate = new SimpleDateFormat("yyyy年MM月dd日");
		showStr += "\t" + formatDate.format(calendar.getTime()); // 格式化时间
		return showStr; // 返回类信息字符串
	}

	public int compareTo(Object obj) {// Comparable接口中的方法
		Book b = (Book) obj;
		return this.id - b.id; // 按书的id比较大小，用于默认排序
	}

	public static void main(String[] args) {
		Book b1 = new Book(10000, "红楼梦", 150.86, new GregorianCalendar(2009,
				01, 25), "曹雪芹、高鄂");
		Book b2 = new Book(10001, "三国演义", 99.68, new GregorianCalendar(2008, 7,
				8), "罗贯中 ");
		Book b3 = new Book(10002, "水浒传", 100.8, new GregorianCalendar(2009, 6,
				28), "施耐庵 ");
		Book b4 = new Book(10003, "西游记", 120.8, new GregorianCalendar(2011, 6,
				8), "吴承恩");
		Book b5 = new Book(10004, "天龙八部", 10.4, new GregorianCalendar(2011, 9,
				23), "搜狐");
		TreeMap tm = new TreeMap();
		tm.put(b1, new Integer(255));
		tm.put(b2, new Integer(122));
		tm.put(b3, new Integer(688));
		tm.put(b4, new Integer(453));
		tm.put(b5, new Integer(40));
		Iterator it = tm.keySet().iterator();
		Object key = null, value = null;
		Book bb = null;
		while (it.hasNext()) {
			key = it.next();
			bb = (Book) key;
			value = tm.get(key);
			System.out.println(bb.toString() + "\t库存：" + tm.get(key));
		}
	}
}




自定义比较器和测试类：

 

 

package com.tjcyjd.comparator;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.List;

public class UseComparator {
	public static void main(String args[]) {
		List<Book> list = new ArrayList<Book>(); // 数组序列
		Book b1 = new Book(10000, "红楼梦", 150.86, new GregorianCalendar(2009,
				01, 25), "曹雪芹、高鄂");
		Book b2 = new Book(10001, "三国演义", 99.68, new GregorianCalendar(2008, 7,
				8), "罗贯中 ");
		Book b3 = new Book(10002, "水浒传", 100.8, new GregorianCalendar(2009, 6,
				28), "施耐庵 ");
		Book b4 = new Book(10003, "西游记", 120.8, new GregorianCalendar(2011, 6,
				8), "吴承恩");
		Book b5 = new Book(10004, "天龙八部", 10.4, new GregorianCalendar(2011, 9,
				23), "搜狐");
		list.add(b1);
		list.add(b2);
		list.add(b3);
		list.add(b4);
		list.add(b5);
		// Collections.sort(list); //没有默认比较器，不能排序
		System.out.println("数组序列中的元素:");
		myprint(list);
		Collections.sort(list, new PriceComparator()); // 根据价格排序
		System.out.println("按书的价格排序:");
		myprint(list);
		Collections.sort(list, new CalendarComparator()); // 根据时间排序
		System.out.println("按书的出版时间排序:");
		myprint(list);
	}

	// 自定义方法：分行打印输出list中的元素
	public static void myprint(List<Book> list) {
		Iterator it = list.iterator(); // 得到迭代器，用于遍历list中的所有元素
		while (it.hasNext()) {// 如果迭代器中有元素，则返回true
			System.out.println("\t" + it.next());// 显示该元素
		}
	}

	// 自定义比较器：按书的价格排序
	static class PriceComparator implements Comparator {
		public int compare(Object object1, Object object2) {// 实现接口中的方法
			Book p1 = (Book) object1; // 强制转换
			Book p2 = (Book) object2;
			return new Double(p1.price).compareTo(new Double(p2.price));
		}
	}

	// 自定义比较器：按书出版时间来排序
	static class CalendarComparator implements Comparator {
		public int compare(Object object1, Object object2) {// 实现接口中的方法
			Book p1 = (Book) object1; // 强制转换
			Book p2 = (Book) object2;
			return p2.calendar.compareTo(p1.calendar);
		}
	}
}




 

 

一、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