Java数据结构与算法笔记——有序链表和双向链表

最新推荐文章于 2022-10-07 17:25:48 发布
最新推荐文章于 2022-10-07 17:25:48 发布
阅读量486 收藏 2
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_Wanderer/article/details/113682229
版权

文章目录

有序列表

有序列表简介

在有序链表中，数据是按照关键值有序排列的。一般在大多数需要使用有序数组的场合也可以使用有序链表。
与有序数组相比，有序链表的优点：插入的速度快（因为元素不需要移动）；链表可以有效的使用内存，而数组只能局限于一个固定的大小中。

插入：先判断大小，然后在正确的位置插入
删除：删除头结点
查找：需要遍历

java实现

package link;

public class OrderLinkedListTest {
    public static void main(String[] args) {
        OrderLinkedList order = new OrderLinkedList();
        order.insert(10);
        order.insert(8);
        order.insert(11);

        order.display();
        System.out.println(order.deleteHead());
        order.display();

    }
}

class OrderLinkedList{
    private Node head;
    private int size;

    //构造方法
    public OrderLinkedList(){
        head = null;
        size = 0;
    }

    //有序链表插入操作
    public void insert(int data){
        Node newNode = new Node(data);
        Node previous = null;
        Node current = head;
        while (current!=null && data>current.data){
            previous = current;
            current = current.next;
        }

        if(previous == null){
            //要插入的值比所有值都小
            head = newNode;
            head.next = current;
        }else{
            newNode.next = current;
            previous.next = newNode;
        }
        size ++;
    }

    //判断链表是不是空链表
    public boolean isEmpty(){
        return size==0;
    }

    //链表删除头结点，默认链表中是有节点的
    public int deleteHead(){
        int obj = head.data;
        head = head.next;
        size --;
        return obj;
    }

    //遍历输出所有node信息
    public void display(){
        if (size>0){
            //不是空的
            Node current = head;
            int tmpSize = size;
            if (tmpSize == 1){
                System.out.println("[" + head.data + "]");
                return; // 结束掉方法
            }
            while (tmpSize>0){
                if (current == head){
                    System.out.print("[" + current.data + "->");
                }else if(current.next == null){
                    //最后一个节点
                    System.out.print(current.data + "]");
                }else {
                    System.out.print(current.data + "->");
                }
                tmpSize --;
                current = current.next;
            }
            System.out.println();//输出一个换行符
        }else {
            //空列表
            System.out.println("[]");
        }
    }

    //定义一个私有类
    private class Node{
        private int data; //封装在节点里的数据
        private Node next; //指针，指向下一个节点

        //构造方法
        public Node(int data){
            this.data = data;

        }

        @Override
        public String toString() {
            return "Node [data=" + data + ", next=" + next + "]";
        }
    }
}

有序链表实现无序数组排序

冒泡排序，选择排序和插入排序方法时间复杂度都是O(N^2)

利用有序链表实现无序数组的排序肯定比以上三种方法效率高，但是需要开辟差不多两倍的空间，因为数组和链表必须在内存中同时存在。

package link;

import com.sun.org.apache.xpath.internal.objects.XString;

import java.util.Arrays;

public class OrderLinkedListTest {
    public static void main(String[] args) {
        // 生成随机数组
        int[] list = new int[10];
        for (int i=0;i<10;i++){
            list[i] = (int)(Math.random()*100);
        }
        System.out.println(Arrays.toString(list));

        //排序
        OrderLinkedList order = new OrderLinkedList();
        for(int i:list){
            order.insert(i);
        }
        while (!order.isEmpty()){
            System.out.print(Integer.toString(order.deleteHead()) + ' ');
        }


    }
}

class OrderLinkedList{
    private Node head;
    private int size;

    //构造方法
    public OrderLinkedList(){
        head = null;
        size = 0;
    }

    //有序链表插入操作
    public void insert(int data){
        Node newNode = new Node(data);
        Node previous = null;
        Node current = head;
        while (current!=null && data>current.data){
            previous = current;
            current = current.next;
        }

        if(previous == null){
            //要插入的值比所有值都小
            head = newNode;
            head.next = current;
        }else{
            newNode.next = current;
            previous.next = newNode;
        }
        size ++;
    }

    //判断链表是不是空链表
    public boolean isEmpty(){
        return size==0;
    }

    //链表删除头结点，默认链表中是有节点的
    public int deleteHead(){
        int obj = head.data;
        head = head.next;
        size --;
        return obj;
    }

    //遍历输出所有node信息
    public void display(){
        if (size>0){
            //不是空的
            Node current = head;
            int tmpSize = size;
            if (tmpSize == 1){
                System.out.println("[" + head.data + "]");
                return; // 结束掉方法
            }
            while (tmpSize>0){
                if (current == head){
                    System.out.print("[" + current.data + "->");
                }else if(current.next == null){
                    //最后一个节点
                    System.out.print(current.data + "]");
                }else {
                    System.out.print(current.data + "->");
                }
                tmpSize --;
                current = current.next;
            }
            System.out.println();//输出一个换行符
        }else {
            //空列表
            System.out.println("[]");
        }
    }

    //定义一个私有类
    private class Node{
        private int data; //封装在节点里的数据
        private Node next; //指针，指向下一个节点

        //构造方法
        public Node(int data){
            this.data = data;

        }

        @Override
        public String toString() {
            return "Node [data=" + data + ", next=" + next + "]";
        }
    }
}

双向链表

双向链表简介

双向链表可以从两个方向遍历。

在双端列表基础上，给每个节点添加了一个previous指针，指向前一个节点。

java实现双向链表

package link;

public class DoubleWayLinkedListTest {
    public static void main(String[] args) {
        DoubleWayLinkedList doubleWayLinkedList = new DoubleWayLinkedList();
        doubleWayLinkedList.addHead(1);
        doubleWayLinkedList.addHead(2);
        doubleWayLinkedList.addHead(3);
        doubleWayLinkedList.addTail(4);
        doubleWayLinkedList.addTail(5);
        doubleWayLinkedList.addTail(6);

        doubleWayLinkedList.display();

        System.out.println(doubleWayLinkedList.delete(1));
        doubleWayLinkedList.display();

        System.out.println(doubleWayLinkedList.deleteHead());
        doubleWayLinkedList.display();

        while (!doubleWayLinkedList.isEmpty()){
            System.out.println(doubleWayLinkedList.deleteTail());
        }

//        System.out.println(doubleLinkedList.deleteTail());
//        doubleLinkedList.display();
    }
}

class DoubleWayLinkedList{
    private int size; //链表的节点数
    private Node head; // head是头结点的指针，引入了一个新类型，node
    private Node tail; //指向尾结点的指针

    //构造方法
    public DoubleWayLinkedList(){
        size = 0;
        head = null;
        tail = null;
    }

    //向链表中添加节点(添加到头部)
    public Object addHead(Object data){
        Node newNode = new Node(data);
        if(size == 0){
            //空链表
            head = newNode;
            tail = newNode;
            newNode.prev = null;
            newNode.next = null;
        }else {
            //非空链表
            newNode.next = head;
            newNode.prev = null;
            head.prev = newNode;
            head = newNode;
        }
        size ++;
        return newNode;
    }

    //添加尾结点
    public Object addTail(Object data){
        Node newNode = new Node(data);
        if(size == 0) {
            //空链表
            head = newNode;
            tail = newNode;
            newNode.prev = null;
            newNode.next = null;
        }else {
            tail.next = newNode;
            newNode.prev = tail;
            newNode.next = null;
            tail = newNode;
        }
        size ++;
        return newNode;
    }

    //链表删除头结点
    public Object deleteHead(){
        Object obj = null;
        if(size == 0){
            //空链表
            return obj;
        }else if(size == 1){
            //链表中只有一个节点
            obj = head.data;
            head = null;
            tail = null;

        }else{
            obj = head.data;
            head =head.next;
            head.prev = null;
        }
        size --;
        return obj;
    }

    //删除尾部节点
    public Object deleteTail(){
        Object obj = null;
        if(size == 0){
            //空链表
            return obj;
        }else if(size == 1) {
            //链表中只有一个节点
            obj = tail.data;
            head = null;
            tail = null;
        }else {
            obj = tail.data;
            tail = tail.prev;
            tail.next = null;
        }
        size --;
        return obj;
    }

    //判断链表是不是空链表
    public boolean isEmpty(){
        return size==0;
    }

    //删除指定节点，删除成功返回true，失败返回false
    public boolean delete(Object value){
        if(isEmpty()){
            //空表
            return false;
        }

        //不是空表
        Node current = head;
        Node previous = head;//上一个变量
        while (!value.equals(current.data)){
            if (current.next == null){
                //已经扫描到了尾结点，且没找到数据
                return false;
            }else{
                //还没到尾结点
                previous = current;
                current = current.next;
            }
        }
        // 循环终止了，还会继续执行下面的语句，证明已经找到了要找的节点
        //删除找到的节点
        if(size == 1){
            head = null;
            tail = null;
        }else if(current == head){
            //头部节点
            head = head.next;
            head.prev = null;
        }else if(current == tail){
            //尾部节点
            previous.next = null;
            tail = previous;
        }else {
            previous.next = current.next;
            current.next.prev = previous;
        }
        size --;
        return true;
    }

    //遍历输出所有node信息
    public void display(){
        if (size>0){
            //不是空的
            Node current = head;
            int tmpSize = size;
            if (tmpSize == 1){
                System.out.println("[" + head.data + "]");
                return; // 结束掉方法
            }
            while (tmpSize>0){
                if (current == head){
                    System.out.print("[" + current.data + "->");
                }else if(current.next == null){
                    //最后一个节点
                    System.out.print(current.data + "]");
                }else {
                    System.out.print(current.data + "->");
                }
                tmpSize --;
                current = current.next;
            }
            System.out.println();//输出一个换行符
        }else {
            //空列表
            System.out.println("[]");
        }
    }

    //获取节点个数
    public int getSize(){
        return size;
    }

    //定义一个私有类
    private class Node{
        private Object data; //封装在节点里的数据
        private Node next; //指针，指向下一个节点
        private Node prev; //指针，指向上一个节点

        //构造方法
        public Node(Object data){
            this.data = data;
        }

        @Override
        public String toString() {
            return "Node [data=" + data + ", next=" + next + ", prev=" + prev + "]";
        }
    }

}
Mr. Wanderer
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
有序的双向链表
记忆流年的博客
09-23 2952
链表是一种物理结构上不连续，非顺序的数据结构,其逻辑顺序结构是以结点内的指针来确定的，此篇文章实现一个特殊的链表结构,其中的元素在插入时就是有序的排列。
Java数据结构——循环链表与双向链表
NoBug
12-21 899
1. 循环链表****** 2. 双向链表******
一步步带你用Java实现双向链表（超详细）
热门推荐
you do ,you win
04-21 1万+
文章目录什么是双向链表属性及方法节点Nodesize数据插入头插法 addFirst(T value)尾插法 addLast(T value)插入到指定下标位置add(int index)数据删除(返回被删除节点存储的值)删除头结点 removeFirst删除尾结点 removeLast删除指定下标节点remove（int index）获取指定下标位置节点的数据 getData（int index）获取链表长度遍历输出print()详细遍历输出清空链表实现细节 上一节说到了单链表,这一节我们来手写一个双向链
数据结构笔记 —— 单链表和双向链表
一纸春秋的博客
12-13 824
本篇博客是根据b站尚硅谷老师的数据结构教程，学习后写的学习笔记 部分概念和图片均来自视频，代码和截图均为自己动手，本篇博客的重点在自己编写的代码注释上 尚硅谷Java数据结构与java算法（Java数据结构与算法） 单链表 链表是有序的列表（Linked List），在内存中的存储方式如上图所示 （1）链表是以节点的方式来存储，是链式存储 （2）每个节点包含data域，next域。其中，data域用来保存当前节点要存储的数据，next域用来指向下一个节点 （3）链表的各个节点不一定是连续存储 （4）链表分
剑指offer 27 - 二叉搜索树与双向链表
yuhan_9204的专栏
06-17 403
一、问题描述 输入一棵二叉搜索树，现在要将该二叉搜索树转换成一个排序的双向链表。而且在转换的过程中，不能创建任何新的结点，只能调整树中的结点指针的指向来实现。 二、实现思路 在二叉搜索树中，每个结点都有两个分别指向其左、右子树的指针，左子树结点的值总是小于父结点的值，右子树结点的值总是大于父结点的值。而在双向链表中，每个结点也有两个指针，它们分别指向前一个结点和后一个
Java 数据结构和算法（七）：链表
dd2016124的博客
02-20 170
Java数据结构和算法（七）——链表 　　前面博客我们在讲解数组中，知道数组作为数据存储结构有一定的缺陷。在无序数组中，搜索性能差，在有序数组中，插入效率又很低，而且这两种数组的删除效率都很低，并且数组在创建后，其大小是固定了，设置的过大会造成内存的浪费，过小又不能满足数据量的存储。 　　本篇博客我们将讲解一种新型的数据结构——链表。我们知道数组是一种通用的数据结构，能用来实现栈、队列等很多数据结构。而链表也是一种使用广泛的通用数据结构，它也可以用来作为实现栈、队列等数据结构的基础，基本上除非.
Java 数据结构和算法 链表
不二
05-25 668
链表 本章将学习一种全新的数据结构，链表。 链表的 机制灵活，用途广泛，它适用于许多通用的数据库，它也可以取代数组，作为其他存储结构的基础，例如栈、队列等等。除非需要频繁的通过下标随机访问各个数据，否则在很多实用数组的地方都可以用链表代替。 链结点 在链表中，每个数据项被包含在链结点中，一个链结点是某个类的对象，这个类可以叫做 Link ，因为一个链表中有许多类似的链结点，所有有必要用
【Java数据结构与算法】双向链表
12-21
在Java中实现双向链表，通常会定义一个包含数据和指针的节点类，如`HeroNode2`，并创建一个`DoubleLinkedList`类来管理链表。`DoubleLinkedList`类通常包括构造函数、遍历方法、添加方法、更新方法和删除方法。在给...
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
Python实现数据结构与算法——反转链表
12-21
反转链表是数据结构与算法领域中的一个经典问题，它要求我们改变链表节点的指向，使得原本顺着一个方向的链表变成逆序。在这个问题中，我们可以采用两种方法来解决：迭代和递归。 首先，让我们详细讲解迭代的解题...
Java有序非循环双向链表算法实例
11-04
Java 有序 非循环 双向 链表 算法 实例
C#数据结构与算法揭秘四 双向链表
12-31
所谓双向链表是如果希望找直接前驱结点和直接后继结点的时间复杂度都是 O(1)，那么，需要在结点中设两个引用域，一个保存直接前驱结点的地址，叫 prev，一个直接后继结点的地址，叫 next，这样的链表就是双向链表...
【Java数据结构与算法】环形链表及约瑟夫问题
12-21
【Java数据结构与算法】环形链表及约瑟夫问题 环形链表是一种特殊的数据结构，它的每个节点都包含一个数据元素和一个指向下一个节点的指针，且最后一个节点的指针会指向列表的第一个节点，形成一个闭合的循环。这种...
Java数据结构和算法-链表（3-有序链表）
Jane_No1的博客
12-12 604
链表的效率 在表头当中插入和删除的速度是很快的，仅仅需要一到两个引用值，和链接点的多少无关，只需O(1)的时间。 不过，查找和删除指定的链接点和在指定位置插入链接点仍然需要搜索一半的链接点，所以比较时间为O(N)。虽然，数组的查找、插入和删除的比较时间也为O(N)，但链表在插入和删除链接点的时候不需要移动任何东西，这样增加的效率是显著的，特别是在复制时间比比较时间大的多时。 还有一点就是链表
java双向链表详解
wang20010104的博客
05-10 2716
java双向链表详解
数据结构01- 单链表、双端链表、双向链表、无序链表、有序链表
琦彦
03-31 5666
数据结构01- 单链表、双端链表、双向链表、无序链表、有序链表 0、节点 节点 是数据结构中的基础，是 构成复杂数据结构的基本组成单位。 public class Node { public long data; public Node next; public Node(long value) { this.data = value; } } 1、链表的定义 链表： 通常由一连串 节点 组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向 上一个 或 下一个
Java实现双向链表
最新发布
keke的博客
10-07 3824
Java实现双向链表
有序双向链表的实现。
小猪爱拱地
07-24 416
双向链表
Python实现Dijkstra最短路径算法
Mr_Wanderer的博客
06-23 1452
''' Author：Lihao Liu 功能：实现最短路径算法 参数： sNode：源节点 dNode：目标节点 adjacencyMatrix：网络的邻接矩阵（不连接的地方标0） ''' def DijkstraRoad(sNode, dNode, adjacencyMatrix): path = [] # s-d的最短路径 n = len(adjacencyMatrix) # 邻接矩阵维度，即节点个数 fmax = 999 w = [[0 f

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值