自定义多列排序：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+5;
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)==1 && n){
        vector<Job> v;
        for(int i=0;i<n;i++){
            scanf("%d%d",&x,&y);
            v.push_back(Job{x,y});
        }

        sort(v.begin(),v.end());
        //输出
        for(int i=0;i<n;i++){
            printf("%d %d\n",v[i].x,v[i].y);
        }
      
    }
    return 0;
}

 

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

#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 1e4+5;
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)==1 && n){
        for(int i=0;i<n;i++){
            scanf("%d%d",&A[i].x,&A[i].y);
        }

        sort(A,A+n,cmp);
        for(int i=0;i<n;i++){
            printf("%d %d\n",A[i].x,A[i].y);
        }
       
    }
    return 0;
}

 

 

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