我以两个数组的形式给出时间间隔。
A[0]= 2 B[0]=3
A[1]= 9 B[1]=11
A[2] = 5 B[2]=6
A[3] = 3 B[3]=10
我想按照开始时间的基本条件对间隔进行排序，即
(2,3) , (3,10) ,(5,6) ,(9,11)
我是否必须制作此结构。或者它可以直接完成。
答案 0 :(得分：1)
它可以直接完成，因为你没有显示到目前为止你尝试了什么我只是给你算法：
for j = 1 to n
for i = i+1 to n
if(A[i]>A[j]){
swap(A[i],A[j])
swap(B[i],B[j])
}
您可以轻松将其转换为java代码。
如果你想要更好的算法使用这个wiki link来改善你的时间，那么这个算法就是buble sort。
正如DwB想要的那样是合并排序完整的java代码，它可以做你想要的。我从here获得了合并排序算法并进行修改以满足您的需求。您也可以在Ideone
上看到工作版本合并排序：
import java.util.*;
import java.lang.*;
import java.io.*;
class Ideone
{
private int[] A;
private int[] B;
private int[] helperA;
private int[] helperB;
private int length;
public static void main (String[] args){
int[] As = {2,9,5,3};
int[] Bs = {3,11,6,10};
new Ideone().sort(As,Bs);
}
public void sort(int[] As , int[] Bs) {
A = As;
B = Bs;
length = A.length;
this.helperA = new int[length];
this.helperB = new int[length];
mergesort(0, length - 1);
for(int i = 0 ; i<length ; i++)
System.out.println("(" + A[i] + "," + B[i]+ ")");
}
private void mergesort(int low, int high) {
// check if low issmaller then high, if not then the array is sorted
if (low < high) {
// Get the index of the element which is in the middle
int middle = low + (high - low) / 2;
// Sort the left side of the array
mergesort(low, middle);
// Sort the right side of the array
mergesort(middle + 1, high);
// Combine them both
merge(low, middle, high);
}
}
private void merge(int low, int middle, int high) {
// Copy both parts into the helper array
for (int i = low; i <= high; i++) {
helperA[i] = A[i];
helperB[i] = B[i];
}
int i = low;
int j = middle + 1;
int k = low;
// Copy the smallest values from either the left or the right side back
// to the original array
while (i <= middle && j <= high) {
if (helperA[i] <= helperA[j]) {
A[k] = helperA[i];
B[k] = helperB[i];
i++;
} else {
A[k] = helperA[j];
B[k] = helperB[j];
j++;
}
k++;
}
// Copy the rest of the left side of the array into the target array
while (i <= middle) {
A[k] = helperA[i];
B[k] = helperB[i];
k++;
i++;
}
}
}
答案 1 :(得分：1)
尝试：
private static class StartEnd implements Comparable<StartEnd> {
private final int start;
private final int end;
// + constructor + getters
@Override
public int compareTo(StartEnd other) {
return start - other.getStart();
}
}
public void sort(int[] starts, int[] ends) {
StartEnd[] ses = new StartEnd[starts.length];
for(int i = 0 ; i < starts.length ; ++i) {
ses[i] = new StartEnd(starts[i], ends[i]);
}
Arrays.sort(sis);
// re-insert
for(int i = 0 ; i < ses.length ; ++i) {
starts[i] = ses[i].getStart;
ends[i] = ses[i].getEnd();
}
}
答案 2 :(得分：0)
而是拥有两个数组，创建保存间隔的对象
class Interval implements Comparable<Interval> {
private Long start,completed
public Interval(Long start, Long completed) {
this.start = start;
this.completed = completed;
}
@Override
public int compareTo(Interval o) {
return start.compareTo(o.start);
}
//getters and setters ommited
}
然后，您需要做的就是实施compareTo方法并将所有数据放入某个集合中，即List<Interval> intervals
并使用Collections.sort(intervals)对其进行排序
修改
示例：
最初你有：
A[0]= 2 B[0]=3,
A[1]= 9 B[1]=11
A[2] = 5 B[2]=6
A[3] = 3 B[3]=10`
让我们将其替换为：
List<Interval> intervals = new ArrayList<>();
intervals.add(new Interval(2L,3L));
intervals.add(new Interval(9L,11L));
intervals.add(new Interval(5L,6L));
intervals.add(new Interval(3L,10L));
//NOTE L is added at the end variable as interval uses Long, if you change it to integer you dont need to add it;
现在你需要做的就是排序
Collection.sort(intervals);
答案 3 :(得分：0)
第1步：Java是一种面向对象的语言;学习使用对象。
时间间隔的可能类
public class TimeInterval implements Comparable<TimeInterval>
{
private int end;
private int start;
public TimeInterval(
final int end,
final int start)
{
this.end = end;
this.start = start;
}
public int getEnd()
{
return end;
}
public int getStart()
{
return start;
}
public int comareTo(final TimeInterval other)
{
if (other == null)
{
return -1; // this will put the null value objects at the end.
}
return start - other.start;
}
}
答案 4 :(得分：0)
古典爪哇人＆＃34;面向对象＆＃34;对此的方法是使用存储一对值（在这种情况下为int值）的专用类，并对它们进行排序，正如大多数其他答案中已经指出的那样。不过，我建议不制作此课程Comparable。相反，可以使用Comparator，这将使引入新的排序顺序更容易。特别地，可以存在Comparator实现，用于分别基于第一/第二值以升序/降序排序。只有这样，面向对象才能发挥其优势，弥补了“劣势”。必须创建这样一对int值作为＆＃34;虚拟数据结构＆＃34;首先......
但是，我想尝试找到原始问题的解决方案，即排序两个数组＆＃34;同步＆＃34;。尽管排序的任务似乎微不足道，但是可以将很多工作投入到正确的中（参见Chapter 3 of TAOCP）。即使对于中型阵列，冒泡排序也很简单但效率低下。在尝试使索引正确时，实现快速或合并排序可能很繁琐。但是，只需从sort中获取现有的java.lang.Arrays方法，并将最基本的构建块分解出来，即可获得一个解决方案：swap函数：
public class ArraySort
{
public static void main(String[] args)
{
final int A[] = new int[4];
final int B[] = new int[4];
A[0] = 2; B[0] = 3;
A[1] = 9; B[1] = 11;
A[2] = 5; B[2] = 6;
A[3] = 3; B[3] = 10;
Swapper swapper = new Swapper()
{
@Override
public void swap(int array[], int i0, int i1)
{
ArraySort.swap(A, i0, i1);
ArraySort.swap(B, i0, i1);
}
};
sort(A, 0, A.length, swapper);
for (int i=0; i<A.length; i++)
{
System.out.println("("+A[i]+","+B[i]+")");
}
}
interface Swapper
{
void swap(int array[], int i0, int i1);
}
public static void swap(int array[], int i0, int i1)
{
int t = array[i0];
array[i0] = array[i1];
array[i1] = t;
}
// The following methods are copied from java.util.Arrays:
public static void sort(int x[], int off, int len, Swapper swapper)
{
if (len < 7)
{
for (int i = off; i < len + off; i++)
{
for (int j = i; j > off && x[j - 1] > x[j]; j--)
{
swapper.swap(x, j, j - 1);
}
}
return;
}
int m = off + (len >> 1);
if (len > 7)
{
int l = off;
int n = off + len - 1;
if (len > 40)
{
int s = len / 8;
l = med3(x, l, l + s, l + 2 * s);
m = med3(x, m - s, m, m + s);
n = med3(x, n - 2 * s, n - s, n);
}
m = med3(x, l, m, n);
}
int v = x[m];
int a = off, b = a, c = off + len - 1, d = c;
while (true)
{
while (b <= c && x[b] <= v)
{
if (x[b] == v)
{
swapper.swap(x, a++, b);
}
b++;
}
while (c >= b && x[c] >= v)
{
if (x[c] == v)
{
swapper.swap(x, c, d--);
}
c--;
}
if (b > c)
{
break;
}
swapper.swap(x, b++, c--);
}
int s, n = off + len;
s = Math.min(a - off, b - a);
vecswap(x, off, b - s, s, swapper);
s = Math.min(d - c, n - d - 1);
vecswap(x, b, n - s, s, swapper);
if ((s = b - a) > 1)
{
sort(x, off, s, swapper);
}
if ((s = d - c) > 1)
{
sort(x, n - s, s, swapper);
}
}
private static void vecswap(int x[], int a, int b, int n, Swapper swapper)
{
for (int i = 0; i < n; i++, a++, b++)
{
swapper.swap(x, a, b);
}
}
private static int med3(int x[], int a, int b, int c)
{
return (x[a] < x[b] ? (x[b] < x[c] ? b : x[a] < x[c] ? c : a)
: (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
}
}
这不是我推荐的解决方案。它只是试图回答这个问题
或者它可以直接完成。 [原文如此！]
答案是：是的，这是可能的，尽管引入某种IntPair的解决方案更具惯用性。
除此之外，内联和＃34;可能更有效率。 Swapper#swap调用直接交换存储在实例变量中的两个数组的元素，或作为方法参数传递。但是，我喜欢这种Swapper接口的通用性。另外，通过传递类似
interface IntArrayEntryComparator {
int compare(int array[], int i0, int i1);
}
但后者将超出我想用这个类测试/演示的内容。