JAVA

zsxxn

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

isdkz

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

复制代码

这是一个基本的泛型循环链表类的实现。它包括了创建循环链表、插入新的结点、删除指定元素结点、查找指定元素结点、修改指定位置结点、遍历循环链表的功能。在这个实现中，我们使用了内部类Node来表示链表中的节点，并实现了Iterator接口来实现遍历功能。

Mike_python小

当使用Java编程实现循环链表的泛型类时，可以按照以下方式设计：

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

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

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

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

    public int size() {
        return size;
    }

    public void insert(T data) {
        Node<T> newNode = new Node<>(data);
        if (head == null) {
            head = newNode;
            head.next = head;  // 构成循环
        } else {
            Node<T> current = head;
            while (current.next != head) {
                current = current.next;
            }
            current.next = newNode;  // 添加到末尾
            newNode.next = head;  // 新结点指向头结点
        }
        size++;
    }

    public void delete(T data) {
        if (head == null) {
            return;
        }
        if (head.data.equals(data)) {
            if (head.next == head) {
                head = null;  // 只有一个结点时直接删除
            } else {
                Node<T> current = head;
                while (current.next != head) {
                    current = current.next;
                }
                head = head.next;  // 移动头指针
                current.next = head;  // 尾结点指向新头结点
            }
            size--;
            return;
        }
        Node<T> current = head;
        Node<T> prev = null;
        do {
            prev = current;
            current = current.next;
            if (current.data.equals(data)) {
                prev.next = current.next;  // 跳过当前结点
                size--;
                return;
            }
        } while (current != head);
    }

    public boolean contains(T data) {
        if (head == null) {
            return false;
        }
        Node<T> current = head;
        do {
            if (current.data.equals(data)) {
                return true;
            }
            current = current.next;
        } while (current != head);
        return false;
    }

    public void set(int index, T data) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of bounds");
        }
        Node<T> current = head;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        current.data = data;
    }

    public void traverse() {
        if (head == null) {
            return;
        }
        Node<T> current = head;
        do {
            System.out.print(current.data + " ");
            current = current.next;
        } while (current != head);
    }
}
[/code]

在上述代码中，我们定义了一个泛型类 CircularLinkedList，其中包含了创建循环链表、插入新的结点、删除指定元素结点、查找指定元素结点、修改指定位置结点、以及遍历循环链表的基本功能。