学一哈静态链表
描述以及特点
一个固定大小的数组
首位两端是不存储数据的
首(0标)节点元素的cur 存储下一空闲位置的下标
数组尾端元素cur存放链表的起点
通过改变元素的cur 来实现元素的位置调整
结构图
循环截至条件
节点元素的cur 是否==0
JAVA代码实现
package com.example.demo.data;
import java.util.Objects;
public class CycleSingleLinkList<T> {
public static void main(String[] args) {
CycleSingleLinkList<Object> objectCycleSingleLinkList = new CycleSingleLinkList<>();
System.out.println("===========选择头插法(默认尾插法)============");
objectCycleSingleLinkList.headInsert = false;
System.out.println("===========新增============");
for (int i = 0; i < 10; i++) {
objectCycleSingleLinkList.add(i);
}
System.out.println("新增完后长度为:" + objectCycleSingleLinkList.size + " 元素情况:" + objectCycleSingleLinkList.toString());
objectCycleSingleLinkList.add(0, new Integer("1000"));
System.out.println("0标增加数据为1000的节点后长度为:" + objectCycleSingleLinkList.size + " 元素情况:" + objectCycleSingleLinkList.toString());
System.out.println("===========删除============");
Boolean remove = objectCycleSingleLinkList.remove(1);
System.out.println("删除第1个节点" + remove + "之后长度为:" + objectCycleSingleLinkList.size + " 元素情况:" + objectCycleSingleLinkList.toString());
Boolean remove1 = objectCycleSingleLinkList.remove(new Integer("9"));
System.out.println("删除数据为9节点" + remove1 + "之后长度为:" + objectCycleSingleLinkList.size + " 元素情况:" + objectCycleSingleLinkList.toString());
System.out.println("===========查询============");
System.out.println("通过数据1000查询" + objectCycleSingleLinkList.get(new Integer("1000")).data);
System.out.println("通过下标0查询" + objectCycleSingleLinkList.get(0).data);
System.out.println("===========修改============");
boolean replace = objectCycleSingleLinkList.replace(0, new Integer(10000));
System.out.println("替换0下标数据为1w:" + replace + "之后长度为:" + objectCycleSingleLinkList.size + " 元素情况:" + objectCycleSingleLinkList.toString());
objectCycleSingleLinkList.replace(new Integer(8), new Integer(800));
System.out.println("替换据8为800:" + "之后长度为:" + objectCycleSingleLinkList.size + " 元素情况:" + objectCycleSingleLinkList.toString());
}
private boolean replace(int index, T data) {
checkPositionIndex(index);
int currentIndex = getBorder(index);
Node<T> current = getPositionPreNode(currentIndex + 1);
current.data = data;
return true;
}
private T replace(T oldData, T newData) {
Node<T> current = get(oldData);
if (null != current) {
current.data = newData;
return oldData;
}
return null;
}
private Node<T> get(int index) {
checkPositionIndex(index);
int border = getBorder(index);
Node<T> node = this.head.next;
for (int i = 0; i < border; i++) {
node = node.next;
}
return node;
}
private Node<T> get(T oldData) {
Node<T> node = this.head.next;
while (node != this.head) {
if (Objects.equals(node.data, oldData)) {
return node;
}
node = node.next;
}
return null;
}
private Boolean remove(T data) {
Node<T> current = get(data);
if (null == current) {
return true;
}
Node<T> next = current.next;
if (next != this.head) {
current.data = next.data;
current.next = next.next;
next.next = null;
next.data = null;
} else {
Node<T> node = this.head;
while (node.next != current) {
node = node.next;
}
node.next = this.head;
current.next = null;
current.data = null;
}
this.size--;
return true;
}
private Boolean remove(int index) {
checkPositionIndex(index);
int border = getBorder(index);
Node<T> pre = getPositionPreNode(border);
Node<T> del = pre.next;
pre.next = del.next;
del.next = null;
del.data = null;
this.size--;
return true;
}
private int getBorder(int index) {
int border;
if (this.headInsert) {
border = size - index - 1;
} else {
border = index;
}
return border;
}
private Node<T> getPositionPreNode(int index) {
Node<T> pre = this.head;
for (int i = 0; i < index; i++) {
pre = pre.next;
}
return pre;
}
private void add(int index, T data) {
checkPositionIndex(index);
int border = getBorder(index);
Node<T> pre = getPositionPreNode(border);
pre.next = new Node<T>(data, pre.next);
this.size++;
}
private void add(T t) {
if (this.headInsert) {
Node<T> head = this.head;
head.next = new Node<>(t, head.next);
} else {
Node<T> last = this.head;
while (last.next != this.head) {
last = last.next;
}
last.next = new Node<>(t, this.head);
}
this.size++;
}
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size - 1;
}
private String outOfBoundsMsg(int index) {
return "Index: " + index + ", size: " + (size - 1);
}
@Override
public String toString() {
Node<T> node = this.head.next;
StringBuilder stringBuilder = new StringBuilder();
while (node != this.head) {
stringBuilder.append(node.data);
stringBuilder.append(" ");
node = node.next;
}
return stringBuilder.toString();
}
private boolean headInsert;
private int size;
private Node<T> head;
public CycleSingleLinkList() {
this.head = new Node<>(null, null);
this.head.next = this.head;
}
private static class Node<T> {
private T data;
private Node<T> next;
public Node(T data, Node<T> next) {
this.data = data;
this.next = next;
}
}
}