简述，顺序表、链表和顺序栈、链栈的异同点。

顺序表和链表是两种常见的数据结构，它们的主要区别在于内存分配方式不同。顺序表是一种基于数组实现的数据结构，它的元素在内存中是连续存储的，因此可以通过下标直接访问元素。而链表则是一种基于指针实现的数据结构，它的元素在内存中是分散存储的，每个元素都有一个指向下一个元素的指针，因此只能通过遍历链表来访问元素。

顺序栈和链栈也是两种常见的数据结构，它们的主要区别在于存储方式不同。顺序栈是一种基于数组实现的栈，它的元素在内存中是连续存储的，因此可以通过下标直接访问元素。而链栈则是一种基于指针实现的栈，它的元素在内存中是分散存储的，每个元素都有一个指向下一个元素的指针，因此只能通过遍历链表来访问元素。

异同点如下：
1.顺序表和链表的主要区别在于内存分配方式不同，顺序表的元素在内存中是连续存储的，而链表的元素在内存中是分散存储的。
2.顺序栈和链栈的主要区别在于存储方式不同，顺序栈的元素在内存中是连续存储的，而链栈的元素在内存中是分散存储的。
3.顺序表和顺序栈的实现方式类似，都是基于数组实现的，而链表和链栈的实现方式类似，都是基于指针实现的。
4.顺序表和链表的插入和删除操作的时间复杂度不同，顺序表的插入和删除操作需要移动其他元素，时间复杂度为O(n)，而链表的插入和删除操作只需要修改指针，时间复杂度为O(1)。
5.顺序栈和链栈的插入和删除操作的时间复杂度也不同，顺序栈的插入和删除操作需要移动其他元素，时间复杂度为O(n)，而链栈的插入和删除操作只需要修改指针，时间复杂度为O(1)。

相关问题

简述顺序表和链表存储方式的主要优缺点。

主要优缺点如下：

1. 顺序表的主要优点是能够快速访问表中任何一个元素，具有较好的随机访问性能。

2. 顺序表的主要缺点在于插入和删除操作的时间复杂度为O(n)，需要移动表中大量的元素，对于大型表来说效率较低。

3. 链表的主要优点是插入和删除操作的时间复杂度为O(1)，操作相对较快，尤其是在表头和表尾进行操作时。

4. 链表的主要缺点是访问表中任何一个元素的时间复杂度为O(n)，性能相对较低，对于需要随机访问的场景不适合使用。

java.通过顺序存储结构和链式存储结构构建顺序表、链表、顺序栈、链栈（学生属性包括：序号、学号、姓名、性别、年龄、班级）

顺序存储结构构建顺序表：

public class SeqList {
    private Student[] students; // 存放学生的数组
    private int size; // 数组中元素的个数
    private int capacity; // 数组的容量

    public SeqList(int capacity) {
        this.capacity = capacity;
        this.students = new Student[capacity];
        this.size = 0;
    }

    // 添加学生到顺序表的末尾
    public void add(Student student) {
        if (size == capacity) {
            System.out.println("顺序表已满，无法添加学生");
            return;
        }
        students[size++] = student;
    }

    // 根据学号查找学生
    public Student findByNo(String stuNo) {
        for (int i = 0; i < size; i++) {
            if (students[i].getStuNo().equals(stuNo)) {
                return students[i];
            }
        }
        return null;
    }

    // 删除指定学号的学生
    public boolean deleteByNo(String stuNo) {
        for (int i = 0; i < size; i++) {
            if (students[i].getStuNo().equals(stuNo)) {
                for (int j = i; j < size - 1; j++) {
                    students[j] = students[j + 1];
                }
                students[size - 1] = null;
                size--;
                return true;
            }
        }
        return false;
    }
}

链式存储结构构建链表：

public class ListNode {
    private Student student;
    private ListNode next;

    public ListNode(Student student) {
        this.student = student;
        this.next = null;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public ListNode getNext() {
        return next;
    }

    public void setNext(ListNode next) {
        this.next = next;
    }
}

public class LinkedList {
    private ListNode head; // 头结点
    private int size; // 链表中元素的个数

    public LinkedList() {
        this.head = new ListNode(null);
        this.size = 0;
    }

    // 添加学生到链表的末尾
    public void add(Student student) {
        ListNode node = new ListNode(student);
        ListNode cur = head;
        while (cur.getNext() != null) {
            cur = cur.getNext();
        }
        cur.setNext(node);
        size++;
    }

    // 根据学号查找学生
    public Student findByNo(String stuNo) {
        ListNode cur = head.getNext();
        while (cur != null) {
            if (cur.getStudent().getStuNo().equals(stuNo)) {
                return cur.getStudent();
            }
            cur = cur.getNext();
        }
        return null;
    }

    // 删除指定学号的学生
    public boolean deleteByNo(String stuNo) {
        ListNode cur = head.getNext();
        ListNode pre = head;
        while (cur != null) {
            if (cur.getStudent().getStuNo().equals(stuNo)) {
                pre.setNext(cur.getNext());
                size--;
                return true;
            }
            pre = cur;
            cur = cur.getNext();
        }
        return false;
    }
}

顺序存储结构构建顺序栈：

public class SeqStack {
    private Student[] students; // 存放学生的数组
    private int top; // 栈顶指针
    private int capacity; // 栈的容量

    public SeqStack(int capacity) {
        this.capacity = capacity;
        this.students = new Student[capacity];
        this.top = -1;
    }

    // 入栈
    public void push(Student student) {
        if (top == capacity - 1) {
            System.out.println("栈已满，无法添加学生");
            return;
        }
        students[++top] = student;
    }

    // 出栈
    public Student pop() {
        if (top == -1) {
            System.out.println("栈已空，无法弹出学生");
            return null;
        }
        return students[top--];
    }

    // 查看栈顶元素
    public Student peek() {
        if (top == -1) {
            System.out.println("栈已空");
            return null;
        }
        return students[top];
    }

    // 判断栈是否为空
    public boolean isEmpty() {
        return top == -1;
    }
}

链式存储结构构建链栈：

public class LinkedStack {
    private ListNode top; // 栈顶结点
    private int size; // 栈中元素的个数

    public LinkedStack() {
        this.top = null;
        this.size = 0;
    }

    // 入栈
    public void push(Student student) {
        ListNode node = new ListNode(student);
        node.setNext(top);
        top = node;
        size++;
    }

    // 出栈
    public Student pop() {
        if (top == null) {
            System.out.println("栈已空，无法弹出学生");
            return null;
        }
        Student student = top.getStudent();
        top = top.getNext();
        size--;
        return student;
    }

    // 查看栈顶元素
    public Student peek() {
        if (top == null) {
            System.out.println("栈已空");
            return null;
        }
        return top.getStudent();
    }

    // 判断栈是否为空
    public boolean isEmpty() {
        return top == null;
    }
}