约瑟夫环问题1求解

约瑟夫环问题：
* 背景：约瑟夫叙述了他和40个士兵在罗马战争期间被罗马军队包围之后签订的一人自杀协定。
* 约瑟夫建议每个人杀掉他旁边的人,约瑟夫利用制定的规则使自己成为这些人中唯一的幸存者。
* 编程：

   1.考虑存储结构：顺序存储结构和链式存储结构(杀人模拟删除节点,链表更适合)
   2.场景：程序需要处理8个士兵组成的线性表,因为每个人要杀掉他的邻居，则要保证
   每个人都有邻居，因此采用循环单链表操作,指针指向的位置表示邻居。
   3.核心思想：从循环单链表中某个节点开始依次去除其相邻节点，直到链表中剩下一个节点为止

 ##思考使用循环双链表及奇数的情况

1.循环单链表数据结构

package com.neusoft.link;
import com.neusoft.List.IList;
/**
 * @author zhao-chj
 * 循环单链表
 */
public class CircleLinkList implements IList{
    public Node head;
    public CircleLinkList() {
        // TODO 初始化
        head=new Node();//初始化头结点
        head.next=head;
    }
    @Override
    public void clear() {
        // TODO 清空
        head.next=head;
    }
    @Override
    public boolean isEmpty() {
        // TODO 判空
        return head.next.equals(head);
    }
    @Override
    public int length() {
        // TODO 长度
        Node p =head.next;
        int length=0;
        while (!p.equals(head)) {
            p=p.next;
            length++;
        }
        return length;
    }
    @Override
    public Object get(int i) {
        // TODO 读取带头结点的循环链表中第i个数据元素
        Node p=head.next;
        int j=0;
        while (!p.equals(head)&&j<i) {
            p=p.next;
            j++;
        }
        if (j>i||p.equals(head)) {
            System.out.println("第"+i+"个元素不存在！");
        }
        return p.data;
    }

    @Override
    public void insert(int i, Object x) {
        // TODO 带头结点的循环链表中第i个节点之前插入一个值为x的元素
        Node p = head;
        int j=-1;//第i个节点前驱位置
        while ((!p.equals(head)||j==-1)&&j<i-1) {
            p=p.next;
            j++;
        }
        if (j>i-1||(p.equals(head)&&j!=-1)) {
            System.out.println("插入位置不合法！");
        }
        Node s =new Node(x);
        s.next=p.next;
        p.next=s;
    }

    @Override
    public void remove(int i) {
        // TODO 移除循环单链表中第i个元素的节点，注意i的范围
        Node p=head;//p指向要删除节点的前驱节点
        int j=-1;
        while ((!p.next.equals(head)||j==-1)&&j<i-1) {//找前驱元素
            p=p.next;
            j++;
        }
        if (j>i-1||(p.next.equals(head)&&j!=-1)) {
            System.out.println("删除位置不合法！");
        }
        p.next=p.next.next;
    }

    @Override
    public int indexOf(Object x) {
        // TODO 查找值为x的元素，返回位置
        Node p =head.next;//p指向首节点
        int j=0;
        while ((!p.equals(head))&&(!p.data.equals(x))) {
            p=p.next;
            j++;
        }
        if (!p.equals(head)) {
            return j;
        }else {
            return -1;
        }
    }
    @Override
    public void display() {
        // TODO 输出元素
        Node p =head.next;
        while (!p.equals(head)) {
            System.out.print(p.data+" ");
            p=p.next;
        }
        System.out.println();
    }

    @Override
    public int remove(Object i) {
        // TODO Auto-generated method stub
        return 0;
    }

}

2.约瑟夫环循环单链表求解

package com.neusoft.exercise;

import java.util.Scanner;

import com.neusoft.link.CircleLinkList;

/**
 * @author zhao-chj
 * 约瑟夫环问题：
 * 来源：约瑟夫叙述了他和40个士兵在罗马战争期间被罗马军队包围之后签订的一人自杀协定。
 * 约瑟夫建议每个人杀掉他旁边的人,约瑟夫利用制定的规则使自己成为这些人中唯一的幸存者。
 * 编程：1.考虑存储结构：顺序存储结构和链式存储结构(杀人模拟删除节点,链表更适合)
 *     2.场景：程序需要处理8个士兵组成的线性表,因为每个人要杀掉他的邻居，则要保证
 *     每个人都有邻居，因此采用循环单链表操作,指针指向的位置表示邻居。
 *     ##可以考虑使用循环双链表
 *     3.核心思想：从循环单链表中某个节点开始依次去除其相邻节点，直到链表中剩下一个节点为止
 *     
 */
public class TestLinearTable06 {
    public static void main(String[] args) {
        CircleLinkList circleLinkList = new CircleLinkList();
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入士兵的个数~");
        int num = sc.nextInt();
        System.out.println(num+"士兵分别为：");
        for (int i = 0; i < num; i++) {
            //输入num个士兵
            circleLinkList.insert(i, sc.next());
        }
        for (int i = 0; circleLinkList.length()>1; ) {
            i = i%circleLinkList.length();
            System.out.println("长度："+circleLinkList.length());//测试用可注释
            //读取到链表中位序号为i的士兵
            String str1= circleLinkList.get(i).toString();
            System.out.println("STR1："+str1);//测试用可注释
            //求出相邻士兵在链表中的位序号
            i=++i%circleLinkList.length();
            //相邻的士兵
            String str2 =circleLinkList.get(i).toString();
            System.out.println("STR2："+str2);//测试用可注释
            //杀死相邻的士兵
            circleLinkList.remove(i);
            //输出谁杀死谁的信息
            System.out.println(str1+"杀死"+str2);
        }
        System.out.println("活着的是(约瑟夫)是："+circleLinkList.get(0));
    }
}

3.结果测试

•     1.加入一些输出语句的测试

    

•     2.不带输出语句的测试