链表:单向链表 双向链表 单向循环链表 双向循环链表 链表的反转.
定义了链表的基本使用, 对链表增加了索引, 使用两种方式(递归和循环)对链表进行反转操作.
单向链表:
public class SinglyChain<E> {
private Object lock = new Object();
private Node head;// 头节点
private Node last;// 尾节点
private int size;
public int size() {
return size;
}
/**
* 允许添加的对象重复, 默认添加到末尾;<br/>
* 不允许添加空对象
*/
public boolean add(E data) {
synchronized (lock) {
if (data != null) {
Node node = new Node(size, data);
if (size == 0) {
head = node;
} else {
last.next = node;
}
last = node;
size++;
return true;
}
return false;
}
}
/**
* 允许添加的对象重复, 默认添加到末尾;<br/>
* 不允许添加空对象
*
* @param index 添加的位置索引
*/
public boolean add(int index, E data) {
if (index < 0) {
index = 0;
} else if (index > size) {
index = size;
}
synchronized (lock) {
if (data != null) {
if (index == size) {
return add(data);
} else {
Node newNode = new Node(index, data);
Node node = head;
Node pre = null;
while (node != null) {
if (node.index == index) {
if (node == head) {
newNode.next = head;
head = newNode;
} else {
pre.next = newNode;
newNode.next = node;
}
moveToBack(node);
size++;
return true;
}
pre = node;
node = node.next;
}
}
}
return false;
}
}
/** 如果添加了重复对象,则只删除遍历到的第一个 */
public boolean remove(E data) {
synchronized (lock) {
if (data != null) {
Node currentNode = head;
Node preNode = null;
Node nextNode;
while (currentNode != null) {
nextNode = currentNode.next;
if (currentNode.data == data) {
if (preNode == null) {
// 如果删除的是首节点, 重置首节点
head = nextNode;
} else {
// 将需要删除的对象 currentNode 从链表中剔除
preNode.next = nextNode;
}
// 如果删除的是尾节点, 重置尾节点
if (currentNode == last) {
last = preNode;
}
// 将node中的index进行移位操作
moveToFront(nextNode);
size--;
return true;
}
preNode = currentNode;
currentNode = currentNode.next;
}
}
return false;
}
}
/** 根据索引位置删除链表中的对象 */
public boolean remove(int index) {
synchronized (lock) {
Node currentNode = head;
Node preNode = null;
Node nextNode;
while (currentNode != null) {
nextNode = currentNode.next;
if (currentNode.index == index) {
if (preNode == null) {
// 如果删除的是首节点, 重置首节点
head = nextNode;
} else {
// 将需要删除的对象 currentNode 从链表中剔除
preNode.next = nextNode;
}
// 如果删除的是尾节点, 重置尾节点
if (currentNode == last) {
last = preNode;
}
// 将node中的index进行移位操作
moveToFront(nextNode);
size--;
return true;
}
preNode = currentNode;
currentNode = currentNode.next;
}
return false;
}
}
public E get(int index) {
if (index < 0 || index > size - 1) {
throw new IndexOutOfBoundsException();
}
Node node = head;
while (node != null) {
if (node.index == index) {
return node.data;
}
}
return null;
}
public E getFirst() {
return head.data;
}
public E getLast() {
return last.data;
}
/** 将当前节点以后的所有节点索引前移一位 */
private void moveToFront(Node node) {
synchronized (lock) {
while (node != null) {
node.setIndex(node.getIndex() - 1);
node = node.next;
}
}
}
/** 将当前节点以后的所有节点索引后移一位 */
private void moveToBack(Node node) {
while (node != null) {
node.setIndex(node.getIndex() + 1);
node = node.next;
}
}
@Override
public String toString() {
if (head == null && head == last) {
return "NodeChain {}";
}
StringBuilder sb = new StringBuilder();
// 将所有的子节点递归处理
Node node = head;
sb.append("NodeChain {");
while (node != null) {
sb.append("\n")
.append('[')
.append(node.toString())
.append(']')
.append(',')
.append(' ');
node = node.next;
}
sb.append('}');
return sb.toString();
}
/** 翻转链表 */
public void reverseChain() {
Node reverse = reverseCycle(head);
// 首尾置换
head = last;
last = reverse;
last.next = null;
last.index = size - 1;
}
/** 递归反转链表 */
private Node reverseRecursion(Node node) {
if (node.next == null) {// 尾节点
return node;
}
Node temp = reverseRecursion(node.next);
temp.next = node;
temp.index = size - 1 - temp.index;
return node;
}
/** 循环反转链表 */
private Node reverseCycle(Node head) {
if (head == null) {
return null;
}
Node pre = head;
Node cur = pre.next;
Node next;
while (cur != null) {
next = cur.next;
cur.next = pre;
cur.index = size - 1 - cur.index;
pre = cur;
cur = next;
}
return head;
}
class Node {
int index;
Node next;
E data;
public Node(int index, E data) {
super();
this.index = index;
this.data = data;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
@Override
public String toString() {
String str = "Node {index:" + index + ", data : " + data.toString() + '}';
if (next != null) {
str += " -> next = " + next.data + ", next.index = " + next.index;
}
return str;
}
}
}
单向循环链表:
public class SinglyCircleChain<E> {
private Object lock = new Object();
private Node head;// 头节点
private Node last;// 尾节点
private int size;
public int size() {
return size;
}
/**
* 允许添加的对象重复, 默认添加到末尾;<br/>
* 不允许添加空对象
*/
public boolean add(E data) {
synchronized (lock) {
if (data != null) {
Node node = new Node(size, data);
if (size == 0) {
head = node;
} else {
last.next = node;
}
last = node;
last.next = head;
size++;
return true;
}
return false;
}
}
/**
* 允许添加的对象重复, 默认添加到末尾;<br/>
* 不允许添加空对象
*
* @param index 添加的位置索引
*/
public boolean add(int index, E data) {
synchronized (lock) {
if (index < 0 || index > size) {
throw new IndexOutOfBoundsException();
}
if (data != null) {
if (index == size) {
return add(data);
} else {
Node newNode = new Node(index, data);
Node node = head;
Node pre = last;
while (node != null) {
if (node.index == index) {
if (node == head) {// 首节点
newNode.next = node;
head = newNode;
last.next = newNode;
} else {
pre.next = newNode;
newNode.next = node;
}
moveToBack(node);
size++;
return true;
}
pre = node;
node = node.next;
if (node == head) {
break;
}
}
}
}
return false;
}
}
/** 如果添加了重复对象,则只删除遍历到的第一个 */
public boolean remove(E data) {
synchronized (lock) {
if (data != null && head != null) {
Node currentNode = head;
Node preNode = null;
Node nextNode;
while (currentNode != null) {
nextNode = currentNode.next;
if (currentNode.data == data) {
if (preNode == null) {
// 如果删除的是首节点, 重置首节点
head = nextNode;
} else {
// 将需要删除的对象 currentNode 从链表中剔除
preNode.next = nextNode;
}
// 如果删除的是尾节点, 重置尾节点
if (currentNode == last) {
last = preNode;
}
// 将node中的index进行移位操作
moveToFront(nextNode);
size--;
return true;
}
preNode = currentNode;
currentNode = currentNode.next;
if (currentNode == head) {
break;
}
}
}
return false;
}
}
/** 根据索引位置删除链表中的对象 */
public boolean remove(int index) {
synchronized (lock) {
Node currentNode = head;
Node preNode = null;
Node nextNode;
while (currentNode != null) {
nextNode = currentNode.next;
if (currentNode.index == index) {
if (preNode == null) {
// 如果删除的是首节点, 重置首节点
head = nextNode;
} else {
// 将需要删除的对象 currentNode 从链表中剔除
preNode.next = nextNode;
}
// 如果删除的是尾节点, 重置尾节点
if (currentNode == last) {
last = preNode;
last.next = head;
}
// 将node中的index进行移位操作
moveToFront(nextNode);
size--;
return true;
}
preNode = currentNode;
currentNode = currentNode.next;
if (currentNode == head) {
break;
}
}
return false;
}
}
public E get(int index) {
if (index < 0 || index > size - 1) {
throw new IndexOutOfBoundsException();
}
Node node = head;
while (node != null) {
if (node.index == index) {
return node.data;
}
}
return null;
}
/** 将当前节点以后的所有节点索引前移一位 */
private void moveToFront(Node node) {
synchronized (lock) {
while (node != null) {
node.setIndex(node.getIndex() - 1);
node = node.next;
if (node == head) {
break;
}
}
}
}
/** 将当前节点以后的所有节点索引后移一位 */
private void moveToBack(Node node) {
while (node != null) {
node.setIndex(node.getIndex() + 1);
node = node.next;
if (node == head) {
break;
}
}
}
/** 翻转链表 */
public void reverseChain() {
Node reverse = reverseCycle(head);
// 首尾置换
head = last;
last = reverse;
last.next = head;
last.index = size - 1;
}
/** 递归反转链表 */
private Node reverseRecursion(Node node) {
if (node.next == head) {// 尾节点
return node;
}
Node temp = reverseRecursion(node.next);
temp.next = node;
temp.index = size - 1 - temp.index;
return node;
}
/** 循环反转链表 */
private Node reverseCycle(Node head) {
if (head == null) {
return null;
}
Node pre = head;
Node cur = pre.next;
Node next;
while (cur != head) {
next = cur.next;
cur.next = pre;
cur.index = size - 1 - cur.index;
pre = cur;
cur = next;
}
return head;
}
@Override
public String toString() {
if (head == null && head == last) {
return "NodeChain {}";
}
StringBuilder sb = new StringBuilder();
// 将所有的子节点递归处理
Node node = head;
sb.append("NodeChain {");
while (node != null) {
sb.append("\n")
.append('[')
.append(node.toString())
.append(']')
.append(',')
.append(' ');
node = node.next;
if (node == head) {
break;
}
}
sb.append('}');
return sb.toString();
}
class Node {
int index;
Node next;
E data;
public Node(int index, E data) {
super();
this.index = index;
this.data = data;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
@Override
public String toString() {
String str = "Node {index:" + index + ", data : " + data.toString() + '}';
str += " -> next = " + next.data + ", next.index = " + next.index;
return str;
}
}
}
双向链表:
public class DoublyChain<E> {
private Object lock = new Object();
private Node head;// 头节点
private Node last;// 尾节点
private int size;
public int gsize() {
return size;
}
/**
* 允许添加的对象重复, 默认添加到末尾;<br/>
* 不允许添加空对象
*/
public boolean add(E data) {
synchronized (lock) {
if (data != null) {
Node node = new Node(size, data);
if (size == 0) {
head = node;
} else {
last.next = node;
node.previous = last;
}
last = node;
size++;
return true;
}
return false;
}
}
/**
* 允许添加的对象重复, 默认添加到末尾;<br/>
* 不允许添加空对象
*
* @param index 添加的位置索引
*/
public boolean add(int index, E data) {
if (index < 0) {
index = 0;
} else if (index > size) {
index = size;
}
synchronized (lock) {
if (data != null) {
if (index == size) {
return add(data);
} else {
Node newNode = new Node(index, data);
Node nextNode = head;// 相对于新插入位置后一个
Node preNode = null;// 相对于新插入位置前一个
while (nextNode != null) {
if (nextNode.index == index) {
if (head == nextNode) {
head = newNode;
}
if (preNode != null) {
preNode.next = newNode;
}
if (nextNode != null) {
nextNode.previous = newNode;
}
newNode.previous = preNode;
newNode.next = nextNode;
moveToBack(nextNode);
size++;
return true;
}
preNode = nextNode;
nextNode = nextNode.next;
}
}
}
return false;
}
}
/** 如果添加了重复对象,则只删除遍历到的第一个 */
public boolean remove(E data) {
synchronized (lock) {
if (data != null) {
Node currentNode = head;
Node preNode = null;
Node nextNode;
while (currentNode != null) {
nextNode = currentNode.next;
if (currentNode.data == data) {
if (preNode == null) {
// 如果删除的是首节点, 重置首节点
head = nextNode;
head.previous = null;
} else {
// 将需要删除的对象 currentNode 从链表中剔除
preNode.next = nextNode;
if (nextNode != null) {// 非尾节点
nextNode.previous = preNode;
}
}
// 如果删除的是尾节点, 重置尾节点
if (currentNode == last) {
last = preNode;
last.next = null;
}
// 将node中的index进行移位操作
moveToFront(nextNode);
size--;
return true;
}
preNode = currentNode;
currentNode = currentNode.next;
}
}
return false;
}
}
/**
* 根据索引位置删除链表中的对象<br>
* 如果索引超出界限将删除失败
*/
public boolean remove(int index) {
synchronized (lock) {
Node currentNode = head;
Node preNode = null;
Node nextNode;
while (currentNode != null) {
nextNode = currentNode.next;
if (currentNode.index == index) {
if (preNode == null) {
// 如果删除的是首节点, 重置首节点
head = nextNode;
head.previous = null;
} else {
// 将需要删除的对象 currentNode 从链表中剔除
preNode.next = nextNode;
if (nextNode != null) {
nextNode.previous = preNode;
}
}
// 如果删除的是尾节点, 重置尾节点
if (currentNode == last) {
last = preNode;
last.next = null;
}
// 将node中的index进行移位操作
moveToFront(nextNode);
size--;
return true;
}
preNode = currentNode;
currentNode = currentNode.next;
}
return false;
}
}
public E get(int index) {
if (index < 0 || index > size - 1) {
throw new IndexOutOfBoundsException();
}
Node node = head;
while (node != null) {
if (node.index == index) {
return node.data;
}
}
return null;
}
/** 将当前节点以后的所有节点索引前移一位 */
private void moveToFront(Node node) {
synchronized (lock) {
while (node != null) {
node.setIndex(node.getIndex() - 1);
node = node.next;
}
}
}
/** 将当前节点以后的所有节点索引后移一位 */
private void moveToBack(Node node) {
while (node != null) {
node.setIndex(node.getIndex() + 1);
node = node.next;
}
}
/** 翻转链表 */
public void reverseChain() {
Node reverse = reverseCycle(head);
// 首尾置换
head = last;
last = reverse;
head.previous = null;
last.next = null;
last.index = size - 1;
}
/** 递归反转链表 */
private Node reverseRecursion(Node node) {
if (node.next == null) {// 尾节点
return node;
}
Node temp = reverseRecursion(node.next);
temp.next = node;
node.previous = temp;
temp.index = size - 1 - temp.index;
return node;
}
/** 循环反转链表 */
private Node reverseCycle(Node head) {
if (head == null) {
return null;
}
Node pre = head;
Node cur = pre.next;
Node next;
while (cur != null) {
next = cur.next;
cur.next = pre;
pre.previous = cur;
cur.index = size - 1 - cur.index;
pre = cur;
cur = next;
}
return head;
}
@Override
public String toString() {
if (head == null && head == last) {
return "NodeChain {}";
}
StringBuilder sb = new StringBuilder();
// 将所有的子节点递归处理
Node node = head;
sb.append("NodeChain {");
while (node != null) {
sb.append('\n')
.append('[')
.append(node.toString())
.append(']')
.append(',');
node = node.next;
}
sb.append('}');
return sb.toString();
}
class Node {
int index;
E data;
Node next;
Node previous;
public Node(int index, E data) {
super();
this.index = index;
this.data = data;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
@Override
public String toString() {
String str = "Node {index:" + index + ", data : " + data.toString() + '}';
if (next != null) {
str += ", next = " + next.index;
} else {
str += ", next is empty";
}
if (previous != null) {
str += ", previous = " + previous.index;
} else {
str += ", previous is empty";
}
return str;
}
}
}
双向循环链表:
public class DoublyCircleChain<E> {
private Object lock = new Object();
private Node head;// 头节点
private Node last;// 尾节点
private int size;
public int gsize() {
return size;
}
/**
* 允许添加的对象重复, 默认添加到末尾;<br/>
* 不允许添加空对象
*/
public boolean add(E data) {
synchronized (lock) {
if (data != null) {
Node node = new Node(size, data);
if (size == 0) {
head = node;
} else {
last.next = node;
node.previous = last;
}
last = node;
last.next = head;
head.previous = last;
size++;
return true;
}
return false;
}
}
/**
* 允许添加的对象重复, 默认添加到末尾;<br/>
* 不允许添加空对象
*
* @param index 添加的位置索引
*/
public boolean add(int index, E data) {
if (index < 0) {
index = 0;
} else if (index > size) {
index = size;
}
synchronized (lock) {
if (data != null) {
if (index == size) {
return add(data);
} else {
Node newNode = new Node(index, data);
Node nextNode = head;// 相对于新插入位置后一个
Node preNode = last;// 相对于新插入位置前一个
while (nextNode != null) {
if (nextNode.index == index) {
if (head == nextNode) {
head = newNode;
}
if (preNode != null) {
preNode.next = newNode;
}
if (nextNode != null) {
nextNode.previous = newNode;
}
newNode.previous = preNode;
newNode.next = nextNode;
moveToBack(nextNode);
size++;
return true;
}
preNode = nextNode;
nextNode = nextNode.next;
if (nextNode == head) {
break;
}
}
}
}
return false;
}
}
/** 如果添加了重复对象,则只删除遍历到的第一个 */
public boolean remove(E data) {
synchronized (lock) {
Node currentNode = head;
Node preNode = last;
Node nextNode;
int index = 0;
while (currentNode != null) {
index++;
nextNode = currentNode.next;
if (currentNode.data == data) {
if (preNode == last) {
// 如果删除的是首节点, 重置首节点
head = nextNode;
head.previous = last;
} else {
// 将需要删除的对象 currentNode 从链表中剔除
preNode.next = nextNode;
nextNode.previous = preNode;
}
// 如果删除的是尾节点, 重置尾节点
if (currentNode == last) {
last = preNode;
last.next = head;
}
last.next = head;
head.previous = last;
if (index != size) {// 如果删除的是最后一个,则不进行索引移动
// 将node中的index进行移位操作
moveToFront(nextNode);
}
size--;
return true;
}
preNode = currentNode;
currentNode = currentNode.next;
if (currentNode == head) {
break;
}
}
return false;
}
}
/**
* 根据索引位置删除链表中的对象<br>
* 如果索引超出界限将删除失败
*/
public boolean remove(int index) {
synchronized (lock) {
Node currentNode = head;
Node preNode = last;
Node nextNode;
while (currentNode != null) {
nextNode = currentNode.next;
if (currentNode.index == index) {
if (preNode == last) {
// 如果删除的是首节点, 重置首节点
head = nextNode;
head.previous = last;
} else {
// 将需要删除的对象 currentNode 从链表中剔除
preNode.next = nextNode;
nextNode.previous = preNode;
}
// 如果删除的是尾节点, 重置尾节点
if (currentNode == last) {
last = preNode;
last.next = head;
}
last.next = head;
head.previous = last;
// 将node中的index进行移位操作
size--;
if (index != size) {
// 如果删除的是最后一个,则不进行索引移动
moveToFront(nextNode);
}
return true;
}
preNode = currentNode;
currentNode = currentNode.next;
if (currentNode == head) {
break;
}
}
return false;
}
}
public E get(int index) {
if (index < 0 || index > size - 1) {
throw new IndexOutOfBoundsException();
}
Node node = head;
while (node != null) {
if (node.index == index) {
return node.data;
}
}
return null;
}
/** 将当前节点以后的所有节点索引前移一位 */
private void moveToFront(Node node) {
synchronized (lock) {
while (node != null) {
node.setIndex(node.getIndex() - 1);
node = node.next;
if (node == head) {
break;
}
}
}
}
/** 将当前节点以后的所有节点索引后移一位 */
private void moveToBack(Node node) {
while (node != null) {
node.setIndex(node.getIndex() + 1);
node = node.next;
if (node == head) {
break;
}
}
}
/** 翻转链表 */
public void reverseChain() {
Node reverse = reverseCycle(head);
// 首尾置换
head = last;
last = reverse;
last.next = head;
head.previous = last;
last.index = size - 1;
}
/** 递归反转链表 */
private Node reverseRecursion(Node node) {
if (node.next == head) {// 尾节点
return node;
}
Node temp = reverseRecursion(node.next);
temp.next = node;
node.previous = temp;
temp.index = size - 1 - temp.index;
return node;
}
/** 循环反转链表 */
private Node reverseCycle(Node head) {
if (head == null) {
return null;
}
Node pre = head;
Node cur = pre.next;
Node next;
while (cur != head) {
next = cur.next;
cur.next = pre;
pre.previous = cur;
cur.index = size - 1 - cur.index;
pre = cur;
cur = next;
}
return head;
}
@Override
public String toString() {
if (head == null && head == last) {
return "NodeChain {}";
}
StringBuilder sb = new StringBuilder();
// 将所有的子节点递归处理
Node node = head;
sb.append("NodeChain {");
while (node != null) {
sb.append('\n')
.append('[')
.append(node.toString())
.append(']')
.append(',');
node = node.next;
if (node == head) {
break;
}
}
sb.append('}');
return sb.toString();
}
class Node {
int index;
E data;
Node next;
Node previous;
public Node(int index, E data) {
super();
this.index = index;
this.data = data;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
@Override
public String toString() {
String str = "Node {index:" + index + ", data : " + data.toString() + '}';
if (next != null) {
str += ", next = " + next.index;
} else {
str += ", next is empty";
}
if (previous != null) {
str += ", previous = " + previous.index;
} else {
str += ", previous is empty";
}
return str;
}
}
}