自定义多列排序：C++/Java实现

前言：

　　有些时候，我们在编程中会遇到多列排序的需求。假如在execle,这事儿就太easy了。不过没办法，现在就需要你用Java或者C++实现这样一个功能！

比如将下表无序的数据通过重排之后按照以下规则显示结果：

1.第二列从大到小排列

2.若第二列相等，则第一列按照从小到大排序

排序前	排序后
2 5 3 2 2 1 11 75 21 101 32 21 20 59 13 21	21 101 11 75 20 59 13 21 32 21 2 5 3 2 2 1

-------------------------------------

C++实现一：运算符重载

 #include <cstdio>
 #include <vector>
 #include <algorithm>
 using namespace std;
 
 const int maxn = 1e4+;
 struct Job{
     int x,y;
     bool operator < (const Job &j) const { //operator
         if(y==j.y){
             return x < j.x;
         }
         return y > j.y;
     }
 };
 
 int main(){
     // 从文件读入
     freopen("datain.txt","r",stdin);
     freopen("dataout.txt","w",stdout);
     int n,x,y;
     while(scanf("%d",&n)== && n){
         vector<Job> v;
         for(int i=;i<n;i++){
             scanf("%d%d",&x,&y);
             v.push_back(Job{x,y});
         }
 
         sort(v.begin(),v.end());
         //输出
         for(int i=;i<n;i++){
             printf("%d %d\n",v[i].x,v[i].y);
         }
 
     }
     return ;
 }

C++实现二：重写cmp()比较函数

 #include <cstdio>
 #include <algorithm>
 using namespace std;
 
 const int maxn = 1e4+;
 struct Job{
     int x,y;
 
 };
 bool cmp(Job j1,Job j2){
     if(j1.y==j2.y)
         return j1.x < j2.x;
     return j1.y > j2.y;
 }
 
 Job A[maxn];
 int main(){
     //将数据从文件读入
     freopen("datain.txt","r",stdin);
     int n;
     while(scanf("%d",&n)== && n){
         for(int i=;i<n;i++){
             scanf("%d%d",&A[i].x,&A[i].y);
         }
 
         sort(A,A+n,cmp);
         for(int i=;i<n;i++){
             printf("%d %d\n",A[i].x,A[i].y);
         }
 
     }
     return ;
 }

Java实现一：实现Comparable接口，重写compareTo()方法

 package sort;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
 /*
  * 重写Comparable接口的campareTo(Object o)方法
  */
 class Task implements Comparable<Task>{
     int x,y;
 
     public Task(int x,int y) {
         this.x=x;
         this.y=y;
     }
     @Override
     public int compareTo(Task o) {
         if(this.y==o.y)
             return this.x-o.x;
         return o.y-this.y;
     }
     @Override
     public String toString() {
         String r = this.x+" "+this.y;
         return r;
     }
 
 }
 public class TestCompare {
     public static void main(String[] args) {
         Task t1 = new Task(5,2);
         Task t2 = new Task(5,4);
         Task t3 = new Task(3,2);
 
         List<Task> tasks = new ArrayList<Task>();
         tasks.add(t1);
         tasks.add(t2);
         tasks.add(t3);
 
         //排序sort
         Collections.sort(tasks);
 
         //打印输出
         for(Task t:tasks){
             System.out.println(t);
         }
     }
 }

Java实现二：重写compare方法

 package sort;
 
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 
 import com.gdufe.mian4.Collection;
 import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils.Collections;
 
 class Job {
     int x;
     int y;
 
     public Job(int x, int y) {
         this.x = x;
         this.y = y;
     }
 
     public String toString() {
         String r = this.x + " " + this.y;
         return r;
     }
 }
 
 public class TestCompare2 {
 
     public static void main(String[] args) {
         List<Job> jobs = new ArrayList<Job>();
         Job j1 = new Job(2,4);
         Job j2 = new Job(5,3);
         Job j3 = new Job(1,4);
         jobs.add(j1);
         jobs.add(j2);
         jobs.add(j3);
 
         //重写Comparator接口的Compare方法：先按照第二列从大到小，若第二列相等则第一列从小到大排序
         Comparator<Job> c = new Comparator<Job>() {
 
             @Override
             public int compare(Job o1, Job o2) {
                 if(o1.y==o2.y){
                     return o1.x-o2.x;
                 }
                 return o2.y-o1.y;
             }
         };
 
         System.out.println("输出排序后的结果：");
         java.util.Collections.sort(jobs, c);
         for(Job job:jobs){
             System.out.println(job);
         }                
 
     }
 
 }