数据结构:链表(1)

顺序表的优缺点

缺点:

1.插入数据必须移动其他数据,最坏情况下,就是插入到0位置。时间复杂度O(N)

2.删除数据必须移动其他数据,最坏情况下,就是删除0位置。时间复杂度O(N)

3.扩容之后,有可能会浪费空间。

优点:

在给定下标进行查找的时候

总结:顺序表比较适合进行给定下路查找的场景

链表可以完美解决顺序表的缺点


链表是什么?

一个链表其实就是一辆火车

数据结构:链表(1)_第1张图片

火车的每个车厢相当于一个节点,链表节点长这样

数据结构:链表(1)_第2张图片

其中,数据域存储数据 

而火车之间要有挂钩链接,这就需要next域出马了,next读取下一个节点的地址并把它记录在next域里面,下面这个图也是单向链表,一条路走到黑

数据结构:链表(1)_第3张图片

分类

有六种分类

常见的是红色圈起来的两个

带头的长啥样?头部存的数据是无效的,跟这个链表没有关系,这个头节点的值永远不会改变

数据结构:链表(1)_第4张图片

循环的?

数据结构:链表(1)_第5张图片

双向的?两边都能走

数据结构:链表(1)_第6张图片

链表结构特点:物理上不一定是连续的,但逻辑上是连续的


单向链表

手搓一个

初始化

实现方法有下面这些

//IList.java 接口
public interface IList {
    //头插法
    void addFirst(int data);
    //尾插法
    void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    void addIndex(int index,int data);
    //查找是否包含关键字key是否在单链表当中
    boolean contains(int key);
    //删除第一次出现关键字为key的节点
    void remove(int key);
    //删除所有值为key的节点
    void removeAllKey(int key);
    //得到单链表的长度
    int size();
    void clear();
    void display();
}

再新建一个模块重写这些方法

public class MySingleList implements IList{
    @Override
    public void addFirst(int data) {

    }

    @Override
    public void addLast(int data) {

    }

    @Override
    public void addIndex(int index, int data) {

    }

    @Override
    public boolean contains(int key) {
        return false;
    }

    @Override
    public void remove(int key) {

    }

    @Override
    public void removeAllKey(int key) {

    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public void clear() {

    }

    @Override
    public void display() {

    }
}

ok!接下来我们要设置一个节点的内部类把要用到的属性加上

    static class ListNode{
        public int val;
        public ListNode next; //定义next域
        //节点类构造方法
        public ListNode(int val){
            this.val = val;
        }
    }

为什么是static呢?因为每个节点都一样,都由数据域和next域组成的,直接static定义共同特点。

那第三行的ListNode next 怎么理解呢?因为next指向的是下一个节点的地址,而下一个节点的类型也是ListNode,所以这里的next一定是ListNode类型

数据结构:链表(1)_第7张图片


好接下来定义一个链表的头

public ListNode head;

注意不要放到内部类里面,因为head是链表的成员而不是节点的成员

给几个节点赋上值

数据结构:链表(1)_第8张图片

1.如何让node1的下一个节点是node2

数据结构:链表(1)_第9张图片

node1.next = node2 //表示node2地址0x46给到node1

node1.next = node2;
node2.next = node3;
node3.next = node4;
node4.next = node5;

数据结构:链表(1)_第10张图片

node1是局部变量,整个过程走完之后node1会被回收怎么办?

两种方法:

第一种,把刚刚那个函数类型改成ListNode,函数返回node1

第二种,我们不是定义了head了吗,直接在函数末尾写上

this.head = node1;    这样就行了

检验结果

数据结构:链表(1)_第11张图片


遍历列表

1.怎么从一个节点走到下一个节点

数据结构:链表(1)_第12张图片

2.怎么判断所有节点都遍历完了

数据结构:链表(1)_第13张图片

一个循环,循环终止条件是head为空,我们按照这个思想把display代码完成

数据结构:链表(1)_第14张图片

这个代码有一个问题,遍历完列表之后head为空,整个头节点地址和值全都无了

解决办法是创一个中间变量cur把head锁死,遍历完之后cur为空了,但是head本质上不会变

    @Override
    public void display() {
        ListNode cur = this.head;
        while(cur != null){
            System.out.println(cur.val + " ");
            cur = cur.next;
        }
    }

有这个代码的基础,链表长度和包含函数也不在话下

    @Override
    public int size() {
        int count = 0;
        ListNode cur = this.head;
        while(cur != null){
            cur = cur.next;
            count++;
        }
        return count;
    }

    @Override
    public boolean contains(int key) {
        ListNode cur = this.head;
        while(cur != null){
            if(cur.val == key){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

头插法

链表里面有节点

数据结构:链表(1)_第15张图片

数据结构:链表(1)_第16张图片

三步走

1. 实例化一个节点

2.改变插入节点的next

3.改变head

无节点

直接把head定义成这个节点

    @Override
    public void addFirst(int data) {
        //实例化节点对象
        ListNode node = new ListNode(data);
        //无节点
        if(this.head == null){
            this.head = node;
        //有节点
        }else{
            node.next = this.head;
            this.head = node;
        }
    }

注意这个插入是倒叙插入 


尾插法

指的是将待插入的节点存放到链表的最后一个位置

步骤:

1.实例化一个节点

2.把cur走到最后一个节点

3.cur.next = node; //插入下一个节点

数据结构:链表(1)_第17张图片

数据结构:链表(1)_第18张图片

    @Override
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        ListNode cur = this.head;
        if (this.head == null){
            this.head = node;
        }else {
            //找到尾巴
            while (cur.next != null) {
                cur = cur.next;
            }
            //cur现在指向最后一个节点
            cur.next = node;
        }
    }

如果想要让cur停在最后一个节点的位置 cur.next != null;

数据结构:链表(1)_第19张图片

如果想把整个链表都遍历完,就是cur != null;

数据结构:链表(1)_第20张图片

注意:尾插法时间复杂度是O(N),因为要遍历完整个链表n个节点后才插入元素


在任意位置插入节点

数据结构:链表(1)_第21张图片

1.让cur走index-1步

2.node.next = cur.next;

cur.next = node;

在插入一个节点的时候,一定要先绑定后面这个节点

    @Override
    public void addIndex(int index, int data) {
        if(index < 0 || index > size()){
            return;
        }
        if(index == size()){
            addLast(data);
            return;
        }

        ListNode cur = searchPrev(index);
        ListNode node = new ListNode(data);

        node.next = cur.next;
        cur.next = node;
    }

    private ListNode searchPrev(int index){
        ListNode cur = this.head;
        int count = 0;
        while(count!=index-1){
            cur = cur.next;
            count++;
        }
        return cur;
    }

删除元素

数据结构:链表(1)_第22张图片

现在我们想删除第三个节点,把第三个节点设成del

在一个循环里面让cur遍历整个链表

判断 cur.next.val == key,找到cur的位置

后面cur = cur.next

    @Override
    public void remove(int key) {
        if(this.head == null){
            //一个节点都没有,删除不了
            return;
        }
        //删除头节点
        if(this.head.val == key){
            this.head = this.head.next;
            return;
        }


        //1、找到前驱
        ListNode cur = findPrev(key);
        //2、判断返回值是否为空?
        if(cur == null){
            System.out.println("没有你要删除的数字");
            return;
        }
        //3、删除
        ListNode del = cur.next;
        cur.next = del.next;
    }
    //找到关键字key的前一个节点的地址
    private ListNode findPrev(int key){
        ListNode cur = this.head;
        while(cur.next!=null){
            if(cur.next.val == key){
                return cur;
            }
        }
        return null;
    }

删除所有值为key的节点 

比如下面删除所有值为23的节点

数据结构:链表(1)_第23张图片

定义cur为当前要删除的节点

prev为当前要删除的节点的前驱

数据结构:链表(1)_第24张图片

cur找到了就直接把prev的next地址改成cur下一个节点的地址,cur继续往下遍历

while(cur!=null){

        if(cur.val == key){

                prev.next = cur.next; //删除操作

                cur = cur.next;

        }else{

                prev = cur;

                cur = cur.next

        }

}

    @Override
    public void removeAllKey(int key) {
        if(this.head == null){
            return;
        }
        ListNode prev = head;
        ListNode cur = head.next;
        while(cur!=null){
            if(cur.val == key){
                prev.next = cur.next;
                cur = cur.next;
            //不等于就往下走
            }else{
                prev = cur;
                cur = cur.next;
            }
        }
        if(head.val == key){
            head = head.next;
        }
    }

清空链表

把一个节点的val = null, next = null

再把链表的head = null

数据结构:链表(1)_第25张图片

注意:这里的val = null不是直接让你 cur.val = null,拿第一个节点来说,如果你把值置为空,那么0x46被替换成null,cur找不到下一个节点的地址0x46了

我们可以拿一个变量curNext来记录cur下一个节点的位置,把cur.next 置为空之后,cur往后挪到curNext的位置,继续置空下一个节点

注意别忘了头节点,整个遍历完之后还要把头节点也置为空

    @Override
    public void clear() {
        ListNode cur = this.head;
        while(cur!=null){
            ListNode curNext = cur.next;
            cur.next = null;
            cur = curNext;
        }
        head = null;
    }

你可能感兴趣的:(Java数据结构,数据结构,链表,java,算法)