数据结构之链表

最新推荐文章于 2022-08-03 22:38:56 发布
最新推荐文章于 2022-08-03 22:38:56 发布
阅读量215 收藏
点赞数
分类专栏： Java基础 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/csdnLeraner/article/details/100584395
版权

参考博文:
Java数据结构和算法（七）——链表

一、链表定义

是一种链式存储结构, 数据在物理空间是分散存储的. 每个节点包含2部分, 存储的数据和指向下一个节点的地址.

二、链表的种类

1.单链表

在这里插入图片描述
单链表特点：
1.只能向一个方向遍历
2.添加元素从头部插入, 若想向尾部插入元素, 必须遍历前n-1个节点

通过单向链表可实现栈, 添加节点和删除头节点对应栈的入栈和出栈

新增节点

在这里插入图片描述

删除节点

在这里插入图片描述
实现思路: 将当前节点的上一个节点指向当前节点的下一个节点

代码实现

public class SinglyLinkedList {
    // 指向头结点
    private Node head; 
    // 链表长度
    private int size;

    public SinglyLinkedList() {
        this.size = 0;
        this.head = null;
    }

// 定义一个内部类Node
private class Node {
     private Object data;
     private Node next;

     public Node(Object data, Node next) {
         this.data = data;
         this.next = next;
     }
 }

 // 增加节点
	 public void addNode(Object obj) {
      if (size == 0) {
          Node newNode = new Node(obj, null);
          head = newNode;
          size++;
          return;
      }

	  Node previous = head;
      Node newNode = new Node(obj, previous );
      head = newNode; // 将头部地址指向当前节点
      size++;
    }
 
 // 打印链表
    public void display() {
        if (size == 0) {
            System.out.println("[]");
        } else {
            Node current = head;
            // 遍历前n-1个节点
            while (current.next != null) {
                Object data = current.data;
                System.out.print(data + "==>");
                current = current.next;
            }
            System.out.println(current.data);// 打印最后一个
        }
    }
    
	// 删除头节点
	public Object deleteHeadNode() {
	        if (size != 0) {
	            Object obj = head.data;
	            head = head.next;
	            size--;
	            return obj;
	        }
	        return null;
	    }

   // 查找链表中的元素
    public Object find(Object obj) {
        if (size == 0) {
            return null;
        }

        Node current = head;
        while (current.next != null) {
            if (current.data.equals(obj)) {
                return obj;
            }
            current = current.next;
        }
        
        // 最后一个元素
        if (current.data.equals(obj)) {
            return obj;
        }
        return null;
    }
2.双端链表

双端链表相对于单链表多了一个尾节点的引用, 这样向尾部添加数据就方便多了
在这里插入图片描述
双端链表实现队列, 向尾部插入数据对应入队, 删除头部节点对应出队

public class DoublEendedList {
    
    private Node head; // 指向头部节点
    private Node tail; // 指向尾部节点
    private int size;

    public DoublEendedList() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }
    // 节点类
    private class Node {
        private Object data;//节点数据
        private Node next;// 节点指向下一节点连接

        public Node(Object data, Node next) {
            this.data = data;
            this.next = next;
        }
    }
}

// 在头部插入节点
    public void addNode(Object data) {
        if (size == 0) {
            Node node = new Node(data, null);
            head = node;
            tail = node;
        } else {
            Node node = new Node(data, head);
            head = node;
        }
        size++;
    }

// 在尾部添加节点
    public Object addTail(Object obj) {
        if (size == 0) {
            Node node = new Node(obj, null);
            head = node;
            tail = node;
        } else {
            Node node = new Node(obj, null);
            tail.next = node;
            tail = node;
        }
        size++;
        return tail.data;
    }

   // 从后往前遍历
    public void displayBackword() {
        Node last = tail;

        if (size == 0) {
            System.out.println("[]");
        } else {
            while (last.previous != null) { // 遍历后n-1个
                System.out.print(last.data + "=>");
                last = last.previous;
            }
            System.out.println(last.data);// 遍历至第一个
        }
    }

    // 从前往后遍历
    public void displayForword() {

        Node current = head;

        if (size == 0) {
            System.out.println("[]");
        } else {
            while (current.next != null) {
                System.out.print(current.data + "==>");
                current = current.next;
            }
            System.out.println(current.data);// 遍历至最后一个
        }
    }

// 删除头部节点
    public Object deleteHead() {
        Object obj = null;

        if (size == 0) {
            return null;
        }

        if (size == 1) {
            obj = head.data;
            head = null;
            size--;
        } else {
            obj = head.data;
            Node next = head.next;
            head = next;
            size--;
        }
        return obj;
    }

// 遍历链表
public void display() {
    if (size == 0) {
        System.out.println("[]");
    } else {
        Node current = head;
        while (current.next != null) {
            Object data = current.data;
            System.out.print(data + "==>");
            current = current.next;
        }
        System.out.println(current.data);// 打印最后一个
    }

 // 删除节点
    public Object deletNode(Object obj) {

        Object item = null;

        if (size == 0) {
            return item;
        }

        if (size == 1) {
            if (head.data.equals(obj)) {
                head = null;
                tail = null;
                size--;
                item = obj;
            }
        } else {
            Node current = head;
            while (current.next != null) {
                if (current.previous == null) {// 如果是第一个
                    if (head.data.equals(obj)) {
                        head = current.next;
                        head.previous = null;
                        current = head;
                        size--;
                        item = obj;
                        continue;
                    }
                    current = current.next;
                } else {
                    if (current.data.equals(obj)) {
                        Node previous = current.previous;
                        Node next = current.next;

                        previous.next = next;
                        next.previous = previous;
                        current = current.next;

                        size--;
                        item = obj;
                        continue;
                    }
                    current = current.next;
                }
            }
            if (current.data.equals(obj)) { // 处理最后一个节点
                current.previous.next = null;
                tail = current.previous;
                size--;
                item = obj;
            }
        }
        return item;
    }
}
3.双向链表

双向链表相对于双端链表, 节点的结构新增加了指向前一个节点的地址, 这样链表就可以双向遍历了.
在这里插入图片描述
新增节点:
在这里插入图片描述

public class TwoWayLinkedList {

    private Node head;
    private Node tail;
    private int size;

    public TwoWayLinkedList() {
        size = 0;
        head = null;
        tail = null;
    }

 	private class Node {
        private Object data;
        private Node next;
        private Node previous;

        public Node(Object data, Node next, Node previous) {
            this.data = data;
            this.next = next;
            this.previous = previous;
        }
    }

 	// 向头部插入节点
    public Object addNode(Object obj) {
        if (size == 0) {
            Node node = new Node(obj, null, null);
            head = node;
            tail = node;
        } else {
            Node node = new Node(obj, head, null);
            head.previous = node;
            head = node;
        }
        size++;
        return obj;
    }
	
	// 向尾部插入节点
    public Object addTailNode(Object obj) {
        if (size == 0) {
            Node node = new Node(obj, null, null);
            head = node;
            tail = node;
        } else {
            Node node = new Node(obj, null, tail);
            tail.next = node;
            tail = node;
        }
        size++;
        return obj;
    }
	
	// 查找节点
    public Object find(Object obj) {
        Node current = head;

        if (size == 0) {
            return null;
        } else {
            while (current.next != null) {
                if (current.data.equals(obj)) {
                    return obj;
                }
                current = current.next;
            }
            if (current.data.equals(obj)) {
                return obj;
            }
        }
        return null;
    }
}

// 删除头部节点
    public Object deleteHeadNode() {

        Node current = head;

        if (size == 0) {
            return current;
        } else {
            head = current.next;
            head.previous = null;
        }
        size--;
        return current.data;
    }

   // 删除尾部节点
    public Object deleteTailNode() {

        Node last = tail;

        if (size == 0) {
            return last;
        } else {
            if (last.previous != null) {
                tail = last.previous;
                tail.next = null;
                size--;
            } else {
                // 只有一个节点
                head = null;
                tail = null;
                size--;
            }
        }
        return last.data;
    }

   // 删除节点
    public Object deletNode(Object obj) {

        Object item = null;

        if (size == 0) {
            return item;
        }

       if (size == 1) {
            if (head.data.equals(obj)) {
                head = null;
                tail = null;
                size--;
                item = obj;
            }
        } else {
            Node current = head;
            while (current.next != null) {
                if (current.previous == null) {// 如果是第一个
                    if (head.data.equals(obj)) {
                        head = current.next;
                        head.previous = null;
                        current = head;
                        size--;
                        item = obj;
                        continue;
                    }
                    current = current.next;
                } else {
                    if (current.data.equals(obj)) {
                        Node previous = current.previous;
                        Node next = current.next;

                        previous.next = next;
                        next.previous = previous;
                        current = current.next;

                        size--;
                        item = obj;
                        continue;
                    }
                    current = current.next;
                }
            }
            if (current.data.equals(obj)) { // 处理最后一个节点
                current.previous.next = null;
                tail = current.previous;
                size--;
                item = obj;
            }
        }
        return item;
    }
链表
仓鼠玉米的博客
02-28 400
对于数据结构问题，首先来谈谈关于链表的问题，这个问题困扰的我很久，其实也没那么难。 关于链表的操作无非就是增删改，理解链表关键是关于指针节点的操作， 1.动态分配内存 定义链表节点，拿数字为例子 typedef Node {     int data;     Node* next; } Node* p=(Node*)malloc(sizeof(Node));
数据结构-使用javascript讲解数据结构之链表.zip
最新发布
02-12
本资料包“数据结构-使用javascript讲解数据结构之链表.zip”将深入探讨链表的概念、实现以及其在JavaScript中的应用。 链表不同于数组，数组是连续的内存空间，而链表的元素在内存中是非连续存储的。每个元素称为...
算法-数据结构之链表合并算法.rar
09-16
本资料“算法-数据结构之链表合并算法.rar”包含的“数据结构之链表合并算法.pdf”应该详细探讨了这个主题。 首先，链表的基本概念是必不可少的。链表由一系列节点构成，每个节点包含数据元素和指向下一个节点的...
C++数据结构之链表的创建
12-26
C++数据结构之链表的创建 前言 1.链表在C/C++里使用非常频繁, 因为它非常使用, 可作为天然的可变数组. push到末尾时对前面的链表项不影响. 反观C数组和std::vector, 一个是静态大小, 一个是增加多了会对之前的元素...
C语言中数据结构之链表归并排序实例代码
08-30
C语言中数据结构之链表归并排序实例代码 本文主要介绍了C语言中数据结构之链表归并排序实例代码的相关知识点，通过对链表归并排序的实现，帮助读者深入了解链表数据结构的应用。 一、链表数据结构 链表是一种常用...
数据结构链表
12-08
数据结构各种链表的实现和建立。#include <iostream.h> #include <conio.h> typedef char datatype; typedef struct NODE * pointer; struct NODE { datatype data; pointer next; }; typedef pointer lklist; lklist initlist() {//初始化 pointer head; head=new NODE; head->next=NULL; return head; }
(C语言数据结构)单链表
09-16
C语言实现单链表 Init(初始化) Length(当前结点个数) AddEnd(尾部添加) AddFirst(首部添加) Insert(插入) * Delete(删除) Find(查找返回) ShowAll(显示所有元素) Destory(销毁链表)
数据结构-链表
浮生若梦
05-30 426
链表
数据结构 --- 链表
GongHao2014的专栏
10-26 474
链表 记录了对链表的简单理解，不知道是否有重大错误，如果有意见或建议，欢迎评论回复 头指针 结点 指针、结点 头指针、头结点、第一个结点区别 举例
【数据结构】链表
Sweet_0115的博客
08-03 449
链表介绍与实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值