泛型类

zsxxn

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

isdkz

1. public class DoubleLinkedList<T> {
   
2.     private Node<T> head;
   
3.     private Node<T> tail;
   
4. 
   
5.     private class Node<T> {
   
6.         T data;
   
7.         Node<T> prev;
   
8.         Node<T> next;
   
9. 
   
10.         public Node(T data) {
    
11.             this.data = data;
    
12.         }
    
13.     }
    
14. 
    
15.     public void insert(T data) {
    
16.         Node<T> newNode = new Node<>(data);
    
17.         if (head == null) {
    
18.             head = newNode;
    
19.             tail = newNode;
    
20.         } else {
    
21.             tail.next = newNode;
    
22.             newNode.prev = tail;
    
23.             tail = newNode;
    
24.         }
    
25.     }
    
26. 
    
27.     public void delete(T data) {
    
28.         Node<T> current = head;
    
29.         while (current != null) {
    
30.             if (current.data.equals(data)) {
    
31.                 if (current.prev != null) {
    
32.                     current.prev.next = current.next;
    
33.                 } else {
    
34.                     head = current.next;
    
35.                 }
    
36.                 if (current.next != null) {
    
37.                     current.next.prev = current.prev;
    
38.                 } else {
    
39.                     tail = current.prev;
    
40.                 }
    
41.                 return;
    
42.             }
    
43.             current = current.next;
    
44.         }
    
45.     }
    
46. 
    
47.     public Node<T> find(T data) {
    
48.         Node<T> current = head;
    
49.         while (current != null) {
    
50.             if (current.data.equals(data)) {
    
51.                 return current;
    
52.             }
    
53.             current = current.next;
    
54.         }
    
55.         return null;
    
56.     }
    
57. 
    
58.     public void modify(int index, T newData) {
    
59.         Node<T> current = head;
    
60.         int i = 0;
    
61.         while (current != null && i < index) {
    
62.             current = current.next;
    
63.             i++;
    
64.         }
    
65.         if (current != null) {
    
66.             current.data = newData;
    
67.         }
    
68.     }
    
69. 
    
70.     public void traverse() {
    
71.         Node<T> current = head;
    
72.         while (current != null) {
    
73.             System.out.print(current.data + " ");
    
74.             current = current.next;
    
75.         }
    
76.     }
    
77. }
    

复制代码

这是一个泛型类DoubleLinkedList，它实现了双向链表的基本功能。在这个类中，我们使用了一个内部类Node来表示链表中的节点，其中包含数据和指向前一个节点和后一个节点的引用。类中包含了插入新节点、删除指定元素节点、查找指定元素节点、修改指定位置节点和遍历循环链表的方法。每个方法都根据具体的需求进行了实现。

Mike_python小

当编写泛型类DoubleLinkedList时，使用Java语言需要考虑以下基本功能设计要求：

1. 创建双向链表：创建一个空的双向链表，初始化头部和尾部节点为空，同时维护链表的大小。

2. 插入新的节点：可以在链表的头部、尾部或指定位置插入新的节点。

3. 删除指定元素节点：删除链表中指定元素值的节点。

4. 查找指定元素节点：查找特定元素值的节点，并返回其位置。

5. 修改指定位置节点：允许通过索引修改链表中指定位置的节点的值。

6. 遍历双向链表：提供方法来遍历整个双向链表，输出其中的所有元素。

下面是一个基本的泛型类DoubleLinkedList的实现，满足上述的基本功能设计要求：

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

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

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

    public DoubleLinkedList() {
        head = null;
        tail = null;
        size = 0;
    }

    // 在链表尾部插入新节点
    public void insertAtEnd(T data) {
        Node<T> newNode = new Node<>(data);
        if (tail == null) {
            head = newNode;
            tail = newNode;
        } else {
            tail.next = newNode;
            newNode.prev = tail;
            tail = newNode;
        }
        size++;
    }

    // 删除指定元素节点
    public void deleteNode(T data) {
        Node<T> current = head;
        while (current != null) {
            if (current.data.equals(data)) {
                if (current == head) {
                    head = head.next;
                    if (head != null) {
                        head.prev = null;
                    }
                } else if (current == tail) {
                    tail = tail.prev;
                    tail.next = null;
                } else {
                    current.prev.next = current.next;
                    current.next.prev = current.prev;
                }
                size--;
                return;
            }
            current = current.next;
        }
    }

    // 查找指定元素节点的位置
    public int findNode(T data) {
        Node<T> current = head;
        int index = 0;
        while (current != null) {
            if (current.data.equals(data)) {
                return index;
            }
            current = current.next;
            index++;
        }
        return -1;
    }

    // 修改指定位置节点的值
    public void updateNode(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() {
        Node<T> current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
    }
}
[/code]

这是一个简单的泛型双向链表类的实现，你可以根据自己的需求进一步扩展和优化这个实现。希望这个例子能够帮助你完成泛型类DoubleLinkedList的基本功能设计。