java 链表学习

最新推荐文章于 2022-02-09 18:21:24 发布

码上开花

最新推荐文章于 2022-02-09 18:21:24 发布

阅读量271

点赞数 1

分类专栏： java学习杂记文章标签： java 链表双向链表环形链表自定义链表链表学习

本文链接：https://blog.csdn.net/FireAny2010/article/details/105071382

版权

java学习杂记专栏收录该内容

34 篇文章 0 订阅

订阅专栏

一、链表定义

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的

二、链表组成

链表由一系列节点（链表中每一个元素称为节点--Node）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

　链表的构成要素的本质，是节点（Node）的设计。对于链表的所有特性，都是基于Node本身或对Node的操作而形成的

Node的构成模式：

　1）单向链表

Node含有：数据变量、下一个节点的指针；

　2）双向链表

Node含有：数据变量、下一个节点的指针、上一个节点的指针；

　3）环形链表

Node含有：数据变量、下一个节点的指针、上一个节点的指针、最后一个节点的指针指向首节点；

　4）有序链表

Node含有：数据变量，下一个节点的指针，上一个节点的指针；自身唯一的序号（inde）或索引（hash）

降低创建效率，提高查询效率的链表数组，或链表hash

三、链表特点

1、长度不固定，可以任意增删，插入或删除节点时，只需改变相应节点的指针指向即可，无需大量移动元素。

2、存储空间不连续，数据元素之间使用指针相连，每个数据元素只能访问周围的一个元素（根据单链表还是双链表有所不同），所以易于扩展。

3、存储密度小，因为每个数据元素，都需要额外存储一个指向下一元素的指针（双链表则需要两个指针）。

4、要访问特定元素，链表必须从链表头开始，依次向后查找，平均需要0(n)的时间，存取速度慢。

四、链表操作

根据上面所说的链表定义和链表组成，自定义一个链表

1、先自定义节点Node

/**
 * 双向链表的节点类
 * 包含2部分   第一个是数据域，第二个是引用域
 */
public class Node {
    public Object e;   //数据域  存储节点内容
    public Node next;  //引用域，指向后一个节点
    public Node pre;   //引用域 指向前一个节点
    public Node(){

    }
    public Node(Object e){
        this.e = e;
        next = null;
        pre = null;
    }


}

2、定义一个简单的双向链表

package com.test.linked;

/**
 * 自定义的双向链表
 */
public class MyList {
    private Node head;   //头部节点
    private Node tail;   //尾部节点
    private int size = 0;  //链表数量

    public MyList() {
        head = new Node();
        tail = new Node();
        head.next =null;
        tail.pre = null;
    }

    public boolean empty() {
        if (head.next == null)
            return true;
        return false;
    }

    //找到所找下标节点的前一个节点
    public Node findpre(int index){
        Node rnode = head;
        int dex = -1;
        while(rnode.next != null){
            //找到了插入节点的上一个节点
            if( dex== index - 1){
                return rnode;
            }
            rnode = rnode.next;
            dex++;
        }
        return null;
    }

    public Node findthis(int index){
        Node rnode = head;
        //把rnode想象为指针，dex为指向的下标，这个地方很容易错，因为当指向最后一个节点时没有判断IF就跳出循环了
        int dex = -1;
        while(rnode.next != null){
            if(dex == index)
            return rnode;
            rnode = rnode.next;
            dex++;
        }
        if(dex == size - 1){
            return rnode;
        }
//        Node test = new Node(new Students("haha",1,2));
        return null;
    }

    // 往链表末尾加入节点
    public void add(Object e) {
        Node node = new Node(e);
        Node rnode = head;
        //如果是空链表的话插入一个节点，这个节点的pre不能指向上一个节点，必须指空
        if (this.empty()) {
            rnode.next = node;
            rnode.next.pre = null;
            tail.pre = node;
            size++;
        } else {
            while (rnode.next != null)
                rnode = rnode.next;
            rnode.next = node;
            node.pre = rnode;
            tail.pre = node;
            size++;
        }
    }

    //往链表的某一个标插入一个节点
    public boolean add(int index,Object e){
        if(index <0||index>=size)
            return false;
        Node node = new Node(e);
        Node prenode = this.findpre(index);
        node.next = prenode.next;
        prenode.next.pre = node;
        prenode.next = node;
        node.pre = prenode;
        size++;
        return true;
    }


    public boolean add(int index,MyList myl){
        if(index <0 || index >= size)
            return false;
        Node prenode = this.findpre(index);
//        myl.tail.pre.next = prenode.next;
//        prenode.pre = myl.tail.pre;
//        tail.pre = null;
//        prenode.next = myl.head.next;
//        myl.head.next.pre = prenode;
//        head.next = null;
        myl.tail.pre.next = prenode.next;
        prenode.next.pre = myl.tail.pre.pre;
        myl.head.next.pre = prenode.pre;
        prenode.next = myl.head.next;
        myl.head = null;
        myl.tail = null;
        size+=myl.size;
        return true;
    }
    
    public Object remove(int index){
        Object ob= this.get(index);
        if(index <0 || index >= size)
            return null;
        //特殊情况，当移除节点是最后一个节点的时候
        //较为复杂通过画图来写代码
        if(index == size - 1){
            Node prenode = this.findpre(index);
            this.tail.pre = this.tail.pre.pre;
            this.tail.pre.next.pre = null;
            this.tail.pre.next =null;
            size--;
            return ob;
        }
        //比较复杂，通过画图解决
        else{
            Node prenode = this.findpre(index);
            prenode.next = prenode.next.next;
            prenode.next.pre.next = null;
            prenode.next.pre = prenode.next.pre.pre;
            size--;
            return ob;
        }
    }
    
    
    public Object get(int index){
        Node thisnode = this.findthis(index);
        return thisnode.e;
    }

    public int size(){
        return size;
    }
}

测试内容：

package com.test.linked;

import java.util.Random;

public class ListTest {
    public static void main(String[] args) {
        String name = "";
        String color = "";
        int size;
        MyList myl = new MyList();
        Random random = new Random();
        size = random.nextInt(5) + 1;
        for (int i = 0; i < size; i++) {
            color = "颜色"+random.nextInt(5) + 18;
            for (int j = 0; j < 4; j++) {
                name += (char) (random.nextInt(26) + 97);
            }
            Dog dog = new Dog(name, color);
            myl.add(dog);
            name = "";
        }

        System.out.println("Size of myl1 is "+ myl.size());
        for(int i = 0; i < myl.size() ;i++){
            Dog dog = (Dog) myl.get(i);
            System.out.println(dog.toString());
        }
//        //测试能否在链表末尾加入节点（成功）
//        for(int i = 0; i < myl.size() ;i++){
//            Dog dog = (Dog) myl.get(i);
//            System.out.println(dog.toString());
//        }
//        //测试能否通过下标加入一个节点（成功）
//        Dog dog = new Dog(name, color);
//        myl.add(1, dog);
//        System.out.println("Size is "+ myl.size());
//        for(int i = 0; i < myl.size() ;i++){
//            Dog dog = (Dog) myl.get(i);
//            System.out.println(dog.toString());
//        }

        MyList myl2 = new MyList();
        size = random.nextInt(5) + 1;
        for (int i = 0; i < size; i++) {
            color = "颜色"+random.nextInt(5) + 18;
            for (int j = 0; j < 4; j++) {
                name += (char) (random.nextInt(26) + 97);
            }
            Dog dog = new Dog(name, color);
            myl2.add(dog);
            name = "";
        }
        System.out.println("Size is of myl2 "+ myl2.size());
        for(int i = 0; i < myl2.size() ;i++){
            Dog dog = (Dog) myl2.get(i);
            System.out.println(dog.toString());
        }

        myl.add(1, myl2);
        System.out.println("Size is of myl1 "+ myl.size());
        for(int i = 0; i < myl.size() ;i++){
            Dog dog = (Dog) myl.get(i);
            System.out.println(dog.toString());
        }
    }

}

码上开花

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java 链表学习

一、链表定义链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的二、链表组成链表由一系列节点（链表中每一个元素称为节点--Node）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域　链表的构成要素的本质，是节点（Node）的...
复制链接

扫一扫

专栏目录