数据结构之 线性结构

线性结构是数据元素之间存在一对一关系的数据结构。线性结构中的数据元素之间存在一对一的线性关系，除了首尾元素外，每一个元素都有且只有一个前驱和一个后继。常见的线性结构有：数组、链表、栈、队列等。

下面我将为你提供Java中这些线性结构的简单实现和详细代码。

1. 数组 (Array)

数组是最简单的线性结构，它按照顺序存储元素。

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[10]; // 创建一个长度为10的整型数组
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i; // 初始化数组
        }
        for (int value : arr) {
            System.out.print(value + " "); // 打印数组元素
        }
    }
}

2. 链表 (LinkedList)

链表由一系列节点组成，每个节点包含数据域和指向下一个节点的指针。

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

public class LinkedListDemo {
    public static void main(String[] args) {
        ListNode head = new ListNode(1);
        ListNode second = new ListNode(2);
        ListNode third = new ListNode(3);

        head.next = second;
        second.next = third;

        ListNode current = head;
        while (current != null) {
            System.out.print(current.val + " ");
            current = current.next;
        }
    }
}

3. 栈 (Stack)

栈是一种后进先出（LIFO）的数据结构。

import java.util.EmptyStackException;

public class StackDemo {
    private int maxSize;
    private int top;
    private int[] stackArray;

    public StackDemo(int size) {
        maxSize = size;
        stackArray = new int[maxSize];
        top = -1;
    }

    public void push(int value) {
        if (top == maxSize - 1) {
            System.out.println("Stack is full");
        } else {
            stackArray[++top] = value;
        }
    }

    public int pop() {
        if (top == -1) {
            throw new EmptyStackException();
        } else {
            return stackArray[top--];
        }
    }

    public int peek() {
        if (top == -1) {
            throw new EmptyStackException();
        } else {
            return stackArray[top];
        }
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public static void main(String[] args) {
        StackDemo stack = new StackDemo(5);
        stack.push(1);
        stack.push(2);
        stack.push(3);
        System.out.println(stack.pop()); // 输出: 3
        System.out.println(stack.peek()); // 输出: 2
    }
}

4. 队列 (Queue)

队列是一种先进先出（FIFO）的数据结构。

import java.util.LinkedList;
import java.util.Queue;

public class QueueDemo {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();

        queue.add(1);
        queue.add(2);
        queue.add(3);

        System.out.println(queue.poll()); // 输出: 1
        System.out.println(queue.peek()); // 输出: 2
    }
}

以上代码提供了四种线性结构的基本实现。需要注意的是，对于链表、栈和队列，Java标准库中已经提供了相应的实现类（如LinkedList、ArrayDeque、LinkedList作为队列等），在实际开发中可以直接使用这些类，而无需自行实现。对于数组，Java也提供了内建的数组类型和操作数组的方法。

这些示例只是线性结构的基本实现，实际应用中可能需要根据具体需求进行扩展和优化。

原文地址：https://blog.csdn.net/weixin_43784341/article/details/136802972

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！