devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

[数据结构] 链表(图文超详解讲解)_链表数据结构

作者：很楠不爱3 | 2024-04-29 22:50:07

赞

踩

链表数据结构

 

一、链表是什么？

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

二、链表

1.链表的结构

链表的结构如图:

d7aedac5d7c84b73aca0572b3418987b.png

 

链表有8种结构:

1.单向带头循环 2.单向带头非循环. 3.单向不带头循环. 4.单向不带头非循环.

5.双向带头循环. 6.双向带头非循环. 7.双向不带头循环. 8.双向不带头非循环.

接下来介绍链表种主要的一些结构

1.单链表和双链表的结构如下:

d00201bcc92549a3a1089ac1ba8b1791.png

2.不带头单链表丶带头单链表结构:

7f7b849f0fee4f67be58e9b1c1ac9487.png

3.单链表丶循环单链表结构:

943ae14d8eb146ddb665d35c3fd84a9c.png

4. 无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

1dce295c1ee04702a5a3fb9bbe74a7ce.png

2.链表的方法代码实现

1.单链表实现方法:

1.我们先创建链表的val值和next

  1. import java.util.Scanner;
  2.  
  3. /**
  4.  * Created with InteliJ IDEA.
  5.  * /Description:
  6.  * User:PANJIAPENG
  7.  * Date:2022-08-11
  8.  * Time:9:20
  9.  */
  10. //节点
  11. class ListNode{
  12.     public int val;
  13.     public ListNode next;
  14.  
  15.     public ListNode (int val){
  16.         this.val = val;
  17.     }
  18. }

2.我们可以用最简单方法创建出一链表但是比较low,不建议使用,我们可以使用下面的头插法和尾插法来实现出链表

  1. public class MylLnkedList {
  2.     public ListNode head;
  3.     //创建链表 low
  4.     public void Mff(){
  5.         ListNode listNode1 = new ListNode(11);
  6.         ListNode listNode2 = new ListNode(12);
  7.         ListNode listNode3 = new ListNode(13);
  8.         ListNode listNode4 = new ListNode(14);
  9.         ListNode listNode5 = new ListNode(15);
  10.         listNode1.next = listNode2;
  11.         listNode2.next = listNode3;
  12.         listNode3.next = listNode4;
  13.         listNode4.next = listNode5;
  14.         this.head = listNode1;
  15.     }

3.打印链表:

  1.  //打印链表
  2.     public void display() {
  3.         ListNode cur = this.head;
  4.         while (cur != null) {
  5.             System.out.print(cur.val+" ");
  6.             cur = cur.next;
  7.         }
  8.         System.out.println();
  9.     }

 4.求链表的长度:

  1.  //求单链表长度
  2.     public int size(){
  3.         int count = 0;
  4.         ListNode cur = this.head;
  5.         while(cur != null){
  6.             count++;
  7.             cur = cur.next;
  8.         }
  9.         return count;
  10.     }

5.头插法:

  1.   //头插法
  2.     public void addFirst(int data){
  3.         ListNode node = new ListNode(data);
  4.         if(this.head == null){
  5.             this.head = node;
  6.         }
  7.         else{
  8.             node.next = this.head;
  9.             this.head = node;
  10.         }
  11.     }

 

6.尾插法:

  1. //尾插法
  2.     public void addLast(int data){
  3.         ListNode node = new ListNode(data);
  4.         ListNode cur = this.head;
  5.         if(this.head==null){
  6.             this.head = node;
  7.         }
  8.         else{
  9.             while (cur.next != null){
  10.                 cur = cur.next;
  11.             }
  12.             cur.next = node;
  13.         }
  14.     }

7.找到链表中是否有val值:

  1.   //找链表中是否有这个数
  2.     public boolean contains(int key){
  3.         ListNode cur = this.head;
  4.         while(cur != null){
  5.             if(key == cur.val){
  6.                 return true;
  7.             }
  8.             cur = cur.next;
  9.         }
  10.         return false;
  11.     }

8.删除第一次出在链表出现的key的关节点:

  1. //找删除的前驱
  2.     public ListNode searchPery(int key){
  3.         ListNode cur = this.head;
  4.         while(cur.next != null) {
  5.             if (cur.next.val == key) {
  6.                 return cur;
  7.             }
  8.             cur = cur.next;
  9.         }
  10.         return null;
  11.     }
  12.     //删除第一次出现的关键字为key的节点
  13.     public void remove(int key){
  14.         if (this.head == null){
  15.             System.out.println("单链表为空，不能删除");
  16.             return;
  17.         }
  18.         if(key == this.head.val){
  19.             this.head = this.head.next;
  20.             return;
  21.         }
  22.         ListNode cur = searchPery(key);
  23.         if(cur == null){
  24.             System.out.println("没有你要删除的节点");
  25.             return ;
  26.         }
  27.         ListNode del = cur.next;
  28.         cur.next = del.next;
  29.     }

9.删除所有出在链表出现的key的关节点:

  1.  //删除出现所以是key的节点
  2.     public ListNode removeAllkey(int key){
  3.         if(this.head == null){
  4.             return null;
  5.         }
  6.         ListNode cur = this.head.next;
  7.         ListNode pver = this.head;
  8.         while (cur != null){
  9.             if(cur.val == key){
  10.                 pver.next = cur.next;
  11.                 cur = cur.next;
  12.             }
  13.             else {
  14.                 pver = cur;
  15.                 cur = cur.next;
  16.             }
  17.            return this.head;
  18.         }
  19.         if(this.head.val == key){
  20.             this.head = this.head.next;
  21.         }
  22.         return this.head;
  23.     }

10.清空链表:

  1.  //清空链表
  2.     public void clear(){
  3.         //粗暴做法 this.head = null;
  4.         ListNode curNext = this.head.next;
  5.         while(this.head != null){
  6.             this.head.next = null;
  7.             this.head = curNext;
  8.         }
  9.     }
  10.     public boolean chkPalindrome(){
  11.         if(this.head == null){
  12.             return true;
  13.         }
  14.         ListNode last = this.head;
  15.         ListNode slow = this.head;
  16.         while (last != null &&  last.next != null){
  17.             last = last.next.next;
  18.             slow = slow.next;
  19.         }
  20.         ListNode cur = slow.next;
  21.         ListNode curNext = cur.next;

2.双向链表的方法实现代码:在已经了解单链表的结构后我们就会发现单链表和双链表的实现是大同小异的

  1. class ListNode {
  2.     public int val;
  3.     public ListNode next;
  4.     public ListNode prev;
  5.  
  6.     public ListNode(int val) {
  7.         this.val = val;
  8.     }
  9. }
  10. public class MyLinjedlist {
  11.     public ListNode head;
  12.     public ListNode last;
  13.  
  14.     //打印链表
  15.     public void display() {
  16.         ListNode cur = this.head;
  17.         while (cur != null) {
  18.             System.out.print(cur.val+" ");
  19.             cur = cur.next;
  20.         }
  21.         System.out.println();
  22.     }
  23.  
  24.     //得到链表的长度
  25.     public int size() {
  26.         int count = 0;
  27.         ListNode cur = this.head;
  28.         while (cur != null) {
  29.             count++;
  30.             cur = cur.next;
  31.         }
  32.         return count;
  33.     }
  34.  
  35.     //查找是否包含关键字key是否在链表中
  36.     public boolean contains(int key) {
  37.         if (this.head == null) {
  38.             return false;
  39.         }
  40.         ListNode cur = this.head;
  41.         while (cur != null) {
  42.             if (cur.val != key) {
  43.                 cur = cur.next;
  44.             } else {
  45.                 return true;
  46.             }
  47.         }
  48.         return false;
  49.     }
  50.     //头插法
  51.     public void addFirst(int data){
  52.         ListNode node = new ListNode(data);
  53.         if(this.head == null){
  54.             this.head = node;
  55.             this.last = node;
  56.         }else {
  57.             node.next = this.head;
  58.             this.head.prev = node;
  59.             this.head = node;
  60.         }
  61.     }
  62.     //尾插法
  63.     public void addLast(int data){
  64.          ListNode node = new ListNode(data);
  65.         if(this.head == null){
  66.             this.head = node;
  67.             this.last = node;
  68.         }else {
  69.             this.last.next = node;
  70.             node.prev = this.last;
  71.             this.last = node;
  72.         }
  73.     }
  74. //删除第一次出现关键字为key的节点
  75.     public void remove(int key){
  76.         ListNode cur = this.head;
  77.         if(this.head == null){
  78.             System.out.println("此链表为空，没有要删除的key值");
  79.             return;
  80.         }
  81.         while(cur != null){
  82.             if(cur.val == key){
  83.                 if(cur == head){
  84.                     this.head = this.head.next;
  85.                     if(head != null) {
  86.                         head.prev = null;
  87.                     }
  88.                     else {
  89.                      last = null;
  90.                     }
  91.                 }
  92.  
  93.                 else {
  94.                     cur.prev.next = cur.next;
  95.                     if (cur.next != null) {
  96.                         //中间位置
  97.                         cur.next.prev = cur.prev;
  98.                     } else {
  99.                         last = last.prev;
  100.  
  101.                     }
  102.                 }
  103.                 return;
  104.             }
  105.             cur = cur.next;
  106.         }
  107.     }
  108.     //删除所以key的节点
  109.     public void removeAll(int key){
  110.         ListNode cur = this.head;
  111.         if(this.head == null){
  112.             System.out.println("此链表为空，没有要删除的key值");
  113.             return;
  114.         }
  115.         while(cur != null){
  116.             if(cur.val == key){
  117.                 if(cur == head){
  118.                     this.head = this.head.next;
  119.                     if(head != null) {
  120.                         head.prev = null;
  121.                     }
  122.                     else {
  123.                         last = null;
  124.                     }
  125.                 }
  126.  
  127.                 else {
  128.                     cur.prev.next = cur.next;
  129.                     if (cur.next != null) {
  130.                         //中间位置
  131.                         cur.next.prev = cur.prev;
  132.                     } else {
  133.                         last = last.prev;
  134.  
  135.                     }
  136.                 }
  137.             }
  138.             cur = cur.next;
  139.         }
  140.     }
  141.     //任意位置插入，第一个数据节点默认为0下标
  142.     public void addIndex(int index,int data){
  143.         ListNode node = new ListNode(data);
  144.         if(index == 0){
  145.             addFirst(data);
  146.             return;
  147.         }
  148.         if (index == size()-1){
  149.             addLast(data);
  150.             return;
  151.         }
  152.         ListNode cur = this.head;
  153.        while (index != 0){
  154.            index--;
  155.            cur = cur.next;
  156.        }
  157.         node.next = cur;
  158.         node.prev= cur.prev;
  159.         cur.prev.next = node;
  160.         cur.prev = node;
  161.     }
  162.     //清理链表
  163.     public  void clear(){
  164.         while (head != null){
  165.             ListNode curNext = this.head.next;
  166.             head.next = null;
  167.             head.prev = null;
  168.             head = curNext;
  169.         }
  170.         last = null;
  171.     }
  172. }

总结

根据读完本文后大家会对链表有更深的理解,并且能够掌握对方法的深层理解,相信大家在过后时间能够保持求学的态度,我们一起加油!offer拿到手软!对博主感兴趣可以关注博主,我会继续更新博客,努力完善我的文章内容不会辜负大家的期待!

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/510195
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号