总结：链表

最新推荐文章于 2023-03-01 15:27:22 发布
最新推荐文章于 2023-03-01 15:27:22 发布
阅读量217 收藏
点赞数
文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75100464/article/details/128176012
版权

目录

 创建链表

遍历链表

得到单链表的长度

头插法

尾插法

在任意位置插入

删除选择的一个节点

删除选择的所有节点

清空链表

找中间节点

找倒数第k个节点

反转链表

合并两个有序链表

判断是否为回文数

 

  val:存储数据

next:存储下一个节点的地址

*链表物理上不一定连续的，逻辑上是连续的，顺序表物理上和逻辑上都是连续的

*创建链表：

package work;
//Node类
public class Node {
    private int val;
    public Node next;

    public Node() {
    }

    public Node(int val) {
        this.val = val;
    }
   
    public int getVal() {
        return val;
    }
    
    public void setVal(int val) {
        this.val = val;
    }

    public String toString() {
        return "Node{val = " + val + ", next = " + next + "}";
    }
}

//mian方法
  public static void main(String[] args) {
        Node node1 = new Node(12);
        Node head=node1;
        Node node2 = new Node(13);
        Node node3 = new Node(15);
        node1.next=node2;
        node2.next=node3;

*遍历链表：

ackage work;

public class demo8 {
//遍历方法
    public static void display(Node head){
        Node cur=head;//用cur代替head，让head值不会一直改变
        while (cur!=null){
            System.out.print(cur.getVal()+" ");
            cur=cur.next;
        }
    }

    public static void main(String[] args) {
        Node node1 = new Node(12);
        Node head=node1;
        Node node2 = new Node(13);
        Node node3 = new Node(15);
        node1.next=node2;
        node2.next=node3;
        display(node1);//放入头节点
    }
}

输出：12 13 15

*判断是否包含某个数（contains）：

public static boolean contains(int key, Node head) {
        Node cur = head;
        while (cur != null) {
            if (head.getVal() == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

*得到单链表的长度：

public static int size(Node head){
        int count=0;
        Node cur=head;
        while (cur!=null){
            count++;
            cur=cur.next;
        }
        return count;
    }


public static void main(String[] args) {
        Node node1 = new Node(12);
        Node head = node1;
        Node node2 = new Node(13);
        Node node3 = new Node(15);
        node1.next = node2;
        node2.next = node3;
        int count=size(head);
        System.out.println(count);
    }

输出：3

*头插法

 public static void main(String[] args) {
        Node node1 = new Node(12);
        Node head = node1;
        Node node2 = new Node(13);
        Node node3 = new Node(15);
        node1.next = node2;
        node2.next = node3; 
        //头插法
        Node node=new Node(11);
        node.next=head;
        head=node;
        display(node);
输出：11 12 13 15

*尾插法

//尾插法
public static void addList(Node head,int data){
        Node node=new Node(data);
        Node cur=head;
        //要判断链表是否为空
        if(head==null){
            head=node;
            return;
        }
        while (cur.next!=null){
            cur=cur.next;
        }
        cur.next=node;
    }
//调用尾插法
public static void main(String[] args) {
 Node node1 = new Node(12);
        Node head = node1;
        Node node2 = new Node(13);
        Node node3 = new Node(15);
        node1.next = node2;
        node2.next = node3;
        addList(head,16);
        display(head);//从头节点开始遍历
    }

*在任意位置插入

 private static void addIndex(Node head,int index, int data) throws ListIndexOutOfException{
        //先判断索引的合法性
        checkIndex(head,index);
        if (index == 0) {
            Node node = new Node(data);
            node.next = head;
            head = node;
            return;
        }
        if (index == size(head)) {
            addList(head, data);
            return;
        }
        //循环找到索引前面的位置插入（cur）
        Node cur=findIndex(index,head);
        Node node=new Node(data);
        node.next=cur.next;
        cur.next=node;
    }

    private static void checkIndex(Node head,int index) {
        if (index < 0 || index > size(head)) {
            throw new ListIndexOutOfException("index位置不合法");
        }//抛出异常
    }

    public static Node findIndex(int index, Node head) {
        Node cur = head;
        int count=0;
        while (count!=index-1){//遍历直到索引前面的位置插入
            cur=cur.next;
            count++;//计算步数，在三索引就走两步在三前面插
        }
        return cur;//返回插入位置
    }

//异常类
package work;

public class ListIndexOutOfException extends RuntimeException{
    public ListIndexOutOfException(String message) {
        super(message);
    }
}

//main
 public static void main(String[] args) {
        Node node1 = new Node(12);
        Node head = node1;
        Node node2 = new Node(13);
        Node node3 = new Node(15);
        node1.next = node2;
        node2.next = node3;
        try {
            addIndex(head,2,14);
        }catch (ListIndexOutOfException e){
            e.printStackTrace();
        }
        display(head);
    }
}

输出：12 13 14 15

*删除选择的一个节点

public static Node searchPrey(Node head, int key) {
        //没有头节点
        if (head == null) {
            return null;
        }
        Node cur = head;
        while (cur.next != null) {//遍历到尾巴
            if (cur.next.getVal() == key) {
                return cur;//返回要删的节点的前一个节点
            }
            cur = cur.next;
        }
        return null;//没有要删除的节点
    }
//main方法
public static void main(String[] args) {
        Node node1 = new Node(12);
        Node head = node1;
        Node node2 = new Node(13);
        Node node3 = new Node(15);
        node1.next = node2;
        node2.next = node3;
         Node cur=searchPrey(head,13);
        if(cur==null){
            return;
        }
        Node del=cur.next;
        cur.next=del.next;
        display(head);
    }

*删除选择的所有节点

 public static Node removeAllkey(Node head, int key) {
        if (head == null) {
            return null;
        }
        Node prev = head;
        Node cur = head.next;
        while (cur != null) {
            if (cur.getVal() == key) {
                prev.next = cur.next;
                cur = cur.next;
            } else {
                prev = cur;
                cur = cur.next;
            }
        }
        if(head.getVal()==key){//最后判断头节点是不是key
            head=head.next;
        }
        return head;
    }

// main方法
public static void main(String[] args) {
        Node node1 = new Node(12);
        Node head =  node1;
        Node node2 = new Node(13);
        Node node3 = new Node(15);
        Node node4 = new Node(12);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        Node head1=removeAllkey(head,12);
        display(head1);
    }
输出：13 15

 *清空链表：

 public static Node clear(Node head) {
        head = null;
        return head;
    }

        Node node1 = new Node(12);
        Node head = node1;
        Node node2 = new Node(13);
        Node node3 = new Node(15);
        Node node4 = new Node(12);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        Node head1 = removeAllkey(head, 12);
        display(head1);
        System.out.println();
        head1=clear(head1);
        display(head1);
    }
输出：13 15
          
结束

*找中间节点

 public static Node middleNode(Node head){
        Node fast=head;
        Node slow=head;//快慢指针
        while (fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;//fast走两步，slow走一步
        }
        return slow;//返回中间节点
    }

 *找倒数第k个节点

public static Node findD(Node head,int k){
        if(k<=0||head==null){
            return null;
        }
        Node fast=head;
        Node slow=head;
        while (k-1!=0){//fast走k-1步
            fast=fast.next;
        if(fast==null){//大于size()则为null
            return null;
        }
            k--;
        }
        while (fast.next!=null){//开始一步一步走
            fast=fast.next;
            slow=slow.next;
        }
        return slow;//slow即要找的k
    }

*反转链表

 

 public static Node fanzhuan(Node head) {
        if(head==null){
            return null;
        }
        if(head.next==null){
            return head;
        }
        Node cur=head.next;
        head.next=null;
        while (cur != null) {
            Node curNext = cur.next;
            cur.next = head;
            head = cur;
            cur = curNext;
        }
        return head;
    }

    public static void main(String[] args) {
        Node node1 = new Node(12);
        Node node2 = new Node(45);
        Node node3 = new Node(23);
        Node node4 = new Node(90);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        Node head=fanzhuan(node1);
        display(head);

输出：90 23 45 12

 *合并两个有序链表

public  Node mergeTwoLists(Node head1, Node head2) {
        Node newhead = new Node();
        Node temp = newhead;
        while (head1 != null && head2 != null) {
            if (head1.getVal() < head2.getVal()) {
                temp.next = head1;
                head1 = head1.next;
                temp = temp.next;
            } else {
                temp.next = head2;
                head2 = head2.next;
                temp = temp.next;
            }
        }
        if (head1 != null) {
            temp.next = head1;
        }
        if (head2 != null) {
            temp.next = head2;
        }
        return newhead.next;
    }

    public static void main(String[] args) {
        LinkList linkList1=new LinkList();
        linkList1.addList(1);
        linkList1.addList(3);
        linkList1.addList(5);
        linkList1.addList(7);
        linkList1.display(linkList1.head);
        LinkList linkList2=new LinkList();
        linkList2.addList(2);
        linkList2.addList(4);
        linkList2.addList(6);
        linkList2.addList(8);
        Node head= linkList1.mergeTwoLists(linkList1.head,linkList2.head);
        System.out.println();
        linkList2.display(head);

输出：1 3 5 7 
      1 2 3 4 5 6 7 8

 *判断是否为回文数

 public boolean PalindromeNumber() {
        Node fast = head;
        Node slow = head;
        while (fast != null && slow != null) {
            fast = fast.next.next;
            slow = slow.next;
        }//找中间节点
        Node cur = slow.next;//要翻转的节点
        while (cur != null) {
            Node curNext = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curNext;
        }
        while (slow != head) {
            if (head.getVal() != slow.getVal()) {
                return false;
            }

            if (head.next == slow) {//只有两个数
                return true;
            }
            slow = slow.next;
            head = head.next;
        }
        return true;
    }

 

发呆的百香果子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
python单向循环链表_python实现单向循环链表 -- 详细思路分析
weixin_28936865的博客
01-29 449
单向循环链表其实就是在单向链表的基础上，让尾节点的下一个节点指向头节点，整个链表形成一个闭环。所以在整体思路上，和单向链表类似，只是在考虑问题时，需要考虑尾部节点指向头部节点的指针。1.构造单向循环链表1.1 构造节点单向循环链表的节点与单向链表相同，因此，这部分的代码没有区别。class Node(object):"""节点"""def __init__(self,item):self.elem...
2.3 设计链表
weixin_46923014的博客
01-03 331
3 设计链表 ①题目 力扣题目链接 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。 addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的
入坑三：链表中对cur=cur.next理解的误区
weixin_42258216的博客
11-19 4709
情况说明：在CSDN中看到了对程序算法网站“力扣”的推荐，附网站地址：https://leetcode-cn.com/ 在里面看到关于链表的算法题，但是在使用链表时存在这样的疑问，如图： 调试中的数据变化： 这里我对cur = cur.next产生了误解，将其看作类似引用类型的值传递问题，最后我在另一篇博文中找到了正确解释（图片引用地址：https://blog.csdn.net/qq_426...
链表
范fun的博客
03-04 3473
一、链表的类型 什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点是由两部分组成，一个是数据域，一个是指针域(存放指向下一个节点的指针)，最后一个节点的指针域指向NULL。 1、单链表 链表的入口点称为链表的头节点，也就是head。 如图所示： 2、双向链表 单链表中的节点只能指向节点的下一个节点。 双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。 双链表 既可以向前查询也可以向后查询 3、循环链表 循环链表，顾名思义，就是链表首尾相连。 .
【Leetcode学习笔记】链表
weixin_42685184的博客
03-20 338
【Leetcode学习笔记】链表
面试题总结：数组和链表的区别 数组和链表.pdf
04-18
面试题总结：数组和链表的区别 数组和链表.pdf
链表题目总结1
08-03
1. 剑指offer 22.返回倒数第k个节点：林伟龙 【20:15-20:34】法思路1. 遍历第次链表计算链表度2. 遍历第次链表找到 第 k 个 元素法
实验二：链表的基本操作的实验报告
12-04
源代码： #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define flag 0 typedef int ElemType; typedef struct linkList { ElemType data;...void init_LinkList(LinkList *head)
php数组和链表的区别总结
10-16
在本篇文章里小编给大家整理的是关于php数组和链表的区别的相关知识点内容，有需要的朋友们可以学习下。
c语言链表总结
03-15
链表是学习数据结构的大门，在微软等大公司招聘c\c++技术人员的时候有3个会必然出现 的东西，指针、链表、二叉树！
数据结构和算法之链表
就是这个七昂的博客
03-08 399
链表知识点： 1）通过指针将内存块串联起来，内存块为链表的节点，每一个节点除了存储的数据还有一个指向下一个节点的next指针。如果是双向链表的话，在节点处除了next指针还有前向指针。 2）搜索链表时间复杂度是O(n)，不能以索引的方式读取节点值。 3）链表的优势在于可以很高的效率在任意位置插入和删除一个节点。 4）单向链表每一个节点包括一个值和一个指向下一个节点的指针。尾节点的next指...
leetcode 707 设计链表
sjc7140的博客
10-16 159
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。...
【数据结构】链表
qq_42814021的博客
03-01 460
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，数据域及指针域。链表的入口节点称为链表的头节点，也就是head。链表在内存中不是连续分布的，它通过指针域的指针链接在内存中的各个节点。
算法学习之链表篇
continue_gdufe的博客
09-09 249
算法学习之链表篇前言一、链表设计大师二、小试牛刀1.反转链表2.总结 前言 这是算法学习链表篇的第二篇Blog，由于个人的懒癌+开学琐事，所以拖延了超级久才发布第二篇学习博客，学习是一个持续、长久的过程，希望以后自己能战胜拖延hhh，话不多说，我们继续深究链表，深入学习叭~ 本博客参考了代码随想录，特此声明 一、链表设计大师 我们在链表操作时往往会使用他人写好的函数，我们直接调用即可，这样操作固然方便，但是这不利于我们理解、学习链表，所以，我们不妨来写5个常见的链表操作，你准备成为大师了么？ Le
链表题目--1 删除链表中所有等于val的值
LXY的博客
10-03 660
注意事项 要删除的结点相邻 第一个结点就是要删除的结点 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode* removeElements(struct ListNode...
LeetCode 链表相关 //重新理解
xinkuIe
11-27 455
1. 剑指 Offer 24 反转链表 927 74.3% 简单 之前用python做过了，但理解的不透彻，重新用JS再做一下。 个人理解： 首先，node.next 相当于链表结构中的左←右→箭头指向(正常就是→)， 其次，如果定义了一个指针如 let cur= head（指向一个链表，相当于头结点），那么再声明一个指针let pre= cur，并不是说pre指向cur，而是指向cur指向的值，也就是说两者都指向head，而不是指针的指针 下...
链表面试题------Java 删除链表中值为 val 的元素
H_Q_Li的博客
08-23 1148
1.题目描述： 删除链表中值为 val 的元素 思路： 1. 遍历原链表，如果与val值相等，则删除 特殊情况：链表为空时，怎么办 第一个节点head的值，如果等于val,怎么办 2. 需要两个指针，一个 cur 遍历整个链表 一个为 perv 记录 遍历的cur 的 前一个节点(如果遇到需要删除的结点， 需要知道此节点的前一个节点，所以需要prev) //定义...
链表的常用操作
wokaoshenmogui的博客
08-21 2466
以下皆为LeetCode上的题 删除链表中等于给定值 val 的所有节点 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Sol...
【数据结构】单链表（基础）
此地无银
10-30 382
学习记录，若有不足请指出来
C语言链表基础知识总结
最新发布
06-02
- 遍历链表： ```c void traverseList(struct Node* head) { struct Node* p = head->next; while (p != NULL) { printf("%d ", p->data); p = p->next; } printf("\n"); } ``` - 销毁链表： ```c void ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

发呆的百香果子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值