Java实现单向链表

最新推荐文章于 2022-05-06 19:40:56 发布
最新推荐文章于 2022-05-06 19:40:56 发布
阅读量598 收藏 2
点赞数 1
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Java_3y/article/details/98866940 
 
 
一、前言
 
 
最近在回顾数据结构与算法，有部分的算法题用到了栈的思想，说起栈又不得不说链表了。数组和链表都是线性存储结构的基础，栈和队列都是线性存储结构的应用～
 
 
本文主要讲解单链表的基础知识点，做一个简单的入门～如果有错的地方请指正
 
 
二、回顾与知新
 
 
说起链表，我们先提一下数组吧，跟数组比较一下就很理解链表这种存储结构了。
 
 
2.1回顾数组 
 
 
数组我们无论是C、Java都会学过：
 
 
 
  640?wx_fmt=jpeg 
  
 
 
 
 
数组的优点：
 
 
数组的缺点：
 
 
2.2链表说明 
 
 
看完了数组，回到我们的链表：
 
 
 
  
n个节点离散分配，彼此通过指针相连，每个节点只有一个前驱节点，每个节点只有一个后续节点，首节点没有前驱节点，尾节点没有后续节点。
 
 
 
 
 
  640?wx_fmt=png 
  
 
 
 
 
链表优点：
 
 
链表缺点：
 
 
链表相关术语介绍，我还是通过上面那个图来说明吧：
 
 
 
  640?wx_fmt=png 
  
 
 
 
 
确定一个链表我们只需要头指针，通过头指针就可以把整个链表都能推导出来了～
 
 
链表又分了好几类：
 
 
操作链表要时刻记住的是：
 
 
三、Java实现链表
 
 
算法：
 
 
首先，我们定义一个类作为节点
 
 
为了操作方便我就直接定义成public了。
 
 
public class Node {    //数据域    public int data;    //指针域，指向下一个节点    public Node next;    public Node() {    }    public Node(int data) {        this.data = data;    }    public Node(int data, Node next) {        this.data = data;        this.next = next;    }}class Node {

    //数据域
    public int data;

    //指针域，指向下一个节点
    public Node next;

    public Node() {
    }

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

    public Node(int data, Node next) {
        this.data = data;
        this.next = next;
    }
}
 
 
3.1创建链表(增加节点) 
 
 
向链表中插入数据：
 
 
    /**     * 向链表添加数据     *     * @param value 要添加的数据     */    public static void addData(int value) {        //初始化要加入的节点        Node newNode = new Node(value);        //临时节点        Node temp = head;        // 找到尾节点        while (temp.next != null) {            temp = temp.next;        }        // 已经包括了头节点.next为null的情况了～        temp.next = newNode;    }
    public static void addData(int value) {

        //初始化要加入的节点
        Node newNode = new Node(value);

        //临时节点
        Node temp = head;

        // 找到尾节点
        while (temp.next != null) {
            temp = temp.next;
        }

        // 已经包括了头节点.next为null的情况了～
        temp.next = newNode;

    }
 
 
3.2遍历链表 
 
 
上面我们已经编写了增加方法，现在遍历一下看一下是否正确～～～
 
 
从首节点开始，不断往后面找，直到后面的节点没有数据：
 
 
    /**     * 遍历链表     *     * @param head 头节点     */    public static void traverse(Node head) {        //临时节点，从首节点开始        Node temp = head.next;        while (temp != null) {            System.out.println("关注公众号Java3y：" + temp.data);            //继续下一个            temp = temp.next;        }    }
    public static void traverse(Node head) {


        //临时节点，从首节点开始
        Node temp = head.next;

        while (temp != null) {

            System.out.println("关注公众号Java3y：" + temp.data);

            //继续下一个
            temp = temp.next;
        }
    }
 
 
结果：
 
 
 
  640?wx_fmt=png 
  
 
 
 
 
3.3插入节点 
 
 
  1. 插入一个节点到链表中，首先得判断这个位置是否是合法的，才能进行插入～
  2. 找到想要插入的位置的上一个节点就可以了～
 
 
    /**     * 插入节点     *     * @param head  头指针     * @param index 要插入的位置     * @param value 要插入的值     */    public static void insertNode(Node head, int index, int value) {        //首先需要判断指定位置是否合法，        if (index < 1 || index > linkListLength(head) + 1) {            System.out.println("插入位置不合法。");            return;        }        //临时节点，从头节点开始        Node temp = head;        //记录遍历的当前位置        int currentPos = 0;        //初始化要插入的节点        Node insertNode = new Node(value);        while (temp.next != null) {            //找到上一个节点的位置了            if ((index - 1) == currentPos) {                //temp表示的是上一个节点                //将原本由上一个节点的指向交由插入的节点来指向                insertNode.next = temp.next;                //将上一个节点的指针域指向要插入的节点                temp.next = insertNode;                return;            }            currentPos++;            temp = temp.next;        }    }
    public static void insertNode(Node head, int index, int value) {


        //首先需要判断指定位置是否合法，
        if (index < 1 || index > linkListLength(head) + 1) {
            System.out.println("插入位置不合法。");
            return;
        }

        //临时节点，从头节点开始
        Node temp = head;

        //记录遍历的当前位置
        int currentPos = 0;

        //初始化要插入的节点
        Node insertNode = new Node(value);

        while (temp.next != null) {

            //找到上一个节点的位置了
            if ((index - 1) == currentPos) {

                //temp表示的是上一个节点

                //将原本由上一个节点的指向交由插入的节点来指向
                insertNode.next = temp.next;

                //将上一个节点的指针域指向要插入的节点
                temp.next = insertNode;

                return;

            }

            currentPos++;
            temp = temp.next;
        }

    }
 
 
3.4获取链表的长度 
 
 
获取链表的长度就很简单了，遍历一下，每得到一个节点+1即可～
 
 
    /**     * 获取链表的长度     * @param head 头指针     */    public static int  linkListLength(Node head) {        int length = 0;        //临时节点，从首节点开始        Node temp = head.next;        // 找到尾节点        while (temp != null) {            length++;            temp = temp.next;        }        return length;    }
    public static int  linkListLength(Node head) {

        int length = 0;

        //临时节点，从首节点开始
        Node temp = head.next;

        // 找到尾节点
        while (temp != null) {
            length++;
            temp = temp.next;
        }

        return length;
    }
 
 
3.5删除节点 
 
 
删除某个位置上的节点其实是和插入节点很像的， 同样都要找到上一个节点。将上一个节点的指针域改变一下，就可以删除了～
 
 
    /**     * 根据位置删除节点     *     * @param head  头指针     * @param index 要删除的位置     */    public static void deleteNode(Node head, int index) {        //首先需要判断指定位置是否合法，        if (index < 1 || index > linkListLength(head) + 1) {            System.out.println("删除位置不合法。");            return;        }        //临时节点，从头节点开始        Node temp = head;        //记录遍历的当前位置        int currentPos = 0;        while (temp.next != null) {            //找到上一个节点的位置了            if ((index - 1) == currentPos) {                //temp表示的是上一个节点                //temp.next表示的是想要删除的节点                //将想要删除的节点存储一下                Node deleteNode = temp.next;                //想要删除节点的下一个节点交由上一个节点来控制                temp.next = deleteNode.next;                //Java会回收它，设置不设置为null应该没多大意义了(个人觉得,如果不对请指出哦～)                deleteNode = null;                return;            }            currentPos++;            temp = temp.next;        }    }
    public static void deleteNode(Node head, int index) {


        //首先需要判断指定位置是否合法，
        if (index < 1 || index > linkListLength(head) + 1) {
            System.out.println("删除位置不合法。");
            return;
        }

        //临时节点，从头节点开始
        Node temp = head;

        //记录遍历的当前位置
        int currentPos = 0;


        while (temp.next != null) {

            //找到上一个节点的位置了
            if ((index - 1) == currentPos) {

                //temp表示的是上一个节点

                //temp.next表示的是想要删除的节点

                //将想要删除的节点存储一下
                Node deleteNode = temp.next;

                //想要删除节点的下一个节点交由上一个节点来控制
                temp.next = deleteNode.next;


                //Java会回收它，设置不设置为null应该没多大意义了(个人觉得,如果不对请指出哦～)
                deleteNode = null;

                return;

            }
            currentPos++;
            temp = temp.next;
        }
    }
 
 
3.6对链表进行排序 
 
 
前面已经讲过了8种的排序算法了【八种排序算法总结】，这次挑简单的冒泡排序吧(其实我是想写快速排序的，尝试了一下感觉有点难…..)
 
 
    /**     * 对链表进行排序     *     * @param head     *     */    public static void sortLinkList(Node head) {        Node currentNode;        Node nextNode;        for (currentNode = head.next; currentNode.next != null; currentNode = currentNode.next) {            for (nextNode = head.next; nextNode.next != null; nextNode = nextNode.next) {                if (nextNode.data > nextNode.next.data) {                    int temp = nextNode.data;                    nextNode.data = nextNode.next.data;                    nextNode.next.data = temp;                }            }        }    }
    public static void sortLinkList(Node head) {


        Node currentNode;

        Node nextNode;

        for (currentNode = head.next; currentNode.next != null; currentNode = currentNode.next) {

            for (nextNode = head.next; nextNode.next != null; nextNode = nextNode.next) {


                if (nextNode.data > nextNode.next.data) {

                    int temp = nextNode.data;
                    nextNode.data = nextNode.next.data;

                    nextNode.next.data = temp;

                }
            }


        }
    }
 
 
3.7找到链表中倒数第k个节点 
 
 
这个算法挺有趣的：设置两个指针p1、p2，让p2比p1快k个节点，同时向后遍历，当p2为空，则p1为倒数第k个节点
 
 
    /**     * 找到链表中倒数第k个节点(设置两个指针p1、p2，让p2比p1快k个节点，同时向后遍历，当p2为空，则p1为倒数第k个节点     *     * @param head     * @param k    倒数第k个节点     */    public static Node findKNode(Node head, int k) {        if (k < 1 || k > linkListLength(head))            return null;        Node p1 = head;        Node p2 = head;        // p2比怕p1快k个节点        for (int i = 0; i < k - 1; i++)            p2 = p2.next;        // 只要p2为null，那么p1就是倒数第k个节点了        while (p2.next != null) {            p2 = p2.next;            p1 = p1.next;        }        return p1;    }
    public static Node findKNode(Node head, int k) {

        if (k < 1 || k > linkListLength(head))
            return null;
        Node p1 = head;
        Node p2 = head;

        // p2比怕p1快k个节点
        for (int i = 0; i < k - 1; i++)
            p2 = p2.next;


        // 只要p2为null，那么p1就是倒数第k个节点了
        while (p2.next != null) {

            p2 = p2.next;
            p1 = p1.next;
        }
        return p1;


    }
 
 
3.8删除链表重复数据 
 
 
跟冒泡排序差不多，只要它相等，就能删除了～
 
 
  /**     * 删除链表重复数据(跟冒泡差不多，等于删除就是了)     *     * @param head 头节点     */    public static void deleteDuplecate(Node head) {        //临时节点，(从首节点开始-->真正有数据的节点)        Node temp = head.next;        //当前节点(首节点)的下一个节点        Node nextNode = temp.next;        while (temp.next != null) {            while (nextNode.next != null) {                if (nextNode.next.data == nextNode.data) {                    //将下一个节点删除(当前节点指向下下个节点)                    nextNode.next = nextNode.next.next;                } else {                    //继续下一个                    nextNode = nextNode.next;                }            }            //下一轮比较            temp = temp.next;        }    }
    public static void deleteDuplecate(Node head) {

        //临时节点，(从首节点开始-->真正有数据的节点)
        Node temp = head.next;

        //当前节点(首节点)的下一个节点
        Node nextNode = temp.next;

        while (temp.next != null) {

            while (nextNode.next != null) {

                if (nextNode.next.data == nextNode.data) {

                    //将下一个节点删除(当前节点指向下下个节点)
                    nextNode.next = nextNode.next.next;

                } else {

                    //继续下一个
                    nextNode = nextNode.next;
                }
            }

            //下一轮比较
            temp = temp.next;
        }


    }
 
 
3.9查询链表的中间节点 
 
 
这个算法也挺有趣的：一个每次走1步，一个每次走两步，走两步的遍历完，然后走一步的指针，那就是中间节点
 
 
    /**     * 查询单链表的中间节点     */    public static Node searchMid(Node head) {        Node p1 = head;        Node p2 = head;        // 一个走一步，一个走两步，直到为null，走一步的到达的就是中间节点        while (p2 != null && p2.next != null && p2.next.next != null) {            p1 = p1.next;            p2 = p2.next.next;        }        return p1;    }

    public static Node searchMid(Node head) {

        Node p1 = head;
        Node p2 = head;


        // 一个走一步，一个走两步，直到为null，走一步的到达的就是中间节点
        while (p2 != null && p2.next != null && p2.next.next != null) {

            p1 = p1.next;
            p2 = p2.next.next;

        }

        return p1;


    }
 
 
3.10通过递归从尾到头输出单链表 
 
 
    /**     * 通过递归从尾到头输出单链表     *     * @param head 头节点     */    public  static  void printListReversely(Node head) {        if (head != null) {            printListReversely(head.next);            System.out.println(head.data);        }    }
    public  static  void printListReversely(Node head) {
        if (head != null) {
            printListReversely(head.next);
            System.out.println(head.data);
        }
    }
 
 
3.11反转链表 
 
 
    /**     * 实现链表的反转     *     * @param node 链表的头节点     */    public static Node reverseLinkList(Node node) {        Node prev ;        if (node == null || node.next == null) {            prev = node;        } else {            Node tmp = reverseLinkList(node.next);            node.next.next = node;            node.next = null;            prev = tmp;        }        return prev;    }
    public static Node reverseLinkList(Node node) {

        Node prev ;
        if (node == null || node.next == null) {
            prev = node;
        } else {
            Node tmp = reverseLinkList(node.next);
            node.next.next = node;
            node.next = null;
            prev = tmp;
        }
        return prev;

    }
 
 
 
  640?wx_fmt=png 
  
 
 
 
 
反转链表参考自：
 
 
四、最后
 
 
 
  
理解链表本身并不难，但做相关的操作就弄得头疼，head.next  next next next ....(算法这方面我还是薄弱啊..脑子不够用了…..)写了两天就写了这么点东西…
 
 
 
 
操作一个链表只需要知道它的头指针就可以做任何操作了
 
 
PS：每个人的实现都会不一样，所以一些小细节难免会有些变动，也没有固定的写法，能够实现功能即可～
 
 
参考资料：
 
 
 
  
如果文章有错的地方欢迎指正，大家互相交流。习惯在微信看技术文章，想要获取更多的Java资源的同学，可以关注微信公众号:Java3y
 
 
 
 

 


                

        

    

  



    

      

        

            

              
                
                  Java3y
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
用Java实现单向链表

				
			

			

				

					Veir的专栏
				

				

					03-16
					
					679
					
				

			

		

		

			
				
用Java实现单向链表说明
  
  实现的链表为最简单的单向链表，只作为复习链表的知识
  链表的存储的数据为String类型，同时也可以修改为其它类型或自定义类型，但是自定义要实现 compare()方法，用来链表实现类里面的比较用。
  代码参考自李兴华老师的Java视频，结构使用内部类的方式来实现，
  链表实现的方法主要有：增、删、查、获取链表元素个数、将链表转为数组、对链表的一些判断

			
		

	



                

            
              



	

		

			

				
					
Java实现单向链表——精简

				
			

			

				

					m0_59340907的博客
				

				

					05-31
					
					1654
					
				

			

		

		

			
				
文章目录

引言

实现思路

添加元素

插入元素

删除元素

查找元素

更新元素

显示链表

实现代码（完整）

总结



引言

   链表是一种重要的数据结构。它的存储空间是不连续的，单向链表是最简单的一种链表。本文主要介绍单向链表，及其“增删改查”等功能的实现。我们希望设计出来的链表不仅仅只能存储一种类型的数据。而是可以像ArrayList集合那样，存储任意类型的数据，因此设计的时候要结合泛型。

实现思路

   链表是由一个个的节点链接起来的，这里介绍.........

			
		

	



              


  
              

                


	

		

			

				
					
java实现链表

				
			

			

				

					09-24
				

			

		

		

			
				
链表是一种物理存储单元上非连续、非顺序的存储结构。
java代码实现单链表，插入，删除和遍历等功能。
链表能够灵活的进行插入和删除操作，时间复杂度为O（1）,链表的查找时间复杂度为O（n）。

			
		

	





	

		

			

				
					
Java实现单向链表反转

				
			

			

				

					08-27
				

			

		

		

			
				
Java实现单向链表反转  Java实现单向链表反转是指将单向链表的顺序颠倒，例如原链表为A->B->C->D->E->F，反转后变为F->E->D->C->B->A。这种操作在实际开发中非常有用，例如在数据处理、数据分析等领域。  单向链表...

			
		

	



		

			
		



	

		

			

				
					
Java实现单向链表的基本功能详解

				
			

			

				

					08-27
				

			

		

		

			
				
主要给大家介绍了关于Java实现单向链表基本功能的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧。

			
		

	





	

		

			

				
					
Java实现单向链表反转示例

				
			

			

				

					技术小青年一枚
				

				

					02-15
					
					2839
					
				

			

		

		

			
				
例如有一单向链表
54-&gt;30-&gt;37-&gt;61-&gt;1-&gt;60-&gt;25-&gt;76-&gt;60-&gt;95
原链表头节点54，尾节点：95
实现效果：
95-&gt;60-&gt;76-&gt;25-&gt;60-&gt;1-&gt;61-&gt;37-&gt;30-&gt;54
新链表头节点95，尾节点54
实现原理：
从头

			
		

	





	

		

			

				
					
java实现一个单向链表

				
			

			

				

					牧xin的博客
				

				

					02-02
					
					449
					
				

			

		

		

			
				
简单介绍下单向链表

单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点；


链表是由结点构成，head指针指向第一个成为表头结点，而终止于最后一个指向NULL的指针。

单向链表和双向链表简单对比下
jdk(目前所用8)中的LinkedList是用双向链表实现的
下图中,有头节点,尾结点,链表长度

其节点代码:
priva

			
		

	





	

		

			

				
					
java实现单向链表

				
			

			

				

					西凉的悲伤博客
				

				

					05-06
					
					1244
					
				

			

		

		

			
				
目录单向链表示意图：单向链表实现代码：测试：结果：
单向链表示意图：

以下是单链表相对于双链表的优缺点。
优点
（1) 只有一个指向下一个节点的指针。
（2) 单向链表增加删除节点简单。遍历时候不会死循环。
缺点
（1) 只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。
单向链表实现代码：

import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;
import j

			
		

	





	

		

			

				
					
java 单向链表

				
			

			

				

					geili_178的专栏
				

				

					10-01
					
					307
					
				

			

		

		

			
				
java 单向链表


分类： Java2012-12-22
 16:53 120人阅读 评论(0) 收藏 举报


简单单向链表





[java] view
 plaincopyprint?






class Node{  
    private String data; //存储当前节点内容  
    private Node   

			
		

	





	

		

			

				
					
JAVA实现链表

				
			

			

				

					
				

				

					08-08
					
					2166
					
				

			

		

		

			
				
链表是一种十分重要的数据结构结构，在程序设计中有很重要的地位。在C和C＋＋中链表都是用指针实现的，但是为了内存安全，JAVA不再提供指针，因而有的读者认为JAVA无法实现链表，其实相反，我们只需简单地定义一个节点类“Node”即可轻松实现，接下来看代码（一共有三个类：MyList接口类、MyLinkedList功能类、MyAbstractList抽象类）：MyList接口类：pac

			
		

	





	

		

			

				
					
Java 实现链表

				
			

			

				

					gannyee
				

				

					06-12
					
					1779
					
				

			

		

		

			
				
链表相比数组操作更灵活，在空间效率方面比数组更有优势，虽然java中没有指针，但可以通过自定义类建立链表模型，进而实现链表。 
分享下自己用java实现链表的过程： 
java代码： 
Node 类：package com.list.stack;/**
 * Setup Node class 
 * @author gannyee
 *
 */
public class Node {
    //D

			
		

	





	

		

			

				
					
Java实现单向链表：基础、优缺点与操作方法

				
			

			

				

					
				

			

		

		

			
				
本文主要介绍了如何使用Java实现单向链表的基本功能，包括链表的原理、优缺点以及相关的操作，如遍历、查找、清空、销毁、求长度、排序、删除节点和插入节点。  一、单向链表概念 单向链表是一种线性数据结构，其...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值