Java实现无头单向非循环链表

最新推荐文章于 2020-11-03 01:07:08 发布
最新推荐文章于 2020-11-03 01:07:08 发布
阅读量116 收藏
点赞数
分类专栏： JavaSE 文章标签： java 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46660141/article/details/107648038
版权

创建空的成员变量并用构造函数初始化

class Node {
    public int data;
    public Node next;

    public Node(int data) {
        this.data = data;
    }
}

遍历链表

public class MyLinkLest {
    public Node head;//标识头节点

    //遍历链表
    public void display() {
        Node cur = this.head;
        while (cur != null) {
            System.out.print(cur.data + " ");
            cur = cur.next;
        }
        System.out.println();
    }

头插法

    //头插法
    public void addFirst(int data) {
        Node node = new Node(data);
        node.next = this.head;
        this.head = node;
    }

尾插法

   //尾插法
    public void addLast(int data) {
        //0、判断当前列表是否是第一次插入
        //1、找尾巴，cur.next == null
        Node node = new Node(data);
        if (this.head == null) {
            this.head = node;
        } else {
            Node cur = this.head;
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }

在任意位置插入，第一个数据节点为0号下表

   public boolean checkIndex(int index) {
        if (index < 0 || index > getLength()) {
            System.out.println("下标不合法");
            return false;
        }
        return true;
    }

    //在任意位置插入，第一个数据节点为0号下表
    public void addIndex(int index, int data) {
        if(!checkIndex(index)) {
            return;
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == this.getLength()) {
            addLast(data);
            return;
        }
        Node cur = searchPrev(index);
        //cur此时保存的就是index-1位置的节点的引用
        Node node = new Node(data);
        node.next = cur.next;
        cur.next = node;
    }

    public Node searchPrev(int index) {
        Node cur = this.head;
        int count = 0;
        while (count < index -1 ) {
            cur = cur.next;
            count++;
        }
        return cur;
    }

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

删除第一次出现关键字为key节点

    public Node searchPrevNode (int key) {
        Node cur = this.head;
        if(cur.next != null) {
            if(cur.next.data == key){
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }
    //删除第一次出现关键字为key节点
    public void remove(int key) {
        if(this.head == null)
            return;
        //头节点是删除的节点
        if(this.head.data == key) {
            this.head = this.head.next;
            return;
        }
        Node cur =searchPrevNode(key);
        if(cur == null) {
            System.out.println("没有你要删除的数字");
            return;
        }
        Node del = cur.next;//删除的节点
        cur.next = del.next;
    }

删除所有值为key的节点

   public void removeAllkey(int key) {
        Node cur = new Node(key);
        cur.next = head;
        while(cur.next != null) {
            if (cur.next.data == key) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
    }

查找是否包含关键字key

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

测试代码

public class Test {
    public static void main(String[] args) {
        MyLinkLest  myLinkLest = new  MyLinkLest();
        myLinkLest.addFirst(1);
        myLinkLest.addFirst(2);
        myLinkLest.addFirst(3);
        myLinkLest.addFirst(2);
        myLinkLest.display();
        myLinkLest.addLast(1);
        myLinkLest.addLast(2);
        myLinkLest.addLast(3);
        myLinkLest.display();
        myLinkLest.addIndex(0,1);
        myLinkLest.addIndex(1,2);
        myLinkLest.addIndex(0,3);
        myLinkLest.display();
        myLinkLest.remove(1);
        myLinkLest.display();
        System.out.println(myLinkLest.contains(3));
        myLinkLest.removeAllkey(2);
        myLinkLest.display();
    }
}

完整代码

/**
 * @Author 袁媛
 * @Date 2020/7/28
 * @Time 10:04
 */
class Node {
    public int data;
    public Node next;

    public Node(int data) {
        this.data = data;
    }
}

public class MyLinkLest {
    public Node head;//标识头节点

    //遍历链表
    public void display() {
        Node cur = this.head;
        while (cur != null) {
            System.out.print(cur.data + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    //头插法
    public void addFirst(int data) {
        Node node = new Node(data);
        node.next = this.head;
        this.head = node;
    }

    //尾插法
    public void addLast(int data) {
        //0、判断当前列表是否是第一次插入
        //1、找尾巴，cur.next == null
        Node node = new Node(data);
        if (this.head == null) {
            this.head = node;
        } else {
            Node cur = this.head;
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }

    public boolean checkIndex(int index) {
        if (index < 0 || index > getLength()) {
            System.out.println("下标不合法");
            return false;
        }
        return true;
    }

    //在任意位置插入，第一个数据节点为0号下表
    public void addIndex(int index, int data) {
        if(!checkIndex(index)) {
            return;
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == this.getLength()) {
            addLast(data);
            return;
        }
        Node cur = searchPrev(index);
        //cur此时保存的就是index-1位置的节点的引用
        Node node = new Node(data);
        node.next = cur.next;
        cur.next = node;
    }

    public Node searchPrev(int index) {
        Node cur = this.head;
        int count = 0;
        while (count < index -1 ) {
            cur = cur.next;
            count++;
        }
        return cur;
    }

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

    public Node searchPrevNode (int key) {
        Node cur = this.head;
        if(cur.next != null) {
            if(cur.next.data == key){
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }
    //删除第一次出现关键字为key节点
    public void remove(int key) {
        if(this.head == null)
            return;
        //头节点是删除的节点
        if(this.head.data == key) {
            this.head = this.head.next;
            return;
        }
        Node cur =searchPrevNode(key);
        if(cur == null) {
            System.out.println("没有你要删除的数字");
            return;
        }
        Node del = cur.next;//删除的节点
        cur.next = del.next;
    }

    //删除所有值为key的节点
    public void removeAllkey(int key) {
        Node cur = new Node(key);
        cur.next = head;
        while(cur.next != null) {
            if (cur.next.data == key) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
    }

    //查找是否包含关键字key
    public boolean contains(int key) {
       Node cur = this.head;
       while( cur != null) {
           if (cur.data == key) {
               return true;
           }
          cur = cur.next;
       }
       return false;
    }
}
public class Test {
    public static void main(String[] args) {
        MyLinkLest  myLinkLest = new  MyLinkLest();
        myLinkLest.addFirst(1);
        myLinkLest.addFirst(2);
        myLinkLest.addFirst(3);
        myLinkLest.addFirst(2);
        myLinkLest.display();
        myLinkLest.addLast(1);
        myLinkLest.addLast(2);
        myLinkLest.addLast(3);
        myLinkLest.display();
        myLinkLest.addIndex(0,1);
        myLinkLest.addIndex(1,2);
        myLinkLest.addIndex(0,3);
        myLinkLest.display();
        myLinkLest.remove(1);
        myLinkLest.display();
        System.out.println(myLinkLest.contains(3));
        myLinkLest.removeAllkey(2);
        myLinkLest.display();
    }
}
小猪媛不圆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LinkedList集合的常用方法及底层解析
weixin_52450674的博客
04-05 412
LinkedList集合的常用方法及底层解析 文章目录LinkedList集合的常用方法及底层解析前言一、常用方法二、构造方法无参构造含参构造三、add方法linkLast(e);四、get方法node(index)方法五、 remove方法索引删除节点按元素删除这个节点总结 前言 LinkedList集合属于线性链表结构（双向链表） 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的 优缺点 优点：删除和插入效率高 缺点：查询效率低 注意：
LinkList.add()源码详解
民义叔
08-22 977
/** * Links e as last element. */ void linkLast(E e) { final Node l = last; final Node newNode = new Node&amp;lt;&amp;gt;(l, e, null); last = newNode; if...
【数据结构】树的基本认识
Jacky_Feng的博客
09-06 1333
文章目录 前言 一、树的定义及基本术语 1.树的定义 2.基本术语 3.树的性质 二、树的表示（存储结构） 前言 树形结构是一类重要的非线性结构。树形结构是结点之间有分支，并且具有层次关系的结构，类似于大自然中的树。 一、树的定义及基本术语 1.树的定义 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因 为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： ①每个结点有零个或多个子结点；（每个结点有.
Java集合---LinkedList源码解析
weixin_34166847的博客
09-01 867
  一、源码解析1、 LinkedList类定义2、LinkedList数据结构原理3、私有属性4、构造方法5、元素添加add()及原理6、删除数据remove()7、数据获取get()8、数据复制clone()与toArray()9、遍历数据：Iterator()二、ListItr     一、源码解析     1、 LinkedList类定义。   public class ...
Java无头单向链表
qq_45349785的博客
09-28 146
链表： 是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： 单向、双向 带头、不带头 循环、非循环 对这六种排列组合即可得到八种链表的名称； 我们今天实现的是 无头单向链表 ```java // 1、无头单向非循环链表实现 public class SingleLinkedList { ...
java实现的带头单向循环链表
family_love_1998的博客
05-10 427
package com.bit; public interface CLinkList { //头插法 void addFirst(int data); //尾插法 void addLast(int data); //任意位置插入,第一个数据节点为0号下标 boolean addIndex(int index,int data); ...
java实现无头单向链表
qq_44791951的博客
09-26 200
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： 单向、带头、循环 双向 、不带头 、非循环 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈 希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。 相关方法代码实现： package L...
Python实现-无头单向非循环链表
12-22
无头单向非循环链表链表 无头单向非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等 无头单向非循环链表 对于任意一个数据元素a(i)来说，储存本身的...
Java之单链表篇！！！ （无头单向非循环链表实现打印、头插、尾插、任意插入、查找、删除某一关键字、删除所有所选关键字、清空单链表等基本操作）
12-21
首先对单链表的结构进行介绍，单链表是由很多个节点一个接一个串接起来的，每个节点包含两部分，数据部分和地址部分，我们这里讲的是无头的单链表，所以没有头节点，每个节点存储的是本身的数据和下一个节点的地址。...
Java实现单向链表反转
08-27
Java实现单向链表反转 Java实现单向链表反转是指将单向链表的顺序颠倒，例如原链表为A->B->C->D->E->F，反转后变为F->E->D->C->B->A。这种操作在实际开发中非常有用，例如在数据处理、数据分析等领域。 单向链表...
Java SE程序 类实现单向链表
01-21
Java SE程序 类实现单向链表Java SE程序 类实现单向链表Java SE程序 类实现单向链表Java SE程序 类实现单向链表Java SE程序 类实现单向链表Java SE程序 类实现单向链表Java SE程序 类实现单向链表Java SE程序 类实现...
给定一个十进制整数，如何转换成二进制形式？如何转换成十六进制形式？
weixin_46660141的博客
07-16 1161
转换成二进制 简单的来说就是，整数部分除二取余，小数部分乘二取整。 比如转换10.25为二进制： 首先看整数部分： 10/2=5余数是0； 5/2=2余数是1； 2/2=1（整商）余数是0. 取最后的整商，然后余数倒着数回去，即1010 再看小数部分： 0.252=0.5（整数部分是0） 0.52=1（整数部分是1）。 则小数部分的二进制为01，整数部分和小数部分合起来就是1010.01，转换成功。 转换成十六进制 有了上面二进制的转换，转换成16进制就更简单了，以小数点为界，整数部分向左数，每四位.
方法的使用
weixin_46660141的博客
11-03 952
1.方法的基本用法 1.1什么是方法 1.2方法定义语句 1.3方法调用的执行过程 1.4实参和形参的关系（重要） 1.5没有返回值的方法 2.方法的重载 2.1重载要解决的问题 2.2使用重载 2.3重载的规则 3.方法的递归 3.1递归的概念 3.2递归执行过程的分析 3.3递归练习 3.4递归小结 1.方法的基本用法 1.1什么是方法 方法就是一个代码片段. 类似于 C 语言中的 “函数”. 方法存在的意义(不要背, 重在体会): 是能够模块化的组织代码(当代码规模比较复杂的时候). 做到代码被重
数组拷贝的四种方式
weixin_46660141的博客
07-23 766
第一种方式也是最常见的方式：for循环 public class Test { public static void main(String[] args) { int[] arr = {1,2,3,4}; int[] newarr = copyOf(arr); System.out.println(Arrays.toString(newarr)); } public static int[] copyOf(int[] arr) {.
Java经典面试题之删除链表中等于给定值 val 的所有节点
weixin_46660141的博客
07-29 559
题目描述都是这样的~ 删除链表中等于给定值 val 的所有节点。 示例: 输入: 1->2->6->3->4->5->6, val = 6 输出: 1->2->3->4->5 要很好的完成这个题，首先我们考虑时间复杂度为O(n),空间复杂度为O(1),这才是面试官想看到的，也是我们要努力做到的。 我先简单的画了个图： val表示链表中的值，一般习惯用data表示，但是由于咱们这个题目中给定了val，就用这个看着更方便一些；next表示地址的引用；h
Java经典面试题之反转一个单链表
weixin_46660141的博客
07-30 244
示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 先上代码！ /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution {
Java经典面试题之输入一个链表，输出该链表中倒数第k个节点。
weixin_46660141的博客
07-30 206
/* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Solution { public ListNode FindKthToTail(ListNode head,int k){ ListNode first = head; ListNode las
面向对象编程（Java）
weixin_46660141的博客
08-03 169
包 继承 多态 抽象类 接口 Java本身就是面向对象编程的一门语言，这一块我们主要需要注意的就是包、继承、组合、多态、抽象类和接口。 包 包是组织类的一种方式，使用包的主要目的是保证类的唯一性。 import java.util.*表示导入包下的所有类，虽然导入包下的所有类，但是不会将所有类加载。 对于import来说，不需要导入java.lang包（如String）,因为编译器会自动帮忙导入。 将类放入包中的时候，包名需要尽量指定成唯一的名字，通常会用公司的域名的颠倒形式。 继承 例如：Bird是A
Java实现无头双向链表
weixin_46660141的博客
08-02 154
创建空的成员变量并用构造函数初始化 class ListNode { public int data; public ListNode next;//节点引用 public ListNode prev;//节点前驱 public ListNode(int data) { this.data = data; } } 头节点和尾结点 public class DoubleLinkedList { public ListNode head.
无头结点的循环链表如何判断完成遍历
最新发布
05-22
因此，对于无头结点的循环链表，我们需要记录一个起始节点，以便在遍历时判断是否已经回到了起始节点。 具体来说，可以使用一个指针指向起始节点，然后依次访问每个节点，直到回到起始节点为止。代码实现如下： ``...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值