一、概述:

  本文主要总结单链表常见操作的实现,包括链表结点添加、删除;链表正向遍历和反向遍历、链表排序、判断链表是否有环、是否相交、获取某一结点等。

二、概念:

链表:

  一种重要的数据结构,HashMap等集合的底层结构都是链表结构。链表以结点作为存储单元,这些存储单元可以是不连续的。每个结点由两部分组成:存储的数值+前序结点和后序结点的指针。即有前序结点的指针又有后序结点的指针的链表称为双向链表,只包含后续指针的链表为单链表,本文总结的均为单链表的操作。

单链表结构:

Java中单链表采用Node实体类类标识,其中data为存储的数据,next为下一个节点的指针:

package com.algorithm.link;
/**
* 链表结点的实体类
* @author bjh
*
*/
public class Node {
Node next = null;//下一个结点
int data;//结点数据
public Node(int data){
this.data = data;
}
}

三、链表常见操作:

package com.algorithm.link;

import java.util.Hashtable;
/**
* 单链表常见算法
* @author bjh
*
*/
public class MyLinkedList { /**链表的头结点*/
Node head = null; /**
* 链表添加结点:
* 找到链表的末尾结点,把新添加的数据作为末尾结点的后续结点
* @param data
*/
public void addNode(int data){
Node newNode = new Node(data);
if(head == null){
head = newNode;
return;
}
Node temp = head;
while(temp.next != null){
temp = temp.next;
}
temp.next = newNode;
} /**
* 链表删除结点:
* 把要删除结点的前结点指向要删除结点的后结点,即直接跳过待删除结点
* @param index
* @return
*/
public boolean deleteNode(int index){
if(index<1 || index>length()){//待删除结点不存在
return false;
}
if(index == 1){//删除头结点
head = head.next;
return true;
}
Node preNode = head;
Node curNode = preNode.next;
int i = 1;
while(curNode != null){
if(i==index){//寻找到待删除结点
preNode.next = curNode.next;//待删除结点的前结点指向待删除结点的后结点
return true;
}
//当先结点和前结点同时向后移
preNode = preNode.next;
curNode = curNode.next;
i++;
}
return true;
} /**
* 求链表的长度
* @return
*/
public int length(){
int length = 0;
Node curNode = head;
while(curNode != null){
length++;
curNode = curNode.next;
}
return length;
} /**
* 链表结点排序,并返回排序后的头结点:
* 选择排序算法,即每次都选出未排序结点中最小的结点,与第一个未排序结点交换
* @return
*/
public Node linkSort(){
Node curNode = head;
while(curNode != null){
Node nextNode = curNode.next;
while(nextNode != null){
if(curNode.data > nextNode.data){
int temp = curNode.data;
curNode.data = nextNode.data;
nextNode.data = temp;
}
nextNode = nextNode.next;
}
curNode = curNode.next;
}
return head;
} /**
* 打印结点
*/
public void printLink(){
Node curNode = head;
while(curNode !=null){
System.out.print(curNode.data+" ");
curNode = curNode.next;
}
System.out.println();
} /**
* 去掉重复元素:
* 需要额外的存储空间hashtable,调用hashtable.containsKey()来判断重复结点
*/
public void distinctLink(){
Node temp = head;
Node pre = null;
Hashtable<Integer, Integer> hb = new Hashtable<Integer, Integer>();
while(temp != null){
if(hb.containsKey(temp.data)){//如果hashtable中已存在该结点,则跳过该结点
pre.next = temp.next;
}else{//如果hashtable中不存在该结点,将结点存到hashtable中
hb.put(temp.data, 1);
pre=temp;
}
temp = temp.next;
}
} /**
* 返回倒数第k个结点,
* 两个指针,第一个指针向前移动k-1次,之后两个指针共同前进,
* 当前面的指针到达末尾时,后面的指针所在的位置就是倒数第k个位置
* @param k
* @return
*/
public Node findReverNode(int k){
if(k<1 || k>length()){//第k个结点不存在
return null;
}
Node first = head;
Node second = head;
for(int i=0; i<k-1; i++){//前移k-1步
first = first.next;
}
while(first.next != null){
first = first.next;
second = second.next;
}
return second;
} /**
* 查找正数第k个元素
*/
public Node findNode(int k){
if(k<1 || k>length()){//不合法的k
return null;
}
Node temp = head;
for(int i = 0; i<k-1; i++){
temp = temp.next;
}
return temp;
} /**
* 反转链表,在反转指针钱一定要保存下个结点的指针
*/
public void reserveLink(){
Node curNode = head;//头结点
Node preNode = null;//前一个结点
while(curNode != null){
Node nextNode = curNode.next;//保留下一个结点
curNode.next = preNode;//指针反转
preNode = curNode;//前结点后移
curNode = nextNode;//当前结点后移
}
head = preNode;
} /**
* 反向输出链表,三种方式:
* 方法一、先反转链表,再输出链表,需要链表遍历两次
* 方法二、把链表中的数字放入栈中再输出,需要维护额外的栈空间
* 方法三、依据方法2中栈的思想,通过递归来实现,递归起始就是将先执行的数据压入栈中,再一次出栈
*/
public void reservePrt(Node node){
if(node != null){
reservePrt(node.next);
System.out.print(node.data+" ");
}
} /**
* 寻找单链表的中间结点:
* 方法一、先求出链表的长度,再遍历1/2链表长度,寻找出链表的中间结点
* 方法二、:
* 用两个指针遍历链表,一个快指针、一个慢指针,
* 快指针每次向前移动2个结点,慢指针一次向前移动一个结点,
* 当快指针移动到链表的末尾,慢指针所在的位置即为中间结点所在的位置
*/
public Node findMiddleNode(){
Node slowPoint = head;
Node quickPoint = head;
//quickPoint.next == null是链表结点个数为奇数时,快指针已经走到最后了
//quickPoint.next.next == null是链表结点数为偶数时,快指针已经走到倒数第二个结点了
//链表结点个数为奇数时,返回的是中间结点;链表结点个数为偶数时,返回的是中间两个结点中的前一个
while(quickPoint.next != null && quickPoint.next.next != null){
slowPoint = slowPoint.next;
quickPoint = quickPoint.next.next;
}
return slowPoint;
} /**
* 判断链表是否有环:
* 设置快指针和慢指针,慢指针每次走一步,快指针每次走两步
* 当快指针与慢指针相等时,就说明该链表有环
*/
public boolean isRinged(){
if(head == null){
return false;
}
Node slow = head;
Node fast = head;
while(fast.next != null && fast.next.next != null){
slow = slow.next;
fast = fast.next.next;
if(fast == slow){
return true;
}
}
return false;
} /**
* 返回链表的最后一个结点
*/
public Node getLastNode(){
Node temp = head;
while(temp.next != null){
temp = temp.next;
}
return temp;
} /**
* 在不知道头结点的情况下删除指定结点:
* 删除结点的重点在于找出其前结点,使其前结点的指针指向其后结点,即跳过待删除结点
* 1、如果待删除的结点是尾结点,由于单链表不知道其前结点,没有办法删除
* 2、如果删除的结点不是尾结点,则将其该结点的值与下一结点交换,然后该结点的指针指向下一结点的后续结点
*/
public boolean deleteSpecialNode(Node n){
if(n.next == null){
return false;
}else{
//交换结点和其后续结点中的数据
int temp = n.data;
n.data = n.next.data;
n.next.data = temp;
//删除后续结点
n.next = n.next.next;
return true;
}
} /**
* 判断两个链表是否相交:
* 两个链表相交,则它们的尾结点一定相同,比较两个链表的尾结点是否相同即可
*/
public boolean isCross(Node head1, Node head2){
Node temp1 = head1;
Node temp2 = head2;
while(temp1.next != null){
temp1 = temp1.next;
}
while(temp2.next != null){
temp2 = temp2.next;
}
if(temp1 == temp2){
return true;
}
return false;
} /**
* 如果链表相交,求链表相交的起始点:
* 1、首先判断链表是否相交,如果两个链表不相交,则求相交起点没有意义
* 2、求出两个链表长度之差:len=length1-length2
* 3、让较长的链表先走len步
* 4、然后两个链表同步向前移动,没移动一次就比较它们的结点是否相等,第一个相等的结点即为它们的第一个相交点
*/
public Node findFirstCrossPoint(MyLinkedList linkedList1, MyLinkedList linkedList2){
//链表不相交
if(!isCross(linkedList1.head,linkedList2.head)){
return null;
}else{
int length1 = linkedList1.length();//链表1的长度
int length2 = linkedList2.length();//链表2的长度
Node temp1 = linkedList1.head;//链表1的头结点
Node temp2 = linkedList2.head;//链表2的头结点
int len = length1 - length2;//链表1和链表2的长度差 if(len > 0){//链表1比链表2长,链表1先前移len步
for(int i=0; i<len; i++){
temp1 = temp1.next;
}
}else{//链表2比链表1长,链表2先前移len步
for(int i=0; i<len; i++){
temp2 = temp2.next;
}
}
//链表1和链表2同时前移,直到找到链表1和链表2相交的结点
while(temp1 != temp2){
temp1 = temp1.next;
temp2 = temp2.next;
}
return temp1;
}
} }

四、测试类:

package com.algorithm.link;
/**
* 单链表操作测试类
* @author bjh
*
*/
public class Test { public static void main(String[] args){
MyLinkedList myLinkedList = new MyLinkedList();
//添加链表结点
myLinkedList.addNode(9);
myLinkedList.addNode(8);
myLinkedList.addNode(6);
myLinkedList.addNode(3);
myLinkedList.addNode(5); //打印链表
myLinkedList.printLink(); /*//测试链表结点个数
System.out.println("链表结点个数为:" + myLinkedList.length()); //链表排序
Node head = myLinkedList.linkSort();
System.out.println("排序后的头结点为:" + head.data);
myLinkedList.printLink(); //去除重复结点
myLinkedList.distinctLink();
myLinkedList.printLink(); //链表反转
myLinkedList.reserveLink();
myLinkedList.printLink(); //倒序输出/遍历链表
myLinkedList.reservePrt(myLinkedList.head); //返回链表的中间结点
Node middleNode = myLinkedList.findMiddleNode();
System.out.println("中间结点的数值为:"+middleNode.data); //判断链表是否有环
boolean isRinged = myLinkedList.isRinged();
System.out.println("链表是否有环:" + isRinged);
//将链表的最后一个结点指向头结点,制造有环的效果
Node lastNode = myLinkedList.getLastNode();
lastNode.next = myLinkedList.head;
isRinged = myLinkedList.isRinged();
System.out.println("链表是否有环:" + isRinged); //删除指定结点
Node nk = myLinkedList.findReverNode(3);
System.out.println(nk.data);
myLinkedList.deleteSpecialNode(nk);
myLinkedList.printLink(); //链表是否相交
//新链表
MyLinkedList myLinkedList1 = new MyLinkedList();
myLinkedList1.addNode(1);
myLinkedList1.addNode(2);
myLinkedList1.printLink();
System.out.println("链表一和链表二是否相交"+myLinkedList.isCross(myLinkedList.head, myLinkedList1.head));
//把第二个链表从第三个结点开始接在第二个链表的后面,制造相交的效果
myLinkedList1.findNode(2).next = myLinkedList.findNode(3);
myLinkedList1.printLink();
System.out.println("链表一和链表二是否相交"+myLinkedList.isCross(myLinkedList.head, myLinkedList1.head));
*/ //如果两个链表相交求链表相交的结点的值
MyLinkedList myLinkedList1 = new MyLinkedList();
myLinkedList1.addNode(1);
myLinkedList1.addNode(2);
myLinkedList1.findNode(2).next = myLinkedList.findNode(3);
myLinkedList1.printLink();
Node n = myLinkedList1.findFirstCrossPoint(myLinkedList, myLinkedList1);
if(n == null){
System.out.println("链表不相交");
}else{
System.out.println("两个链表相交,第一个交点的数值为:" + n.data);
}
}
}

java实现单链表常见操作的更多相关文章

  1. Java实现单链表反转操作

    单链表是一种常见的数据结构,由一个个节点通过指针方式连接而成,每个节点由两部分组成:一是数据域,用于存储节点数据.二是指针域,用于存储下一个节点的地址.在Java中定义如下: public class ...

  2. Java实现单链表的各种操作

    Java实现单链表的各种操作 主要内容:1.单链表的基本操作 2.删除重复数据 3.找到倒数第k个元素   4.实现链表的反转   5.从尾到头输出链表 6.找到中间节点 7.检测链表是否有环 8.在 ...

  3. 数据结构——Java实现单链表

    一.分析 单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素.链表中的数据是以结点来表示的,每个结点由元素和指针构成.在Java中,我们可以将单链表定义成一个类,单链表的基 ...

  4. JAVA数据结构——单链表

    链表:一. 顺序存储结构虽然是一种很有用的存储结构,但是他有如下几点局限性:1. 因为创造线性表的时候已经固定了空间,所以当需要扩充空间时,就需要重新创建一个地址连续的更大的存储空间.并把原有的数据元 ...

  5. java实现单链表的增删功能

    JAVA 实现单链表的增删功能 package linked; class LinkedTable{ } public class LinkedTableTest { public static vo ...

  6. 使用java实现单链表(转载自:https://www.cnblogs.com/zhongyimeng/p/9945332.html)

    使用java实现单链表----(java中的引用就是指针)转载自:https://www.cnblogs.com/zhongyimeng/p/9945332.html ? 1 2 3 4 5 6 7 ...

  7. java单链表常用操作

    总结提高,与君共勉 概述. 数据结构与算法亘古不变的主题,链表也是面试常考的问题,特别是手写代码常常出现,将从以下方面做个小结 [链表个数] [反转链表-循环] [反转链表-递归] [查找链表倒数第K ...

  8. java实现单链表、栈、队列三种数据结构

    一.单链表 1.在我们数据结构中,单链表非常重要.它里面的数据元素是以结点为单位,每个结点是由数据元素的数据和下一个结点的地址组成,在java集合框架里面 LinkedList.HashMap(数组加 ...

  9. (java实现)单链表

    什么是单链表 在了解单链表之前,你知道什么是链表吗?如果你不知道什么是链表,可以看看我的这篇博客<链表-LinkList> 单链表是链表的其中一种基本结构.一个最简单的结点结构如图所示,它 ...

随机推荐

  1. js知识点记录

    1.for...in:用于遍历数组或对象的属性. for(var prop in obj){console.log(obj[prop])}; 该循环遍历对于对象属性是无序的,可能是因为obj本来就是无 ...

  2. SpringBoot初步

    1.创建maven 项目 quickstart类型 2.pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" ...

  3. 2、公司部门的组成 - CEO之公司管理经验谈

    今天讲讲公司部门的组成.公司部门一般是根据公司业务来进行划分的,IT企业和其它企业的部门划分有一定的区别.企业部门的划分还是比较重要的,部门主要明确各部门所具有的自己的职责.这里对IT企业的部门做了一 ...

  4. python实现散列表的直接寻址法

    散列表(Hash table,也叫哈希表),是根据键(Key)而直接访问在内存存储位置的数据结构.也就是说,它通过计算一个关于键值的函数, 将所需查询的数据映射到表中一个位置来访问记录,这加快了查找速 ...

  5. 关于swing的一些问题

    -问题1 :Exception in thread "AWT-EventQueue-0" java.lang.ArrayIndexOutOfBoundsException: 1 & ...

  6. PAGELATCH_x 等待--转载

    转自出处:http://www.cnblogs.com/xwdreamer/archive/2012/08/30/2663232.html 0.参考文献 Microsoft SQL Server企业级 ...

  7. 用元类和__getattribute__改变类属性的读取方式

    首先,需要知道两点: 类本身是type类的实例 __getattribute__ 可以改变类实例的属性的读取方式(http://www.cnblogs.com/blackmatrix/p/568148 ...

  8. 极光配置-》thinkphp3.2.3

    1,小白我搞了几天,终于得到了这样的结果(我猜应该是成功了吧). { "body": { "sendno": "100000", " ...

  9. 微信支付接口开发之---微信支付之JSSDK(公众号支付)步骤

    1.准备     1.1.公众号为服务号,开通微信支付功能     1.2.为了方便调试微信后台的回调URL(必须为外网),我用了nat123软件来做一个映射     1.3.官方微信开发的示例WxP ...

  10. Linux笔记---硬盘添加

    BZ创建了一个块云硬盘添加到了虚拟机里,然后按照平时挂在U盘的方式去挂载硬盘: mount  -t ext4 /dev/vdb  /mnt/xxxx 结果报出以下错误: mount: wrong fs ...