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.         E data;
   
9.         Node<E> next;
   
10. 
    
11.         Node(E data) {
    
12.             this.data = data;
    
13.         }
    
14.     }
    
15. 
    
16.     public void insert(E data) {
    
17.         if (head == null) {
    
18.             head = new Node<>(data);
    
19.             head.next = head;
    
20.         } else {
    
21.             Node<E> newNode = new Node<>(data);
    
22.             newNode.next = head.next;
    
23.             head.next = newNode;
    
24.         }
    
25.         size++;
    
26.     }
    
27. 
    
28.     public void delete(E data) {
    
29.         if (head == null) {
    
30.             return;
    
31.         }
    
32. 
    
33.         Node<E> current = head;
    
34.         Node<E> previous = null;
    
35. 
    
36.         do {
    
37.             if (current.data.equals(data)) {
    
38.                 if (previous != null) {
    
39.                     previous.next = current.next;
    
40.                 } else {
    
41.                     head = current.next;
    
42.                 }
    
43.                 size--;
    
44.                 return;
    
45.             }
    
46.             previous = current;
    
47.             current = current.next;
    
48.         } while (current != head);
    
49.     }
    
50. 
    
51.     public Node<E> find(E data) {
    
52.         Node<E> current = head;
    
53.         do {
    
54.             if (current.data.equals(data)) {
    
55.                 return current;
    
56.             }
    
57.             current = current.next;
    
58.         } while (current != head);
    
59.         return null;
    
60.     }
    
61. 
    
62.     public void modify(int index, E newData) {
    
63.         if (index < 0 || index >= size) {
    
64.             throw new IndexOutOfBoundsException("Index out of bounds");
    
65.         }
    
66. 
    
67.         Node<E> current = head;
    
68.         for (int i = 0; i < index; i++) {
    
69.             current = current.next;
    
70.         }
    
71.         current.data = newData;
    
72.     }
    
73. 
    
74.     @Override
    
75.     public Iterator<E> iterator() {
    
76.         return new Iterator<E>() {
    
77.             private Node<E> current = head;
    
78.             private int count = 0;
    
79. 
    
80.             @Override
    
81.             public boolean hasNext() {
    
82.                 return count < size;
    
83.             }
    
84. 
    
85.             @Override
    
86.             public E next() {
    
87.                 E data = current.data;
    
88.                 current = current.next;
    
89.                 count++;
    
90.                 return data;
    
91.             }
    
92.         };
    
93.     }
    
94. }
    
95. 
    
96. // 测试类
    
97. public class CircularLinkedListTest {
    
98.     public static void main(String[] args) {
    
99.         CircularLinkedList<Integer> list = new CircularLinkedList<>();
    
100.         list.insert(1);
     
101.         list.insert(2);
     
102.         list.insert(3);
     
103.         
     
104.         for (Integer data : list) {
     
105.             System.out.println(data);
     
106.         }
     
107.         
     
108.         list.delete(2);
     
109.         
     
110.         for (Integer data : list) {
     
111.             System.out.println(data);
     
112.         }
     
113.         
     
114.         list.modify(1, 5);
     
115.         
     
116.         for (Integer data : list) {
     
117.             System.out.println(data);
     
118.         }
     
119.     }
     
120. }
     

复制代码

Mike_python小

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

    // 构造函数
    public CircularLinkedList() {
        head = null;
        size = 0;
    }

    // 结点类
    private static class Node<T> {
        T data;
        Node<T> next;

        Node(T data, Node<T> next) {
            this.data = data;
            this.next = next;
        }
    }

    // 插入新的结点
    public void insert(T data) {
        if (head == null) {
            head = new Node<>(data, null);
            head.next = head;  // 单结点成环
        } else {
            Node<T> newNode = new Node<>(data, head.next);
            head.next = newNode;
        }
        size++;
    }

    // 删除指定元素结点
    public void delete(T data) {
        if (head != null) {
            Node<T> current = head;
            while (current.next != head && !current.next.data.equals(data)) {
                current = current.next;
            }
            if (current.next.data.equals(data)) {
                current.next = current.next.next;
                size--;
            }
        }
    }

    // 查找指定元素结点
    public boolean search(T data) {
        Node<T> current = head;
        do {
            if (current.data.equals(data)) {
                return true;
            }
            current = current.next;
        } while (current != head);
        return false;
    }

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

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

        current.data = newData;
    }

    // 遍历循环链表
    public void traverse() {
        Node<T> current = head;
        do {
            System.out.print(current.data + " ");
            current = current.next;
        } while (current != head);
        System.out.println();
    }

    // 测试类
    public static void main(String[] args) {
        CircularLinkedList<Integer> list = new CircularLinkedList<>();
        list.insert(1);
        list.insert(2);
        list.insert(3);

        list.traverse(); // 输出：3 2 1

        list.delete(2);
        list.traverse(); // 输出：3 1

        System.out.println(list.search(3));  // 输出：true

        list.modify(1, 4);
        list.traverse(); // 输出：3 4
    }
}
[/code]