深圳同城快跑笔试题目 1 约瑟夫环

参见

http://www.cnblogs.com/cici-new/p/3154553.html

package com.cici.linknode;

public interface Node{

　　　　public Object data = null;

           public Node next = null;

           public void display();

}

package com.cici.linklist.exercise;
import com.cici.linknode.LinkNode;

package com.cici.linknode;
/**
 * Copyright:   WANGCH
 * Company:     WANGCH
 * @fileName: LinkNode.java
 * @Description:
 * @Create date: 2013-6-20 上午12:14:31
 * @Create by: wangchao(wangchao_new@163.com)
 * @Update Date: 2013-6-20 上午12:14:31
 * @Update by: WANGCH(wangchao_new@163.com)
 * @version 5.1
 */

public class LinkNode implements Node{
    public int iData;//data
    public double dData;//data
    public LinkNode next; //reference to next link
    
    //constructor
    public LinkNode(int id,double dd){
        iData = id;
        dData = dd;
    }
    public void display(){
        //display itself
        System.out.println
        ("iData  :  "+iData+"    dData:"+dData);
    }
}//end class LinkNode

package com.cici.linklist.exercise;

import com.cici.linknode.LinkNode;

/**
 * Copyright:   WANGCH
 * Company:     WANGCH
 * @fileName: CircleListNew.java
 * @Description:
 * @Create date: 2013-6-24 下午11:53:36
 * @Create by: wangchao(wangchao_new@163.com)
 * @Update Date: 2013-6-24 下午11:53:36
 * @Update by: WANGCH(wangchao_new@163.com)
 * @version 5.1
 */
/*单链表节点实现的有序循环链表*/
public class CircleList {
    private LinkNode current;//当前节点的指针
    public int nItems;//链表内节点个数
    public CircleList(){
        current = null;
    }
    public LinkNode peek() { // 返回最早插入的元素  
        // 调用前要判断是否为空  
        return current.next;  
    }  
    public LinkNode find(int value) {  
        LinkNode temp = current; // 保存原来的位置  
        do{
            if(current.iData == value) return current;
            stepNext();
        }while(current!=temp);
      
        throw new RuntimeException("不能找到该值 :"+value);
    }
    //添加新元素
    public void insert(LinkNode node){
        if(isEmpty()) {
            node.next = node;
            current = node;// 插入元素，current要移动要新元素  
        }else{
            node.next = current.next;
             current.next = node;
             current = node;// 插入元素，current要移动要新元素  
            
        }
        nItems++;
    } 
    //当前元素无法删除自身 只能删除当前元素的下一个元素
  public LinkNode remove() {  
     // list为空是没有考虑，在调用remove之前应该判断是否为空 
      if(isEmpty()){
            throw new RuntimeException("链表当前为空 ,不能删除操作");
        }
      LinkNode temp = current.next;// 删掉current的下一个元素  
      if (current.next == current) { // 只有一个元素时  
          current = null;  
      } else {  
          current.next = current.next.next;  
      } 
        nItems--;
        return temp;
    }
 
    public void displayList() {
        if(isEmpty()){
            throw new RuntimeException("链表当前为空 ,不需要显示");
        }
            LinkNode temp = current;
            do {
                // 从current
                stepNext();
                current.display();
            } while (current != temp);
            System.out.println();
    }
    
    /*指针移向下一处节点，返回指针指向的最新节点 */
    public LinkNode stepNext(){
        if(isEmpty())
            throw new RuntimeException
            ("链表当前为空,指针不能移向下一个节点");
        current = current.next;
        return current;
    }
     public int size() {  
            return nItems;  
        }  
    public boolean isEmpty(){
        return current== null;
    }
    public static void main(String[] args) {
        LinkNode node1 = new LinkNode(10,10.1);
        LinkNode node2 = new LinkNode(20,20.2);
        LinkNode node3 = new LinkNode(5,5.5);
        CircleList list = new CircleList();
        list.insert(node1);
        list.insert(node2);
        list.insert(node3);
        System.out.println("Before delete");
        list.displayList();
        System.out.println("After delete");
        list.remove();
        list.displayList();
        
        /*int target = list.find(20).iData;
        System.out.println("找到的值为"+target);*/
    }
}

package com.cici.linklist.exercise;

import com.cici.linknode.LinkNode;

/**
 * Copyright:   WANGCH
 * Company:     WANGCH
 * @fileName: JosephusRing.java
 * @Description:
 * @Create date: 2013-6-22 下午8:03:34
 * @Create by: wangchao(wangchao_new@163.com)
 * @Update Date: 2013-6-22 下午8:03:34
 * @Update by: WANGCH(wangchao_new@163.com)
 * @version 5.1
 */
/*5.5 Josephus问题是古代一个著名的数学难题。围绕这个问题有很多故事。其 
中一个说Josephus是一群被罗马人抓获的犹太人中的一个，为了不被奴役， 
他们选择自杀。他们排成一个圆圈，从某个人开始，沿着圆圈计数。每报 
第n个数的人就要离开圆圈去自杀。Josephus不想死，所以他制定了规则， 
以使他成为最后一个离开圆圈的人。如果有（例如）20个人的话，他就是 
从开头数第7个人，那么他让他们用什么数来进行报数呢？这个问题会越来 
越复杂，因为随着过程进行，圆圈在缩小。使用5.3题的循环链表创建一个 
应用来模拟这个问题。输入是组成圆圈的人数，要报的数和第一个开始报的 
人的位置（通常是1）。输出是被消去的人的列表。当一个人出了圆圈，再 
继续从他左边那个人开始计数（假设沿顺时针旋转）。这有一个例子。有7 
个人，从1到7，从第一个人开始报数，报到4出圆圈，最后被消去的人的顺 
序是4，1，6，5，7，3。最后剩下的人是2。*/
public class JosephusRing {
        public static LinkNode  getJosephus(int number){
            CircleList circleList=
            new CircleList();
            //Initialise the link list
        for (int i=1;i<=number;i++){
            LinkNode node =
                    new LinkNode(i,i+0.1);
            circleList.insert(node);
        }
        System.out.println("原始的圈子:");
        circleList.displayList();
        System.out.println("出圈子的顺序 :");
 
        while(circleList.nItems!=1){
            System.out.println("圈子中的人数 :"+circleList.nItems );
            for(int j=1;j<4;j++)
                circleList.stepNext();
            System.out.print(circleList.remove().iData + " ");
        }
        System.out.println();
        return circleList.peek();    
        }
        public static void main(String[] args) {
            LinkNode number = 
                    JosephusRing.getJosephus(7);
            System.out.println("Josephus的编号是 ："+ number.iData);
        }
}