用java编写，并完成所有测试类

豪在这学python

1.请编程完成泛型类CircularLinkedList（循环链表），CircularLinkedList的基本功能设计要求：创建循环链表、插入新的结点、删除指定元素结点、查找指定元素结点、修改指定位置结点、遍历循环链表。

isdkz

1. import java.util.Iterator;
   
2. 
   
3. public class CircularLinkedList<E> implements Iterable<E> {
   
4. 
   
5.     private Node<E> head;
   
6.     private int size;
   
7. 
   
8.     private static class Node<E> {
   
9.         E data;
   
10.         Node<E> next;
    
11. 
    
12.         Node(E data, Node<E> next) {
    
13.             this.data = data;
    
14.             this.next = next;
    
15.         }
    
16.     }
    
17. 
    
18.     public CircularLinkedList() {
    
19.         head = null;
    
20.         size = 0;
    
21.     }
    
22. 
    
23.     public void insert(E element) {
    
24.         if (head == null) {
    
25.             head = new Node<>(element, null);
    
26.             head.next = head;
    
27.         } else {
    
28.             Node<E> newNode = new Node<>(element, head.next);
    
29.             head.next = newNode;
    
30.         }
    
31.         size++;
    
32.     }
    
33. 
    
34.     public void delete(E element) {
    
35.         if (head == null) {
    
36.             return;
    
37.         }
    
38.         if (head.data.equals(element)) {
    
39.             if (size == 1) {
    
40.                 head = null;
    
41.             } else {
    
42.                 Node<E> current = head;
    
43.                 while (!current.next.data.equals(element)) {
    
44.                     current = current.next;
    
45.                 }
    
46.                 current.next = current.next.next;
    
47.                 if (element.equals(head.data)) {
    
48.                     head = current.next;
    
49.                 }
    
50.             }
    
51.             size--;
    
52.         } else {
    
53.             Node<E> current = head;
    
54.             while (!current.next.data.equals(element)) {
    
55.                 current = current.next;
    
56.                 if (current.next == head) {
    
57.                     return;
    
58.                 }
    
59.             }
    
60.             current.next = current.next.next;
    
61.             size--;
    
62.         }
    
63.     }
    
64. 
    
65.     public Node<E> find(E element) {
    
66.         Node<E> current = head;
    
67.         if (head != null) {
    
68.             do {
    
69.                 if (current.data.equals(element)) {
    
70.                     return current;
    
71.                 }
    
72.                 current = current.next;
    
73.             } while (current != head);
    
74.         }
    
75.         return null;
    
76.     }
    
77. 
    
78.     public void modify(int index, E element) {
    
79.         if (index < 0 || index >= size) {
    
80.             throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
    
81.         }
    
82.         Node<E> current = head;
    
83.         for (int i = 0; i < index; i++) {
    
84.             current = current.next;
    
85.         }
    
86.         current.data = element;
    
87.     }
    
88. 
    
89.     @Override
    
90.     public Iterator<E> iterator() {
    
91.         return new Iterator<E>() {
    
92.             private Node<E> current = head;
    
93.             private int count = 0;
    
94. 
    
95.             @Override
    
96.             public boolean hasNext() {
    
97.                 return count < size;
    
98.             }
    
99. 
    
100.             @Override
     
101.             public E next() {
     
102.                 E data = current.data;
     
103.                 current = current.next;
     
104.                 count++;
     
105.                 return data;
     
106.             }
     
107.         };
     
108.     }
     
109. }
     

复制代码

Mike_python小

[/code]java
public class CircularLinkedList<T> {
    private Node<T> head;
    private int size;

    private static class Node<T> {
        T data;
        Node<T> next;

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

    // 创建循环链表
    public void createCircularLinkedList(T data) {
        Node<T> newNode = new Node<>(data);
        if (head == null) {
            head = newNode;
            head.next = head;
        } else {
            Node<T> temp = head;
            while (temp.next != head) {
                temp = temp.next;
            }
            temp.next = newNode;
            newNode.next = head;
        }
        size++;
    }

    // 插入新的结点
    public void insertNode(T data, int position) {
        if (position < 0 || position > size) {
            throw new IndexOutOfBoundsException("Invalid position for insertion");
        }

        Node<T> newNode = new Node<>(data);
        if (position == 0) {
            newNode.next = head;
            Node<T> temp = head;
            while (temp.next != head) {
                temp = temp.next;
            }
            temp.next = newNode;
            head = newNode;
        } else {
            Node<T> temp = head;
            for (int i = 0; i < position - 1; i++) {
                temp = temp.next;
            }
            newNode.next = temp.next;
            temp.next = newNode;
        }
        size++;
    }

    // 删除指定元素结点
    public void deleteNode(T data) {
        if (head == null) {
            return;
        }

        if (head.data.equals(data)) {
            if (head.next == head) {
                head = null;
            } else {
                Node<T> temp = head;
                while (temp.next != head) {
                    temp = temp.next;
                }
                temp.next = head.next;
                head = head.next;
            }
            size--;
        } else {
            Node<T> prev = head;
            Node<T> current = head.next;
            while (current != head) {
                if (current.data.equals(data)) {
                    prev.next = current.next;
                    size--;
                    return;
                }
                prev = current;
                current = current.next;
            }
        }
    }

    // 查找指定元素结点
    public int findNode(T data) {
        int index = 0;
        Node<T> temp = head;
        do {
            if (temp.data.equals(data)) {
                return index;
            }
            temp = temp.next;
            index++;
        } while (temp != head);
        return -1;
    }

    // 修改指定位置结点
    public void modifyNode(T newData, int position) {
        if (position < 0 || position >= size) {
            throw new IndexOutOfBoundsException("Invalid position for modification");
        }

        Node<T> temp = head;
        for (int i = 0; i < position; i++) {
            temp = temp.next;
        }
        temp.data = newData;
    }

    // 遍历循环链表
    public void traverseList() {
        if (head == null) {
            return;
        }
        Node<T> temp = head;
        do {
            System.out.print(temp.data + " ");
            temp = temp.next;
        } while (temp != head);
        System.out.println();
    }
}
[/code]

[/code]java
public class CircularLinkedListTest {
    public static void main(String[] args) {
        CircularLinkedList<Integer> circularList = new CircularLinkedList<>();

        // 创建循环链表
        circularList.createCircularLinkedList(1);
        circularList.createCircularLinkedList(2);
        circularList.createCircularLinkedList(3);

        // 遍历循环链表
        circularList.traverseList();

        // 插入新的结点
        circularList.insertNode(4, 2);
        circularList.traverseList();

        // 删除指定元素结点
        circularList.deleteNode(2);
        circularList.traverseList();

        // 查找指定元素结点
        int position = circularList.findNode(3);
        System.out.println("Position of 3: " + position);

        // 修改指定位置结点
        circularList.modifyNode(5, 0);
        circularList.traverseList();
    }
}
[/code]