JAVA数据结构之顺序表、单向链表及双向链表的设计和API实现

最新推荐文章于 2024-05-20 18:08:43 发布
最新推荐文章于 2024-05-20 18:08:43 发布
阅读量507 收藏 1
点赞数
分类专栏： Java 文章标签： java 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45266856/article/details/130171875
版权

一、顺序表

顺序表在内存中是数组的形式存储

类名SequenceList
构造方法SequenceList(int capacity)：创建容量为capacity的SequenceList对象
成员方法1. public void clear()：空置线性表
2. public boolean isEmpty()：判断线性表是否为空，是返回true，否返回false
3. public int length():获取线性表中元素的个数
4. public T get(int i):读取并返回线性表中的第i个元素的值
5. public void insert(int i,T t)：在线性表的第i个元素之前插入一个值为t的数据元素
6. public void insert(T t):向线性表中添加一个元素t
7. public T remove(int i):删除并返回线性表中第i个数据元素。
8. public int indexOf(T t):返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1。
成员变量1. private T[] eles：存储元素的数组
2.private int N:当前线性表的长度

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FJhR2QzJ-1681547704344)(C:\Users\29973\AppData\Roaming\Typora\typora-user-images\image-20230413095931799.png)]

//用来构造顺序表
public class SequenceList<T> implements Iterable{

    //存储元素的数组
    private T[] eles;
    //当前线性表的长度
    private int N;
    //获得当前容量
    private int capacity;

    //构造方法
    public SequenceList(int capacity) {
        //强制类型转化
        this.eles = (T[])new Object[capacity];
        //初始化长度
        N = 0;
        //获取当前顺序表的容量
        this.capacity = capacity;
    }

    //空置线性表
    public void clear() {
        for (int index = 0 ; index<getLength();index++){
            eles[index] = null;
        }
        this.N = 0;
    }

    //判断线性表是否为空，是返回true，否返回false
    public boolean isEmpty() {
        return N==0;
    }

    //获取线性表中元素的个数
    public int getLength() {
        return N;
    }

    //获取线性表的容量
    public int getCapacity() {
        return capacity;
    }

    //读取并返回线性表中的第i个元素的值
    public T get(int i) {
        if (i <= 0 || i>=N){
            throw new RuntimeException("当前元素不存在");
        }
        return eles[i];
    }

    //在线性表的第i个元素之前插入一个值为t的数据元素
    public void insert(int i,T t) {
        //如果当前元素的数量等于当前数组的长度
        if(N==eles.length){
            //扩容
            resize(2*eles.length);
        }
        //将i索引处以及后面的元素全部向后移动
        for (int index = N;index>i;index--){
            eles[index] = eles[index-1];
        }
        eles[i] = t;
        N++;
    }

    //向线性表中添加一个元素t
    public void insert(T t) {
        //如果当前元素的数量等于当前数组的长度
        if(N==eles.length){
            //扩容
            resize(2*eles.length);
        }
        //先将N处赋值为t，随后N自增
        eles[N]=t;
        N++;
    }

    //删除并返回线性表中第i个数据元素
    public T remove(int i) {
        //记录i处索引的值，并且后面的值全部向前移动
        T current = eles[i];
        for (int index = i ; index<N-1; index++ ){
            eles[index] = eles[index+1];
        }
        //元素个数减一
        N--;
        //如果当前元素的数量等于当前（数组的长度/4）
        if(N<eles.length/4){
            //将顺序表的长度变为原来的一半
            resize(eles.length/2);
        }
        return current;
    }


    //根据参数的newSize，重新来设置数组的大小
    public void resize(int newSize){
        //定义一个临时数组，指向原数组，用来提供复制数组
        T[] temp = eles;
        //容量翻倍
        eles = (T[]) new Object[newSize];
        //把原数组的数据拷贝到新数组即可
        for (int i = 0 ; i<N;i++){
            eles[i] = temp[i];
        }
        //重新定义容量的大小
        capacity = newSize ;
    }

    //返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返 回-1。
    public int indexOf(T t){
        if(t==null){
            throw new RuntimeException("查找的元素不合法");
        }
        for (int i = 0; i < N; i++) {
            if (eles[i].equals(t)){
                return i;
            }
        }
        return -1;
    }

    //实现遍历输出
    @Override
    public Iterator iterator() {
        return new SIterator();
    }

    private class SIterator implements Iterator{

        private int index;
        public SIterator(){
            this.index = 0;
        }
       @Override
        public boolean hasNext() {
            //表示还有下一个元素
            return index<N;
        }

        @Override
        public Object next() {
            return eles[index++];
        }
    }
}
  • 从以上代码可得知，顺序表查找元素很快，只需要进行一次遍历即可，时间复杂度为O(1);
  • 在插入或者删除元素的时候，我们要进行相应的元素移动，时间复杂度大，时 间复杂为O(n);

二、链表

链表分为两个类组成，分别为Node节点类和LinkList链表类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CBhN8HRy-1681547848794)(C:\Users\29973\AppData\Roaming\Typora\typora-user-images\image-20230413100004528.png)]

2.1 单向链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FWtSJUS9-1681547848794)(C:\Users\29973\AppData\Roaming\Typora\typora-user-images\image-20230413101025423.png)]

2.1.1 设计Node节点类
类名Node
构造方法Node(T t,Node next)：创建Node对象
成员变量T item:存储数据
Node next：指向下一个结点
//用来定义节点
public class Node<T> {
    //存储数据
    T item;
    //下一个节点
    Node next;
    
    public Node(T item, Node next) {
        this.item = item;
        this.next = next;
    }
}
2.1.2 设计LinkList链表类
类名LinkList
构造方法LinkList()：创建LinkList对象
成员方法1. public void clear()：空置线性表
2. public boolean isEmpty()：判断线性表是否为空，是返回true，否返回false
3. public int length():获取线性表中元素的个数
4. public T get(int i):读取并返回线性表中的第i个元素的值
5. public void insert(T t)：往线性表中添加一个元素；
6. public void insert(int i,T t)：在线性表的第i个元素之前插入一个值为t的数据元素。
7. public T remove(int i):删除并返回线性表中第i个数据元素。
8. public int indexOf(T t):返回线性表中首次出现的指定的数据元素的位序号，若不存在，则 返回-1。
成员内容类private class Node:结点类
成员变量1. private Node head:记录首结点
2.private int N:记录链表的长度
//实现链表的构造
public class LinkList<T> implements Iterable{
    //记录头节点
    private Node<T> head;
    //记录链表的长度
    private int N;

    //构造方法
    public LinkList(){
        //初始化头节点
        this.head = new Node<T>(null,null);
        //初始化元素个数
        this.N = 0;
    }

    //清空链表：原理是断开头节点的指向，并且将链表置零
    public void clear(){
        head.next = null;
    }

    //获取链表的长度
    public int length(){
        return N;
    }

    //判断链表是否为空
    public boolean isEmpty(){
        return N==0;
    }

    //获取指定位置i处的元素
    public T get(int i){
        Node n = head.next;
        for (int index = 0 ; index<i ; index++){
            n = n.next;
        }
        return (T) n.item;
    }

    //向链表中插入元素
    public void insert(T t){
        //找到当前的最后一个节点
        Node n = head;
        while (n.next!=null){
            n = n.next;
        }
        //创建节点，保存元素
        Node newNode = new Node(t,null);
        //让当前最后一个节点指向新节点
        n.next = newNode;
        //元素的个数++
        N++;
    }

    //向链表的指定位置插入元素
    public void insert(int i , T t){
        if (i<0 || i>=N){
            throw new RuntimeException("位置不合法");
        }
        //找到i-1和i节点
        Node preNode = head;// i-1 节点
        for (int index = 0 ; index<=i-1 ; index++){
            preNode = preNode.next;
        }
        Node currentNode = preNode.next;// i 节点
        //创建新节点newNode
        Node newNode = new Node(t,null);
        //让i-1节点的next节点指向创建的newNode
        preNode.next = newNode;
        //将newNode的next节点指向原本的i节点
        newNode.next = currentNode;
        //元素个数++
        N++;
    }

    //删除指定位置的索引，并且返回被删除的元素
    public T remove(int i){
        if (i<0 || i>=N){
            throw new RuntimeException("位置不合法");
        }
        //找到 i-1 、 i 、i+1 节点
        Node preNode = head ; //找到i-1
        for (int index = 0 ; index<=i-1 ; index++){
            preNode = preNode.next;
        }
        Node currentNode = preNode.next; //找到i
        Node nextNode = currentNode.next; //找到i+1
        //将i-1的next节点指向i+1即可
        preNode.next = nextNode ;
        //元素个数--
        N--;
        return (T) currentNode.item;
    }

    //查找元素t在链表中第一次出现的位置
    public int indexOf(T t){
        Node n = head ;
        //依次去除节点元素进行比较
        for (int i = 0;n.next!=null;i++){
            n = n.next;
            if (t.equals(n.item)){
                return i;
            }
        }
        return -1;
    }


    //实现遍历输出
    @Override
    public Iterator iterator() {
        return new LIterator();
    }

    public class LIterator implements Iterator{
        private Node n;
        public LIterator(){
            this.n = head;
        }
        @Override
        public boolean hasNext() {
            return n.next!=null;
        }

        //获取下一个元素的值
        @Override
        public Object next() {
            n = n.next;
            return n.item;
        }
    }
}

2.2 双向链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2VkiR53v-1681547985087)(C:\Users\29973\AppData\Roaming\Typora\typora-user-images\image-20230413170710947.png)]

2.2.1 设计Node节点类
类名Node
构造方法Node(T t,Node next)：创建Node对象
成员变量T item:存储数据
Node next：指向下一个结点
Node pre：指向上一个结点
public class Node<T> {
    //下一个节点
    public Node next;
    //上一个节点
    public Node pre;
    //存储数据
    public T item;

    //构造函数
    public Node(Node pre, Node next, T item) {
        this.pre = pre;
        this.next = next;
        this.item = item;
    }
}
2.2.2 设计DoublyLinkList链表类
类名DoublyLinkList
构造方法DoublyLinkList()：创建DoublyLinkList对象
成员方法1. public void clear()：空置线性表
2. public boolean isEmpty()：判断线性表是否为空，是返回true，否返回false
3. public int length():获取线性表中元素的个数
4. public T get(int i):读取并返回线性表中的第i个元素的值
5. public void insert(T t)：往线性表中添加一个元素；
6. public void insert(int i,T t)：在线性表的第i个元素之前插入一个值为t的数据元素。
7. public T remove(int i):删除并返回线性表中第i个数据元素。
8. public int indexOf(T t):返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1。
9. public T getFirst():获取第一个元素
10. public T getLast():获取最后一个元素
成员内容类private class Node:结点类
成员变量1. private Node head:记录首结点
2. private Node end:记录尾结点
3.private int N:记录链表的长度
public class DoublyLinkList<T> implements Iterable{
    //记录头节点
    private Node<T> head;
    //记录尾节点
    private Node<T> end;
    //记录链表的长度
    private int N;

    //构造方法
    public DoublyLinkList(){
        //初始化头节点和尾节点
        this.head = new Node<T>(null,null,null);
        this.end = null;
        //所以这个地方头节点和尾节点不占用长度
        this.N = 0;
    }

    //清空链表：原理是断开头节点和尾节点的指向，并且将链表置零
    public void clear(){
        head.next = null;
        end = null;
        N = 0;
    }

    //获取链表的长度
    public int length(){
        return N;
    }

    //判断链表是否为空
    public boolean isEmpty(){
        return N==0;
    }

    //获取第一个元素
    public T getHead(){
        if (isEmpty()){
            return null;
        }
        return (T) head.next.item;
    }

    //获取最后一个元素
    public T getLast(){
        if (isEmpty()){
            return null;
        }
        return (T) end.item;
    }


    //向链表中插入元素(默认是尾部)
    public void insert(T t){
        //1. 如果链表为空
        if (isEmpty()){
            //1.1 创建新的节点
            Node newNode = new Node(head, null, t);
            //1.2 让新的的节点称之为尾节点
            end = newNode;
            //1.3 让头节点指向尾节点
            head.next = end;
        }else {
        //2. 如果链表不为空
            Node oldNode = end;
            //2.1 创建新的节点
            Node newNode = new Node(oldNode,null,t);
            //2.2 让当前的尾节点指向新节点
            oldNode.next = newNode;
            //2.3 让新节点成为尾节点
            end = newNode;
        }
        N++;
    }

    //向链表的指定位置插入元素
    public void insert(int i , T t){
        if (i<0 || i>=N){
            throw new RuntimeException("位置不合法");
        }

        //找到 i-1 的节点
        //假如在 3 位置插入新节点，我们就是遍历从0-2，恰好可以找到2节点
        Node preNode = head;
        for (int index = 0 ; index<=i-1 ; index++){
            preNode = preNode.next;
        }
        //找到 i 位置节点
        Node currentNode = preNode.next;
        //创建新节点
        Node newNode = new Node(null,null,t);
        //修改指向
        preNode.next = newNode;
        newNode.next = currentNode;
        currentNode.pre = newNode;
        newNode.pre = preNode;
        //元素个数加一
        N++;
    }

    //删除指定位置的索引，并且返回被删除的元素
    public T remove(int i){
        if (i<0 || i>=N){
            throw new RuntimeException("位置不合法");
        }
        //找到i位置的节点
        Node node = head;
        for (int index = 0 ;index<=i ; index++){
            node = node.next;
        }
        //找到 i+1 位置节点
        Node nextNode = node.next;
        //找到 i-1 位置节点
        Node preNode = node.pre;
        //修改指向
        preNode.next = nextNode;
        nextNode.pre = preNode;
        N--;
        return (T) node.item;
    }

    //获取指定位置i处的元素
    public T get(int i){
        Node node = head;
        for (int index = 0 ; index<=i ; index++){
            node  = node.next;
        }
        return (T) node.item;
    }

    //查找元素t在链表中第一次出现的位置
    public int indexOf(T t){
        Node node = head;
        for (int index = 0 ; node.next != null ; index++){
            node  = node.next;
            if (t.equals(node.item)){
                return index;
            }
        }
        return -1;
    }

    @Override
    public Iterator iterator() {
        return new DIterator();
    }

    private class DIterator implements Iterator{
        private Node n;

        public DIterator() {
            this.n = head;
        }

        @Override
        public boolean hasNext() {
            return n.next != null;
        }

        @Override
        public Object next() {
            n = n.next;
            return n.item;
        }
    }
}
2.2.3 总结和提醒

总结

  • 每一次查询，都需要从链表的头部开始，依次向后查找，随着数据元素N的增多，比较的元素越多，时间复杂度为O(n)
  • 对于插入和移除节点，随着数据元素N的增多，查找的 元素越多，时间复杂度为O(n);
  • 相比较顺序表，链表插入和删除的时间复杂度虽然一样，但仍然有很大的优势，因为链表的物理地址是不连续的， 它不需要预先指定存储空间大小，或者在存储过程中涉及到扩容等操作,同时它并没有涉及的元素的交换。

提醒

其中对于双向链表遍历的边界值条件，如下代码

//获取指定位置i处的元素
public T get(int i){
    Node node = head;
    for (int index = 0 ; index<=i ; index++){
        node  = node.next;
    }
    return (T) node.item;
}

我们需要获取到i处的元素，因为我们是从头节点head开始遍历，所以其实我们的跳数也是从头节点开始计算，假设我们需要定位到2号节点，从head节点开始计算，index设置为0，我们刚好要移动3次。即要定位i处的元素，边界值判定条件恰好为i

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l9GLQKD9-1681548030257)(C:\Users\29973\AppData\Roaming\Typora\typora-user-images\image-20230415155614643.png)]

参考

黑马程序员Java数据结构与java算法全套教程

毒爪的小新
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
你还不会表结构设计？三分钟内教你如何做好表结构设计
weixin_71690375的博客
05-29 2932
如何做好表结构设计？大家关心的问题阳哥必须整理出来，希望对大家有帮助。这篇文章介绍了设计数据库表结构应该考虑的4个方面，还有优雅设计的6个原则，举了一个例子分享了我的设计思路，为了提高性能我们也要从多方面考虑缓存问题。首先，一定要先搞清楚业务需求。比如我的例子中，如果不需要灵活设置，完全可以写到配置文件中，并不需要单独设计外键。主表中直接保存各种筛选标签名称（注意维护的问题，要考虑到数据一致性）数据库表结构设计一定考虑数据量和并发量，我的例子中如果数据量小，可以适当做冗余设计，降低业务复杂度。
Java - 数据结构之 顺序表与链表
m0_65638983的博客
12-25 518
假设当前有n个元素，第1个元素和第n个元素相等，第二个元素个第n-1个元素相等......直到中间只剩一个元素时(奇数个) 或者中间没有元素(偶数个)时称为回文这道题的思路又是好几个小题，首先是找出中间结点，其次反转中间结点后的链表，最后使用双指针从前后遍历即可力扣反转链表：力扣。
【JAVA】双向链表详解
weixin_74999790的博客
06-04 3109
LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。每个数据节点都有两个指针，指向前驱和后继，所以，双向链表中的任意一个节点开始，都可以十分方便找到前驱节点和后继节点。
Java 对外API接口开发 java开发api接口如何编写
最新发布
2301_78159247的博客
05-20 1455
Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是List和Set。Map：双列集合类的根接口，用于存储具有键（Key）、值（Value）映射关系的元素，每个元素都包含一对键值，其中键值不可重复且每个键最多只能映射到一个值，在使用Map集合时可以通过指定的Key找到对应的Value。某些场合下可能需要把基本数据类型的数据作为对象来使用，为了解决这样的问题，JDK中提供了一系列的包装类，可以把基本数据类型的值包装为引用数据类型的对象。
[Java]快速入门顺序表链表
Node_Hao的博客
07-25 680
Hello,大家好!我是Node_Hao,今天给大家带来的内容是顺序表和链表的快速入门,旨在掌握顺序表和链表的底层构造方法,以达到熟练掌握并能在leetcode独立刷题为主要目的.希望我的内容能给大家带来帮助!...........................
java实现链表
woai3364的博客
02-05 815
由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。4、我们在写一个数据结构时无非就是 增、删、查、改，还有一些像获取长度，判断是否为空的功能函数，我们在这添加两个检查索引是否越界函数。5、在链表中访问一个index 位置的节点值会很困难，必须遍历链表，我们将或取index位置的节点设置一个函数。3、设置头、尾节点和长度变量。
数据结构与算法:单向链表实现与封装
08-26
"数据结构与算法：单向链表实现与封装" 在计算机科学中，数据结构是指计算机中存储、组织和管理数据的方式。链表是一种基本的数据结构，单向链表是指链表中的每个节点 chỉ指向下一个节点的数据结构。今天，我们将...
Python单向链表和双向链表原理与用法实例详解
09-20
在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只包含一个指向下一个节点的引用。在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法...
【Java数据结构与算法】双向链表
12-21
这种设计使得双向链表在某些操作上比单向链表更高效和灵活。 **单向链表的缺点：** 1. 只能单向遍历，查找效率受限。一旦从头部开始，无法通过指针直接返回到前一个节点，只能顺序查找。 2. 自我删除困难。在删除...
链表-使用PHP实现的双向链表数据结构.zip
03-13
双向链表是链表的一种变体，与单向链表不同，它允许从两个方向遍历链表。每个节点除了包含数据和指向下一个节点的指针外，还有一个指向前一个节点的指针。这样的设计提高了数据操作的灵活性，例如在链表中间插入或...
数据结构顺序表和链表（超详细）
08-14
此压缩包为1、无头+单向+非循环链表增删查改实现// 动态申请一个结点// 单链表打印// 单链表尾插// 单链表的头插// 单链表的尾删// 单链表头删// 单链表查找// 单链表在pos位置之后插入x// 单链表删除pos位置之后的...
JAVA链表实现类（数据结构学习）
12-14
JAVA链表实现类（数据结构学习）.chm
算法村-Java构建链表 遍历链表 单链表插入、删除 单调递增情况下的处理 双链表插入、删除操作
mianbaoquanmaxi的博客
07-26 198
【代码】算法村-Java构建链表 遍历链表 单链表插入、删除 单调递增情况下的处理 双链表插入、删除操作。
链表API设计
gjbss的博客
07-27 250
单项链表，双向链表，快慢指针问题(链表中间值问题，成环问题),约瑟夫问题
Java-数据容器-集合-LinkedList
yy310585的博客
01-05 134
Java-数据容器-集合-LinkedList LinkedList是List接口的实现类 LinkedList底层数据存储方式是跳转结构进行存储的，是双向链表 LinkedList的优点 删除、增加元素效率高 数据可重复 LinkedList的缺点 遍历效率低 LinkedList的方法，常用方法黄底标注 方法名 方法详细描述 方法返回值类型 add(E ...
数据结构与算法——Java实现单链表、双向链表、环型链表、约瑟夫
weixin_51351637的博客
12-13 742
我们看下面的图示如下图链表是以节点的方法来存储，是链式存储每个节点包含data域（存放数据），next域（指向下一个节点）链表各个节点不一定是连续存储的链表分带头节点的链表（头结点不存放数据）和不带头结点的链表，根据实际需求来确定下图是带头节点的链表，其中每一个白色的矩形就是一个节点。
简单实现双向链表常用API
m0_62547912的博客
09-22 259
简单实现双向链表API
Java 链表详细介绍(1)
weixin_45428910的博客
02-11 187
Java 链表详细介绍(1)
Java学习指南系列（基础篇）
03-12
你比其他Java程序员更优秀的原因，是你学习了这篇课程！本篇涵盖了Java的主要语法和核心概念：（1）异常，抽象类，接口等语法概念 （2）装箱拆箱，反射，线程、同步与通知，等Java里的基本机制（3）Java文档及API的用法，命令行、jar文件的使用方法（4）Eclipse的常用操作（5）中文编码，文件读写，时间处理等技术Java学习指南的后续篇章以此篇为基础展开讲解。
数据结构深入解析：双向链表与Java实现
课程提到了几种数据结构相关的书籍，包括《数据结构、算法与应用:java语言描述》、《数据结构Java语言描述》、《数据结构(Java版)》(第2版)和《数据结构-Java语言描述》，这些书籍可以作为深入学习的参考资料。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值