数据结构第3节： 抽象数据类型_java adt

第3节：基础概念 - 抽象数据类型（ADT）

抽象数据类型（ADT）是一种逻辑上的数学模型，以及定义在此数学模型上的一组操作。ADT通常隐藏了底层实现的细节，只暴露出一个可以被外界访问和操作的接口。在Java中，ADT可以通过接口（interface）来定义，并通过类（class）来实现。

2.3.1 抽象数据类型的定义

ADT定义了数据的逻辑结构和操作，但不涉及数据的具体表示和实现。例如，一个栈的ADT可以定义为具有push、pop、peek和isEmpty等操作。

2.3.2 Java中的ADT实现

在Java中，可以使用接口来定义ADT，然后通过类来实现这些接口。

定义一个ADT接口

public interface StackADT<T> {
    void push(T element);  // 入栈操作
    T pop();               // 出栈操作
    T peek();              // 查看栈顶元素
    boolean isEmpty();     // 检查栈是否为空
}
1
2
3
4
5
6

实现ADT接口

public class ArrayStack<T> implements StackADT<T> {
    private T[] elements;
    private int size;
    private static final int DEFAULT_CAPACITY = 10;

    public ArrayStack() {
        elements = (T[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    @Override
    public void push(T element) {
        ensureCapacity();
        elements[size++] = element;
    }

    @Override
    public T pop() {
        if (isEmpty()) {
            throw new NoSuchElementException("Stack is empty");
        }
        return elements[--size];
    }

    @Override
    public T peek() {
        if (isEmpty()) {
            throw new NoSuchElementException("Stack is empty");
        }
        return elements[size - 1];
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    private void ensureCapacity() {
        if (size == elements.length) {
            T[] newElements = (T[]) new Object[elements.length * 2];
            System.arraycopy(elements, 0, newElements, 0, size);
            elements = newElements;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

2.3.3 ADT的优势

• 封装性：ADT隐藏了数据的具体实现，只暴露操作接口，提高了代码的安全性和易用性。
• 抽象性：ADT提供了一个高层次的操作集合，使得用户可以不必关心数据的具体存储方式。
• 通用性：ADT的实现可以针对不同的数据存储需求进行定制，但对外提供的接口保持一致。

2.3.4 使用ADT

使用ADT可以简化编程，提高代码的可读性和可维护性。用户只需要知道如何使用ADT提供的操作，而不需要了解其内部实现。

public class Main {
    public static void main(String[] args) {
        StackADT<Integer> stack = new ArrayStack<>();
        stack.push(1);
        stack.push(2);
        System.out.println(stack.peek());    // 输出 2
        System.out.println(stack.pop());     // 输出 2
        System.out.println(stack.isEmpty()); // 输出 false
    }
}
1
2
3
4
5
6
7
8
9
10

通过上述Java源码，我们可以看到ADT如何在Java中被定义和实现。定义一个接口作为ADT，然后通过不同的类来实现这个接口，可以提供多种数据结构的实现，同时保持对外的接口一致。这种方式使得代码更加模块化，易于理解和使用。

继续探讨抽象数据类型（ADT）的概念，我们可以再通过Java代码来展示另一个常见的ADT：队列（Queue）。

2.3.5 队列（Queue）ADT

队列是一种先进先出（FIFO）的数据结构，其ADT定义通常包括以下操作：

• enqueue(T element): 在队列末尾添加一个元素。
• dequeue(): 移除并返回队列头部的元素。
• peek(): 返回队列头部的元素但不移除它。
• isEmpty(): 检查队列是否为空。

定义队列的ADT接口

public interface QueueADT<T> {
    void enqueue(T element);  // 入队操作
    T dequeue();              // 出队操作
    T peek();                 // 查看队首元素
    boolean isEmpty();        // 检查队列是否为空
}
1
2
3
4
5
6

实现队列的ADT接口

我们可以利用链表来实现队列，以避免在数组实现中可能需要的昂贵的元素移动操作。

public class LinkedListQueue<T> implements QueueADT<T> {
    private Node<T> head; // 队首
    private Node<T> tail; // 队尾

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

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

    @Override
    public void enqueue(T element) {
        Node<T> newNode = new Node<>(element);
        if (tail != null) {
            tail.next = newNode;
        } else {
            head = newNode;
        }
        tail = newNode;
    }

    @Override
    public T dequeue() {
        if (isEmpty()) {
            throw new NoSuchElementException("Queue is empty");
        }
        T element = head.data;
        head = head.next;
        if (head == null) {
            tail = null;
        }
        return element;
    }

    @Override
    public T peek() {
        if (isEmpty()) {
            throw new NoSuchElementException("Queue is empty");
        }
        return head.data;
    }

    @Override
    public boolean isEmpty() {
        return head == null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

2.3.6 使用队列ADT

使用队列ADT可以简化代码，使得队列操作更加直观和安全。

public class Main {
    public static void main(String[] args) {
        QueueADT<Integer> queue = new LinkedListQueue<>();
        queue.enqueue(1);
        queue.enqueue(2);
        System.out.println(queue.peek());    // 输出 1
        System.out.println(queue.dequeue()); // 输出 1
        System.out.println(queue.isEmpty()); // 输出 false
    }
}
1
2
3
4
5
6
7
8
9
10

2.3.7 ADT的进一步讨论

ADT不仅定义了数据的操作，还提供了一种思考问题的方式，使得程序员可以专注于如何使用数据，而不是如何实现数据结构。这种抽象层次上的分离是面向对象编程的核心概念之一。

通过这些案例，我们可以看到ADT在Java中的实现方式，以及它们如何帮助我们以一种抽象和通用的方式来处理数据结构。这些实现展示了ADT的封装性、抽象性和通用性的优势，同时也说明了为什么学习和使用ADT对于任何希望编写高效、可维护代码的程序员来说都是非常重要的。

让我们继续探讨抽象数据类型（ADT）的概念，并通过Java代码来展示另一个常见的ADT：链表（LinkedList）。

2.3.8 链表（LinkedList）ADT

链表是一种线性数据结构，其中元素以节点的形式存在，每个节点包含数据部分和指向下一个节点的链接。

定义链表的ADT接口

public interface LinkedListADT<T> {
    void addFirst(T element);  // 在链表头部添加元素
    void addLast(T element);   // 在链表尾部添加元素
    T removeFirst();           // 移除并返回链表头部的元素
    T removeLast();            // 移除并返回链表尾部的元素
    T getFirst();              // 获取链表头部的元素
    T getLast();               // 获取链表尾部的元素
    boolean isEmpty();         // 检查链表是否为空
    int size();                // 返回链表中的元素数量
}
1
2
3
4
5
6
7
8
9
10

实现链表的ADT接口

public class SinglyLinkedList<T> implements LinkedListADT<T> {
    private Node<T> head; // 链表的头节点
    private int size;     // 链表的元素数量

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

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

    @Override
    public void addFirst(T element) {
        Node<T> newNode = new Node<>(element);
        newNode.next = head;
        head = newNode;
        size++;
    }

    @Override
    public void addLast(T element) {
        Node<T> newNode = new Node<>(element);
        if (head == null) {
            head = newNode;
        } else {
            Node<T> current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
        size++;
    }

    @Override
    public T removeFirst() {
        if (isEmpty()) {
            throw new NoSuchElementException("Linked list is empty");
        }
        T element = head.data;
        head = head.next;
        size--;
        return element;
    }

    @Override
    public T removeLast() {
        if (isEmpty()) {
            throw new NoSuchElementException("Linked list is empty");
        }
        if (head.next == null) {
            T element = head.data;
            head = null;
            size--;
            return element;
        } else {
            Node<T> current = head;
            while (current.next.next != null) {
                current = current.next;
            }
            T element = current.next.data;
            current.next = null;
            size--;
            return element;
        }
    }

    @Override
    public T getFirst() {
        if (isEmpty()) {
            throw new NoSuchElementException("Linked list is empty");
        }
        return head.data;
    }

    @Override
    public T getLast() {
        if (isEmpty()) {
            throw new NoSuchElementException("Linked list is empty");
        }
        Node<T> current = head;
        while (current.next != null) {
            current = current.next;
        }
        return current.data;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public int size() {
        return size;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

2.3.9 使用链表ADT

使用链表ADT可以简化链表操作，使得链表的使用更加直观和安全。

public class Main {
    public static void main(String[] args) {
        LinkedListADT<Integer> linkedList = new SinglyLinkedList<>();
        linkedList.addFirst(10);
        linkedList.addLast(20);
        System.out.println(linkedList.getFirst());  // 输出 10
        System.out.println(linkedList.getLast());   // 输出 20
        System.out.println(linkedList.removeFirst()); // 输出 10
        System.out.println(linkedList.removeLast());  // 输出 20
        System.out.println(linkedList.isEmpty());     // 输出 true
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

通过上述Java源码，我们可以看到链表ADT如何在Java中被定义和实现。定义一个接口作为ADT，然后通过类来实现这个接口，可以提供多种链表的实现，同时保持对外的接口一致。这种方式使得代码更加模块化，易于理解和使用。

ADT的使用提高了代码的可维护性和可扩展性，因为具体的实现可以被替换或修改，而不影响使用这些数据结构的客户端代码。这种抽象层次上的分离是面向对象编程的核心概念之一，有助于创建清晰、可重用和易于测试的代码。