循环报数

题目描述：

 *输入1个数字和多个字符，中间均以空格隔开。假设数字取值为m（范围1~9），后面字符个数为n。
 *假设n个字符围成一圈，从第一个字母开始循环报数，当数到m以后，第m个字母就出列，直到这n个字母全部出列。
 *最后，按照出列的顺序输出这些字母，中间仍以空格隔开。取值范围：m为1到9， 字符个数n大于1小于20。

输入:
第一个为数字，后面为多个字符，均以空格隔开
输出:
输出重新排列后的字符，以空格隔开
样例输入:
3 a b c d e f g h i
样例输出:
c f i d h e b g a

代码实现：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

/**
 * @author njupt
 *输入1个数字和多个字符，中间均以空格隔开。假设数字取值为m（范围1~9），后面字符个数为n。
 *假设n个字符围成一圈，从第一个字母开始循环报数，当数到m以后，第m个字母就出列，直到这n个字母全部出列。
 *最后，按照出列的顺序输出这些字母，中间仍以空格隔开。取值范围：m为1到9， 字符个数n大于1小于20。
 */
public class CycleNum {

  
  class DoubleCycleLinkedList{
	  private char[] initArr;
	  
	  private Node header=new Node();
	  
	  private int size=0;
	  
	  public DoubleCycleLinkedList(char[] initArr){
		  this.initArr=initArr;
	  }
	  
	  public Node createNode(char val){
		  Node n=new Node(null,null,val);
		  return n;
	  }
	  
	  public void add(char val){
		  Node n=createNode(val);
		  Node temp=header.pre;
		  temp.next=n;
		  n.pre=temp;
		  n.next=header;
		  header.pre=n;
		  size++;
	  }
	  
	  public void remove(char val){
		  Node temp=header;
		  while(size!=0){
			  if(temp.value==val){
				  temp.pre.next=temp.next;
				  temp.next.pre=temp.pre;
				  temp=null;
				  size--;
				  break;
			  }
			  temp=temp.next;
		  }
	  }
	  
	  
	  public void init(){
		  header.setPre(header);
		  header.setNext(header);
		  header.setValue('0');
		  if(initArr==null)
			  return;
		  Node temp=header;
		  for(int i=0;i<initArr.length;i++){
			  Node n=createNode(initArr[i]);
			  n.setNext(null);
			  n.setPre(temp);
			  temp.setNext(n);
			  temp=n;
			  size++;
		  }
		  temp.setNext(header);
		  header.setPre(temp);
	  }
	  
	  
	  //节点
	  class Node{
		 private Node pre;//前一个节点
		 private Node next;//下一个节点
		 private char value;//值	  
		 
		 public Node(){}
		 
		 public Node(Node pre,Node next,char value){
			 this.pre=pre;
			 this.next=next;
			 this.value=value;
		 }

		public Node getPre() {
			return pre;
		}

		public void setPre(Node pre) {
			this.pre = pre;
		}

		public Node getNext() {
			return next;
		}

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

		public char getValue() {
			return value;
		}

		public void setValue(char value) {
			this.value = value;
		}
		 
		 
	  }


	  //按照索引删除
	public char remove(int index) {
		Node temp=header;
		int num=0;
		while(num!=index){
			temp=temp.next;
			if(temp.value!='0'){
				num++;
			}
		}
		char c=temp.getValue();
		remove(c);
		return c;
	}

	//根据num,循环报数
	public List<Character> count(int index) {
		Node temp=header;
		List<Character> list=new LinkedList<Character>();
		while(size!=0){
			int num=0;
			while(num!=index){
				temp=temp.next;
				if(temp.value!='0'){
					num++;
				}
			}
			char c=temp.getValue();
//			temp=temp.next;
			remove(c);
			list.add(c);
		}
		return list;
	}
  }
  
  
  public static char[] strArrToCharArr(String[] strArr){
	  char[] charArr=new char[strArr.length];
	  for (int i=0;i<strArr.length;i++) {
		char c=(strArr[i].toCharArray())[0];
		charArr[i]=c;
	}
	  return charArr;
  }
  
  
  
  private static DoubleCycleLinkedList initLink(String[] strArr) {	
	  
	  char[] charArr=strArrToCharArr(strArr);
	  CycleNum c=new CycleNum();
	  DoubleCycleLinkedList list=c.new DoubleCycleLinkedList(charArr);
	  list.init();
	  return list;
}



public static boolean valid(String input){
	  if(null!=input&&!"".equals(input)){
		  String[] temp=input.split(" ");
		  
		  for (int i = 0; i < temp.length; i++) {
			if(temp[i].length()!=1)
				return false;
		}
		  
		  char t=(temp[0].toCharArray())[0];
		  if(t<49||t>57)
			  return false;
		  if(input.length()-1<1||input.length()-1>20)
			  return false;
		  for (int i = 1; i < temp.length; i++) {
			  t=(temp[i].toCharArray())[0];
//			  if(t<'A'||(t>'A'&&t<'a')||t>'z')
			  if(t<'a'||t>'z')
				  return false;
		}
	  }
	  return true;
  }
  
  private static void print(List<Character> list){
	  for (int i = 0; i < list.size(); i++) {
		  if(i!=list.size()-1)
			  System.out.print(list.get(i)+" ");
		  else
			  System.out.println(list.get(i));
	}
  }
  public static void main(String[] args) throws IOException{
	  BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
	  String input=bf.readLine();
	  boolean b=valid(input);
	  if(!b)
		  return;
	  String[] inputArr=input.split(" ");
	  String[] charArr=Arrays.copyOfRange(inputArr, 1, inputArr.length);
	  int num=Integer.valueOf(inputArr[0]);
	  DoubleCycleLinkedList list=initLink(charArr);//初始化链表
	  List<Character> l=list.count(num);
	  print(l);
  }
  
}

</pre><pre name="code" class="java">

自己测试了多个用例没有问题，但是给的提交了只有一半用例通过，欢迎大家指正错误，积极讨论