数据结构

小白编程思想之崛起

于 2020-12-15 15:48:40 发布

阅读量199

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/weixin_44967898/article/details/111220956

版权

数据结构基础

什么是链表？

地下党是一些什么样的人物呢?

在影视作品中，我们可能都见到过地下工作者的经典话语：

上级的姓名、住址，我知道，下级的姓名、住址，我也知道。但是这些都是我们党的秘密，不能告诉你们!

地下党借助这种单线联络的方式，灵活隐秘地传递着各种重要信息。

在计算机科学领域里，有一种数据结构也恰恰具备这样地特征，这种数据结构就是链表。

链表是一种在物理上非连续、非顺序的数据结构，由若干节点所组成。

单项链表的每一个节点又包含两个部分，最后1个节点被称为尾节点，尾节点的next指针指向空。

public   class Node {
   String data;
    Node next;

    public Node(String data) {
        this.data = data;
    }
}

双向链表？

双向链表比单项链表稍微复杂一些，它的每一个节点除了拥有data和next指针，还拥有指向向前节点的prev指针。

数组在内存中的存储方式是顺序存储，那么链表在内存中的存储方式是随机存储。

什么是随机存储？

我们知道数据的内存分配方式，数组在内存中占用了连续完整的存储空间。而链表则采用了见缝插针的方式，链表的每一个节点分布在内存的不同位置，依靠next指针关联起来。这样可以灵活有效地利用零散地碎片化空间。

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

数组的内存分配方式

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

链表的内存分配方式

链表的基本操作

1. 查找节点

在查找元素时，链表不像数组那样可以通过下标快速进行定位，只能从头节点开始向后一个一个节点逐一查找。所以，最坏的时间复杂度时O(n)。

2.更新节点

如果不考虑查找节点的过程，链表的更新过程会像数组那样简单，直接把旧数据替换成新数据即可。

3.插入节点

与数组类似，链表插入节点时，同样分为3种情况

尾部插入
头部插入
中间插入

尾部插入

尾部插入时最简单的情况，把最后一个节点的next指针指向新插入的节点即可。

         //插入尾部
            last.next=insertNode;
            last=insertNode;

头部插入分为两个步骤

第一步，把新节点的next指针指向原先的头节点。
第二步，把新节点变为链表的头节点。

 //插入头部
            insertNode.next=head;
            head=insertNode;

中间插入，同样分为两个步骤。

第一步，新节点的next指针，指向插入位置的节点。
第二步，插入位置前置节点的next指针，指向新节点。

    /**
     * 链表查找元素
     * @Param index 查找的位置
    * */
    public Node get(int index){
        if (index<0 || index>=size){
            throw new IndexOutOfBoundsException("超出链表节点范围");
        }
        Node temp=head;
        for (int i=0;i<index;i++){
            temp=temp.next;
        }
        return temp;
    }

        //中间插入
             Node prevNode=get(index-1);
             insertNode.next=prevNode.next;
             prevNode.next=insertNode;

只要内存空间永许，能够插入链表的元素是无穷无尽的，不需要像数组那样考虑扩容的问题。

4.删除元素

链表的删除操作同样分为3种情况

尾部删除
头部删除
中间删除

尾部删除

尾部删除，是最简单的情况，把倒数第2个节点的next指针指向空即可。

  //删除尾节点
            Node prevNode=get(index-1);
            removNode=prevNode.next;
            prevNode.next=null;
            last=prevNode;

头部删除

头部删除，也很简单，把链表的头节点设为原先头节点的next指针即可

   //删除头节点
            removNode=head;
            head=head.next;

中间删除

把要删除节点的前置节点的next指针，指向要删除元素的下一个节点

        //删除中间节点
            Node prevNode=get(index-1);
            Node nextNode=prevNode.next.next;
            removNode=prevNode.next;
            prevNode.next=nextNode;

	查找	更新	插入	删除
数组	O(1)	O（1）	O(n)	O(n)
链表	O(n)	O(1)	O(1)	O(1)

实现代码

package com.stx.linkedlist;

/**
 * @Author :张国军
 * @Date ：Created in 11:38 2020/12/15
 * @Description : algorithm
 **/
public class LinkedList {
    /**
     * 头节点指针
     * */
    private Node head;
    /**
     * 尾节点指针
     * */
    private Node last;
    /**
     * 链表实际长度
    * */
    private int size;

    /**
    * 链表插入元素
     * @Param data 插入元素
     * @Param index 插入位置
    * */
    public void insert(String data ,int index){
        if (index<0 || index>size){
            throw new IndexOutOfBoundsException("超出链表实际长度");
        }
        Node insertNode=new Node(data);
        if (size==0){
            //空链表
            head=insertNode;
            last=insertNode;

        }else if (index==0){
            //插入头部
            insertNode.next=head;
            head=insertNode;
        }else if (size==index){
            //插入尾部
            last.next=insertNode;
            last=insertNode;
        }else {
            //中间插入
             Node prevNode=get(index-1);
             insertNode.next=prevNode.next;
             prevNode.next=insertNode;
        }
        size++;
    }

    /**
     * 链表删除元素
     *
     * */
    public Node remove(int index){
        if (index<0||index>=size){
            throw new IndexOutOfBoundsException("超出链表节点范围");
        }
        Node removNode=null;
        if (index==0){
            //删除头节点
            removNode=head;
            head=head.next;
        }else if (index==size-1){
            //删除尾节点
            Node prevNode=get(index-1);
            removNode=prevNode.next;
            prevNode.next=null;
            last=prevNode;
        }else {
            //删除中间节点
            Node prevNode=get(index-1);
            Node nextNode=prevNode.next.next;
            removNode=prevNode.next;
            prevNode.next=nextNode;
        }
        size--;
        return removNode;
    }

    /**
     * 链表查找元素
     * @Param index 查找的位置
    * */
    public Node get(int index){
        if (index<0 || index>=size){
            throw new IndexOutOfBoundsException("超出链表节点范围");
        }
        Node temp=head;
        for (int i=0;i<index;i++){
            temp=temp.next;
        }
        return temp;
    }

    /**
     * 输出链表
     * */
    public void output(){
        Node temp=head;
        while (temp!=null){
            System.out.println(temp.data);
            temp=temp.next;

        }
    }

}