Java实现单向链表基本功能
1、前言
最近在回顾数据结构与算法，有部分的算法题用到了栈的思想，提及栈又不得不说链表了。数组和链表都是线性存储结构的基础，栈和队列都是线性存储结构的应用～html
本文主要讲解单链表的基础知识点，作一个简单的入门～若是有错的地方请指正node
2、回顾与知新
提及链表，咱们先提一下数组吧，跟数组比较一下就很理解链表这种存储结构了。算法
2.1回顾数组
数组咱们不管是C、Java都会学过：数组
- 数组是一种连续存储线性结构，元素类型相同，大小相等
数组的优势：微信
- 存取速度快
数组的缺点：数据结构
- 事先必须知道数组的长度
- 插入删除元素很慢
- 空间一般是有限制的
- 须要大块连续的内存块
- 插入删除元素的效率很低
2.2链表说明
看完了数组，回到咱们的链表：this
- 链表是离散存储线性结构
n个节点离散分配，彼此经过指针相连，每一个节点只有一个前驱节点，每一个节点只有一个后续节点，首节点没有前驱节点，尾节点没有后续节点。spa
链表优势：指针
- 空间没有限制
- 插入删除元素很快
链表缺点：code
- 存取速度很慢
链表相关术语介绍，我仍是经过上面那个图来讲明吧：
肯定一个链表咱们只须要头指针，经过头指针就能够把整个链表都能推导出来了～
链表又分了好几类：
- 单向链表
- 一个节点指向下一个节点
- 双向链表
- 一个节点有两个指针域
- 循环链表
- 能经过任何一个节点找到其余全部的节点，将两种(双向/单向)链表的最后一个结点指向第一个结点从而实现循环
操做链表要时刻记住的是：
- 节点中指针域指向的就是一个节点了！
3、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;
}
}
3.1建立链表(增长节点)
向链表中插入数据：
- 找到尾节点进行插入
- 即便头节点.next为null，不走while循环，也是将头节点与新节点链接的(我已经将head节点初始化过了，所以不必判断头节点是否为null)～
/**
* 向链表添加数据
*
* @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;
}
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;
}
}
结果：
3.3插入节点
- 插入一个节点到链表中，首先得判断这个位置是不是合法的，才能进行插入～
- 找到想要插入的位置的上一个节点就能够了～
/**
* 插入节点
*
* @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;
}
}
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;
}
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;
}
}
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;
}
}
}
}
3.7找到链表中倒数第k个节点
这个算法挺有趣的：设置两个指针p一、p2，让p2比p1快k个节点，同时向后遍历，当p2为空，则p1为倒数第k个节点
/**
* 找到链表中倒数第k个节点(设置两个指针p一、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;
}
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;
}
}
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;
}
3.10经过递归从尾到头输出单链表
/**
* 经过递归从尾到头输出单链表
*
* @param head 头节点
*/
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;
}
反转链表参考自：
4、最后
理解链表自己并不难，但作相关的操做就弄得头疼，
head.next next next next ....(算法这方面我仍是薄弱啊..脑子不够用了.....)写了两天就写了这么点东西...
操做一个链表只须要知道它的头指针就能够作任何操做了
- 添加数据到链表中
- 遍历找到尾节点，插入便可(只要
while(temp.next != null)，退出循环就会找到尾节点)
- 遍历找到尾节点，插入便可(只要
- 遍历链表
- 从首节点(有效节点)开始，只要不为null，就输出
- 给定位置插入节点到链表中
- 首先判断该位置是否有效(在链表长度的范围内)
- 找到想要插入位置的上一个节点
- 将本来由上一个节点的指向交由插入的节点来指向
- 上一个节点指针域指向想要插入的节点
-
- 获取链表的长度
- 每访问一次节点，变量++操做便可
- 删除给定位置的节点
- 首先判断该位置是否有效(在链表长度的范围内)
- 找到想要插入位置的上一个节点
- 将本来由上一个节点的指向后面一个节点
-
- 对链表进行排序
- 使用冒泡算法对其进行排序
- 找到链表中倒数第k个节点
- 设置两个指针p一、p2，让p2比p1快k个节点，同时向后遍历，当p2为空，则p1为倒数第k个节点
- 删除链表重复数据
- 操做跟冒泡排序差很少，只要它相等，就能删除了～
- 查询链表的中间节点
- 这个算法也挺有趣的：一个每次走1步，一个每次走两步，走两步的遍历完，而后走一步的指针，那就是中间节点
- 递归从尾到头输出单链表
- 只要下面还有数据，那就往下找，递归是从最后往前翻。
- 反转链表
- 有递归和非递归两种方式，我以为是挺难的。能够到我给出的连接上查阅～
PS：每一个人的实现都会不同，因此一些小细节不免会有些变更，也没有固定的写法，可以实现对应的功能便可～
参考资料：
若是文章有错的地方欢迎指正，你们互相交流。习惯在微信看技术文章，想要获取更多的Java资源的同窗，能够关注微信公众号:Java3y
相关文章
- 1. Java实现单向链表功能
- 2. Java实现单向链表基本功能
- 3. js单向链表的基本实现
- 4. 单向链表的基本实现
- 5. java实现单向链表
- 6. js实现基本的链表功能
- 7. 数据结构--单链表的基本功能实现
- 8. List | 链表实现表（单向链表）
- 9. Java实现单向链表和双向链表
- 10. (java实现)单向循环链表
- 更多相关文章...
- • 使用Redis和Lua的原子性实现抢红包功能 - 红包项目实战
- • PHP 完整表单实例 - PHP教程
- • ☆基于Java Instrument的Agent实现
- • Kotlin学习（二）基本类型
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Java实现单向链表功能
- 2. Java实现单向链表基本功能
- 3. js单向链表的基本实现
- 4. 单向链表的基本实现
- 5. java实现单向链表
- 6. js实现基本的链表功能
- 7. 数据结构--单链表的基本功能实现
- 8. List | 链表实现表（单向链表）
- 9. Java实现单向链表和双向链表
- 10. (java实现)单向循环链表