排序题目汇总

---

最大数

class Solution {
public:
    string largestNumber(vector<int>& nums) {
        vector<string>res;
        int n=nums.size();
        for(int i=0;i<n;++i){
            res.push_back(to_string(nums[i]));
        }
        sort(res.begin(),res.end(),[&](string& a,string& b){
            return a+b>b+a;
        });
        string ans;
        for(string s:res){
            ans+=s;
        }
        // if(ans=="0")return "0";
        int i=0;
        while(i<ans.length()&&ans[i]=='0'){
            ++i;
        }
        if(i==ans.length())return "0";
        return ans.substr(i);
    }
};

---

整数奇偶排序

#include<bits/stdc++.h>
using namespace std;
int main(){
    int a[10];
    while(cin>>a[0]>>a[1]>>a[2]>>a[3]>>a[4]>>a[5]>>a[6]>>a[7]>>a[8]>>a[9]){
        sort(a,a+10,[&](int& x,int& y){
            if((x&1)==0&&(y&1)==0){//都是偶数
                return x<y;
            }else if((x&1)==1&&(y&1)==1){//都是奇数
                return x>y;
            }else if((x&1)==1&&(y&1)==0){
                return -(x&1)<-(y&1);
            }else{
                return (x&1)>(y&1);
            }
        });
        for(int i=0;i<10;++i){
            printf("%d ",a[i]);
        }printf("\n");
    }
}

---

成绩排序

注意点：
如果成绩相同，需要根据读入的先后顺序进行排序，我们可以多加一个属性来进行比较。

#include<bits/stdc++.h>
using namespace std;
typedef struct {
    int id;
    string name;
    int grade;
}stu;
bool compare0(stu s1,stu s2){
    if(s1.grade==s2.grade){
        return s1.id<s2.id;
    }
    return s1.grade>s2.grade;
    
}
bool compare1(stu s1,stu s2){
    if(s1.grade==s2.grade){
        return s1.id<s2.id;
    }
    return s1.grade<s2.grade;
    
}
int main(){
    int n,t;
    while(~scanf("%d%d",&n,&t)){
        stu s[n];
        string name;
        int grade;
        int id;
        for(int i=0;i<n;++i){
            cin>>name>>grade;
            s[i].name=name;
            s[i].grade=grade;
            s[i].id=i;
        }
        if(t==0)sort(s,s+n,compare0);
        else sort(s,s+n,compare1);
        for(int i=0;i<n;++i){
            cout<<s[i].name<<" "<<s[i].grade<<endl;
        }
    }
    
    return 0;
}

---

字符串排序

（用到了 $substring()$ 截取字符串方法，字符串转数字 $Integer.parseInt()$ ）

月神拿到一个新的数据集，其中每个样本都是一个字符串（长度小于100），样本的的后六位是纯数字，月神需要将所有样本的后六位数字提出来，转换成数字，并排序输出。

月神要实现这样一个很简单的功能确没有时间，作为好朋友的你，一定能解决月神的烦恼，对吧。

输入描述:

每个测试用例的第一行是一个正整数M（1<=M<=100)，表示数据集的样本数目

接下来输入M行，每行是数据集的一个样本，每个样本均是字符串，且后六位是数字字符。

输出描述:

对每个数据集，输出所有样本的后六位构成的数字排序后的结果（每行输出一个样本的结果）

示例1

输入

4	
abc123455
boyxx213456
cba312456
cdwxa654321

输出

123455
213456
312456
654321

import java.util.Arrays;
import java.util.Scanner;

public class StringSort {

	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int M=scan.nextInt();
		scan.nextLine();
		String[] strs=new String[M];
		for(int i=0;i<M;++i) {
			strs[i]=scan.nextLine();
		}
		int[] nums=new int[M];
		for(int i=0;i<M;++i) {
			nums[i]=Integer.parseInt(strs[i].substring(strs[i].length()-6,strs[i].length()));
		}
		Arrays.sort(nums);
		for(int i=0;i<M;++i) {
			System.out.println(nums[i]);
		}
	}
}

insert-interval

给定一组不重叠的时间区间，在时间区间中插入一个新的时间区间(如果有重叠的话就合并区间)。
这些时间区间初始是根据它们的开始时间排序的。

示例1:

给定时间区间[1,3]，[6,9]，在这两个时间区间中插入时间区间[2,5]，并将它与原有的时间区间合并，变成[1,5],[6,9].

示例2：

给定时间区间[1,2], [3,5] ,[6,7], [8,10], [12,16],在这些时间区间中插入时间区间[4,9]，并将它与原有的时间区间合并,变成[1,2],[3,10],[12,16].
这是因为时间区间[4,9]覆盖了时间区间[3,5],[6,7],[8,10].

算法思路：

情形一：将 $newInterval$ 加进 $ans$ 里，退出循环;

情形二：将 $intervals[i]$ 添加进 $ans$ 里，继续判断下一个 $intervals[i]$ ；

情形三：更新 $newInterval$ 边界。

import java.util.*;

/*
 * public class Interval {
 *   int start;
 *   int end;
 *   public Interval(int start, int end) {
 *     this.start = start;
 *     this.end = end;
 *   }
 * }

*/
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 
     * @param intervals Interval类ArrayList 
     * @param newInterval Interval类 
     * @return Interval类ArrayList
     */
    public ArrayList<Interval> insert (ArrayList<Interval> intervals, Interval newInterval) {
        
        ArrayList<Interval>ans=new ArrayList<>();
        int i;
        for(i=0;i<intervals.size();++i){
            if(newInterval.end<intervals.get(i).start){
                 ans.add(newInterval);
	             break;
	         }
	         else if(newInterval.start>intervals.get(i).end){
	             ans.add(intervals.get(i));
	         }
	         else {
	             newInterval.start=Math.min(newInterval.start,intervals.get(i).start);
                 newInterval.end=Math.max(newInterval.end,intervals.get(i).end);
             }     
        }
        
       if(i==intervals.size()){
           ans.add(newInterval);
       }
       else{
            for(int j=i;j<intervals.size();++j){
                ans.add(intervals.get(j));
            }
       }
       
       return ans;
       
    }
    
}

最大点集

P为给定的二维平面整数点集。定义P中某点x，如果x满足P中任意点都不在x的右上方区域内（横纵坐标都大于x），则称其为“最大的”。求出所有“最大的”点的集合。（所有点的横坐标和纵坐标都不重复,坐标轴范围在[0, 1e9]内）。

如下图：实心点为满足条件的点的集合。

请实现代码找到集合P中的所有”最大“点的集合并输出。

输入描述:

第一行输入点集的个数N， 接下来N行，每行两个数字代表点的X轴和Y轴。1 ≤ n ≤ 500000

输出描述:

输出“最大的”点集合， 按照X轴从小到大的方式输出，每行两个数字分别代表点的X轴和Y轴。

示例1

输入

5
1 2
5 3
4 6
7 5
9 0

输出

4 6
7 5
9 0

备注:

输出结果按照x轴排序。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;



public class MaxPointArray {
	public static class Compare implements Comparator<int[]>{
		@Override
		public int compare(int[] o1, int[] o2) {
			return o2[1]-o1[1];
		}
	}
	public static void main(String[] args) {
	
		BufferedReader in =new BufferedReader(new InputStreamReader(System.in));
		int n=Integer.parseInt(in.readLine());
		int[][] arr=new int[n][2];
		for(int i=0;i<n;++i) {
			String[] strs=in.readLine().split(" ");
			arr[i][0]=Integer.parseInt(strs[0]);
			arr[i][1]=Integer.parseInt(strs[1]);
		}
		Arrays.sort(arr,new Compare());
		int rightest=arr[0][0];
		System.out.println(arr[0][0]+" "+arr[0][1]);
		for(int i=1;i<arr.length;++i) {
			if(arr[i][0]>rightest) {
				rightest=arr[i][0];
				System.out.println(arr[i][0]+" "+arr[i][1]);
			}
		}
	}
}

算法思路：

对y坐标按照降序排列，遍历一遍点集，在这个过程中，去不断更新当前x坐标的最大值，当前点的x坐标如果大于x坐标最大值，那么当前的点就是最大的。

本题出现的问题:

输入数据较多，输入较慢，运行超时，采用 $BufferedReader$.