Java定义 MyLinkedList 类，实现链表的结构，实现结点类。解决约瑟夫问题，：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。

好的，这是一个有趣的问题。下面是我实现的代码：

class MyLinkedList<T> {
    class Node<T> {
        T data;
        Node<T> next;

        public Node(T data) {
            this.data = data;
        }
    }

    private Node<T> head;
    private int size;

    public MyLinkedList() {
        head = null;
        size = 0;
    }

    public void add(T data) {
        Node<T> newNode = new Node<>(data);
        if (head == null) {
            head = newNode;
        } else {
            Node<T> tail = head;
            while (tail.next != null) {
                tail = tail.next;
            }
            tail.next = newNode;
        }
        size++;
    }

    public T remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }

        if (index == 0) {
            T data = head.data;
            head = head.next;
            size--;
            return data;
        } else {
            Node<T> prev = head;
            for (int i = 0; i < index - 1; i++) {
                prev = prev.next;
            }
            T data = prev.next.data;
            prev.next = prev.next.next;
            size--;
            return data;
        }
    }

    public T get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }

        Node<T> node = head;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node.data;
    }

    public int size() {
        return size;
    }
}

public class JosephusProblem {
    public static void main(String[] args) {
        int N = 6;
        int M = 5;

        MyLinkedList<Integer> list = new MyLinkedList<>();
        for (int i = 1; i <= N; i++) {
            list.add(i);
        }

        int index = 0;
        while (list.size() > 1) {
            index = (index + M - 1) % list.size();
            System.out.print(list.remove(index) + " ");
        }
        System.out.println("\nThe last survivor is " + list.get(0));
    }
}

首先定义了一个自己实现的链表类 MyLinkedList，并实现了其中的结点类 Node。然后在 main 函数中，先将N个人的编号依次加入链表中。

接下来，使用 index 变量来记录当前报数到第几个人了。每次找到第 index + M - 1 个结点，并将其从链表中移除，打印出来。为了处理循环，需要对链表的长度取模。

最后，只剩下一个结点时，打印出它的编号即可。

运行上述代码，可以得到如下输出：

5 4 6 2 3 
The last survivor is 1

可以看到，输出的顺序与题目中给出的一致，最后只剩下了编号为1的人。