POJ3784

POJ3784(链表)

---

Running Median

Description

For this problem, you will write a program that reads in a sequence of 32-bit signed integers. After each odd-indexed value is read, output the median (middle value) of the elements received so far.

Input

The first line of input contains a single integer P, (1 ≤ P ≤ 1000), which is the number of data sets that follow. The first line of each data set contains the data set number, followed by a space, followed by an odd decimal integer M, (1 ≤ M ≤ 9999), giving the total number of signed integers to be processed. The remaining line(s) in the dataset consists of the values, 10 per line, separated by a single space. The last line in the dataset may contain less than 10 values.

Output

For each data set the first line of output contains the data set number, a single space and the number of medians output (which should be one-half the number of input values plus one). The output medians will be on the following lines, 10 per line separated by a single space. The last line may have less than 10 elements, but at least 1 element. There should be no blank lines in the output.

Sample Input

3 
1 9 
1 2 3 4 5 6 7 8 9 
2 9 
9 8 7 6 5 4 3 2 1 
3 23 
23 41 13 22 -3 24 -31 -11 -8 -7 
3 5 103 211 -311 -45 -67 -73 -81 -99 
-33 24 56

Sample Output

1 5
1 2 3 4 5
2 5
9 8 7 6 5
3 12
23 23 22 22 13 3 5 5 3 -3 
-7 -3

题意

​ 读入 n 个整数，当读入奇数个数时，输出目前读到数的中位数。

思路

​ 用链表维护一个有序序列，当输入个数为奇数时，记录中位数。

代码

public class RunningMedian {
  static class Node {
    private Node next;
    private int data;

    public int getData() {
      return data;
    }

    public Node getNext() {
      return next;
    }

    public void setData(int data) {
      this.data = data;
    }

    public void setNext(Node next) {
      this.next = next;
    }

    public static Node setData(Node head, int index, int data) {
      Node p = head;
      int count = 0;
      while (count < index - 1 && p != null) {
        p = p.getNext();
        count++;
      }
      Node tmp = new Node();
      tmp.setData(data);
      tmp.next = p.next;
      p.next = tmp;
      return head;
    }
  }

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();

    while (n-- > 0) {
      int num = sc.nextInt();
      int count = sc.nextInt();
      if (count <= 0) {
        continue;
      }
      List<Integer> result = new ArrayList<Integer>();
      Node head = new Node();
      head.setData(-999999);
      head.setNext(null);
      for (int i = 0; i < count; i++) {
        int data = sc.nextInt();
        Node p = head;
        int index = 0;
        while (p != null) {
          if (p.getData() < data) {
            index++;
            p = p.getNext();
          } else {
            break;
          }
        }
        head = Node.setData(head, index, data);
        if (i % 2 == 0) {
          p = head.getNext();
          int tmp = (i + 1) / 2;
          for (int j = 0; j < tmp; j++) {
            p = p.next;
          }
          result.add(p.getData());
        }
      }
      System.out.println(num + " " + ((count + 1) / 2));
      for (int i = 1; i < result.size(); i++) {
        if (i % 10 == 0) {
          System.out.println(result.get(i - 1) + " ");
        } else {
          System.out.print(result.get(i - 1) + " ");
        }
      }
      System.out.println(result.get(result.size() - 1));
    }
  }

}