Java基础——链表的添加、移除、反转
1 链表
链表：是由节点组成的。
节点：是由数据域+引用域组成。
节点与节点之间：引用域进行链接。
2 链表实现
2.1 定义节点类
- 节点类
- 链表：是有节点链接起来的
- 节点：有数据域（存储数据，类型不定）+引用域（存储下一个节点，用于节点链接）
package com.java8.mylinkedlist;
/**
* 节点类
* 链表：是有节点链接起来的
* 节点：有数据域（存储数据，类型不定）+引用域（存储下一个节点，用于节点链接）
*/
public class Node {
private Object data;
private Node next;
//无参构造方法
public Node(){
}
//有参构造，初始化的时候设置root的data为null
public Node(Object data){
this.data = data;
}
//获取数据，使用数据时需要
public Object getData() {
return data;
}
//设置数据，添加add时需要
public void setData(Object data) {
this.data = data;
}
//获取下一个节点，查找get需要
public Node getNext() {
return next;
}
//设置下一个节点，添加add时候需要
public void setNext(Node next) {
this.next = next;
}
}
2.2 实现链表类
- 链表类
- 链表：包括头结点root + n个数据节点node（包括尾部节点last）
链表类包括以下功能：
- add(Object data)：添加node到链表，参数为data
头插法 add_head()：每次插入node放在root后面，链表最前面
尾插法 add()：每次插入node放在链表最后
- size()：返回链表大小
- get(int index)：返回第index个链表的data
- remove(int index)：移除第index个元素
- reverse(LinkedList linkedList)：反转链表
package com.java8.mylinkedlist;
/**
* 链表类
* 链表：包括头结点root + n个数据节点node（包括尾部节点last）
*/
public class LinkedList {
//链表的长度
private int size = 0;
//链表的头结点，内容为null
private Node root = new Node(null);
//链表的尾部：尾插法
private Node last = root;
//构造方法，初始化链表
public LinkedList() {
}
/**
* 1.2、add()方法:
* 尾差法:添加新节点到链表的末尾
* @param data：添加的数据
*/
public void add(Object data) {
//创建本node对象的时候初始化数据:data
Node node = new Node(data);
//1 尾差法:添加到链表的末尾
//设置尾部last的下一个为：node
last.setNext(node);
//更新链表尾部last
last = node;
//size增加
size++;
}
/**
* 1.3、add_head()方法:
* 头插法：添加新节点到头节点后面
* @param data：添加的数据
*/
public void add_head(Object data) {
//创建本node对象的时候初始化数据:data
Node node = new Node(data);
//2 头插法：添加到头节点后面
//设置该node的下一个为：root的下一个
node.setNext(root.getNext());
//设置root的下一个为：本node
root.setNext(node);
//size增加
size++;
}
/**
* 2、获取链表大小
*
* @return ：链表长度
*/
public int size() {
return size;
}
/**
* 3、获取链表第index的数据data
*
* @param index ：要获取的第i个链表
* @return :第index的个链表的数据内容
*/
public Object get(int index) {
Node node = root.getNext();
if (index < 0 || index > size) {
return null;
}
for (int i = 0; i < index; i++) {
node = node.getNext();
}
return node.getData();
}
/**
* 4、移除第index的节点node
*
* @param index ：第i个
* @return
*/
public Object remove(int index) {
Node node = root.getNext();
if (index < 0 || index > size) {
return 0;
}
//1 若要移除的index为第一个node，index为0，不存在index-1，则单独设置
if (index == 0) {
//setNext链接上一个和下一个 ：上一个为root,下一个为node.getNext()
root.setNext(node.getNext());
//清除该节点的引用域为null：next
node.setNext(null);
//大小－1
size--;
}
//2 移除的index不为0
else {
//2.1 获取三个节点：上一个node、这个removenode、下一个nextnode
// 获取要移除node的上一个node
for (int i = 0; i < index - 1; i++) {
node = node.getNext();
}
// 获取要移除的node
Node removenode = node.getNext();
// 获取要移除的下一个node
Node nextnode = removenode.getNext();
//2.2 setNext链接上一个和下一个：上一个为node，下一个为nextnode
node.setNext(nextnode);
//2.3 清除该node的引用域为null：next
removenode.setNext(null);
//2.4 大小－1
size--;
}
return 0;
}
/**
* 5、reverse 反转链表
* 利用头插法，直接可以反转链表
* @param linkedList 原链表
* @return 翻转后的链表
*/
public LinkedList reverse(LinkedList linkedList){
LinkedList rlinkedList = new LinkedList();
Node node = linkedList.root.getNext();
for (int i = 0; i < linkedList.size(); i++) {
rlinkedList.add_head(node.getData());
node = node.getNext();
}
return rlinkedList;
}
}
2.3 测试代码 Manage类：
package com.java8.mylinkedlist;
import java.util.Random;
public class Manage {
public static void main(String[] args) {
//创建链表对象
LinkedList linkedList = new LinkedList();
//随机给出大小:1-20
int size = new Random().nextInt(20)+1;
//1.add
for (int i = 0; i < size; i++) {
linkedList.add((char)(97+i));
}
//2.size
System.out.println("1 创建 —————————————————————————————");
System.out.println("链表的size为："+linkedList.size());
//3.get
for (int i = 0; i < linkedList.size(); i++) {
System.out.println("第i个数据为："+linkedList.get(i));
}
//4.remove
//随机给出删除数据index：1-size
System.out.println("2 移除 —————————————————————————————");
int removeindex = new Random().nextInt(linkedList.size()-1)+1;
System.out.println("移除的index为："+removeindex);
System.out.println("移除的data为："+linkedList.get(removeindex));
linkedList.remove(removeindex);
System.out.println("移除后链表的size为："+linkedList.size());
for (int i = 0; i < linkedList.size(); i++) {
System.out.println("移除后第i个数据为："+linkedList.get(i));
}
//5.reverse
System.out.println("3 翻转 —————————————————————————————");
LinkedList rlinkedList = linkedList.reverse(linkedList);
System.out.println("翻转后链表的size为："+rlinkedList.size());
for (int i = 0; i < linkedList.size(); i++) {
System.out.println("翻转后第i个数据为："+rlinkedList.get(i));
}
}
}
输出结果：
1 创建 —————————————————————————————
链表的size为：7
第i个数据为：a
第i个数据为：b
第i个数据为：c
第i个数据为：d
第i个数据为：e
第i个数据为：f
第i个数据为：g
2 移除 —————————————————————————————
移除的index为：5
移除的data为：f
移除后链表的size为：6
移除后第i个数据为：a
移除后第i个数据为：b
移除后第i个数据为：c
移除后第i个数据为：d
移除后第i个数据为：e
移除后第i个数据为：g
3 翻转 —————————————————————————————
翻转后链表的size为：6
翻转后第i个数据为：g
翻转后第i个数据为：e
翻转后第i个数据为：d
翻转后第i个数据为：c
翻转后第i个数据为：b
翻转后第i个数据为：a
