循环链表
单向循环链表
单向循环链表的结构
尾结点的next，指向头结点
当只有一个结点
接口设计
相较于单向链表，单向循环链表需要重写插入结点、删除结点两个方法
- 插入节点，需要特别关注插入头节点的情况。此时需要拿到尾节点，然后将其next指向新节点。
public class SingleCircleLinkedList<E> extends AbstractList<E> {
......
/**
* 往index位置添加元素 --- 改造
* @param index
* @param element
*/
public void add(int index, E element){
//边界判断
rangeCheckForAdd(index);
if (index == 0){// 给空链表添加第一个元素的情况
//创建新节点
Node<E> newFirst = new Node<>(element,first);
//拿到最后一个节点
Node<E> last = (size==0) ? newFirst : node(size - 1 );
//尾指向头
last.next = newFirst;
//头指向
first = newFirst;
}else {
//index上一个节点
Node<E> prev = node(index - 1);
//创建新节点，prev节点指向这个新节点
prev.next = new Node<>(element, prev.next);
}
size++;
}
......
}
- 如果删除的是头节点，删除后需让last指向新的头节点
- 当只有一个节点并删除时, first指向null
public class SingleCircleLinkedList<E> extends AbstractList<E> {
......
/**
* 删除index位置对应的元素 --- 改造
* @param index
* @return
*/
public E remove(int index){
//边界判断
rangeCheck(index);
//记录节点
Node<E> node = first;
if (index == 0){ // 删除第一个元素是特殊情况
// 只有一个节点
if (size == 1){
first = null;
}else {
//拿到最后一个节点
Node<E> last = node(size - 1);
first = first.next;
last.next = first;
}
}else {
//index上一个节点
Node<E> prev = node(index - 1);
//记录删除的节点
node = prev.next;
//node节点下一个节点，prev节点指向这个节点
prev.next = node.next;
}
size --;
return node.element;
}
......
}
完整代码
/**
* 单向循环链表的实现
* @param <E> 泛型
*/
public class SingleCircleLinkedList<E> extends AbstractList<E> {
/**
* 元素所在的结点
*/
private Node<E> first;
/**
* 内部类 结点
* @param <E>
*/
private static class Node<E>{
E element;//元素
Node<E> next;//下个元素的地址
public Node(E element, Node<E> next) {
this.element = element;
this.next = next;
}
}
/**
* 返回index位置对应的元素
* @param index
* @return
*/
public E get(int index){
return node(index).element;
}
/**
* 设置index位置的元素
* @param index
* @param element
* @return
*/
public E set(int index, E element){
Node<E> node = node(index);
E old = node.element;
node.element = element;
return old;
}
/**
* 往index位置添加元素 --- 改造
* @param index
* @param element
*/
public void add(int index, E element){
//边界判断
rangeCheckForAdd(index);
if (index == 0){// 给空链表添加第一个元素的情况
//创建新节点
Node<E> newFirst = new Node<>(element,first);
//拿到最后一个节点
Node<E> last = (size==0) ? newFirst : node(size - 1 );
//尾指向头
last.next = newFirst;
//头指向
first = newFirst;
}else {
//index上一个节点
Node<E> prev = node(index - 1);
//创建新节点，prev节点指向这个新节点
prev.next = new Node<>(element, prev.next);
}
size++;
}
/**
* 删除index位置对应的元素 --- 改造
* @param index
* @return
*/
public E remove(int index){
//边界判断
rangeCheck(index);
//记录节点
Node<E> node = first;
if (index == 0){ // 删除第一个元素是特殊情况
// 只有一个节点
if (size == 1){
first = null;
}else {
//拿到最后一个节点
Node<E> last = node(size - 1);
first = first.next;
last.next = first;
}
}else {
//index上一个节点
Node<E> prev = node(index - 1);
//记录删除的节点
node = prev.next;
//node节点下一个节点，prev节点指向这个节点
prev.next = node.next;
}
size --;
return node.element;
}
/**
* 查看元素的位置
* @param element
* @return
*/
public int indexOf(E element){
// 取出头结点
Node<E> node = first;
if(element ==null){// 当element为null时的处理
// 遍历节点, 找到存储为null的节点, 返回索引
for (int i = 0; i < size; i++) {
if (node.element == null) return i;
node = node.next;
}
}else {
// 遍历节点, 找到存储的元素与指定元素相等的节点, 返回索引
for (int i = 0; i < size; i++) {
if (element.equals(node.element)) return i;
node = node.next;
}
}
return ELEMENT_NOT_FOUND;
}
/**
* 清除所有元素
*/
public void clear(){
size = 0;
first = null;
}
/**
* 获取index位置对应的节点对象
* @param index
* @return
*/
private Node<E> node(int index){
rangeCheck(index);
Node<E> node = first;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node;
}
/**
* 打印
* @return
*/
@Override
public String toString() {
//Size = ? , [1, 2, 3]
StringBuilder string = new StringBuilder();
string.append("size=").append(size).append(", [");
Node<E> node = first;
for (int i = 0; i < size; i++) {
if (i != 0){
string.append(", ");
}
string.append(node.element);
node = node.next;
}
string.append("]");
return string.toString();
}
}
双向循环链表
双向循环链表的结构
- 头节点的prev指向尾节点。
- 尾节点的next指向头节点。
当只有一个节点
接口设计
相较于双向链表，双向循环链表需要重写插入节点、删除节点两个方法
- 需特殊处理添加第一个元素和添加到尾节点两种特殊情况
public class DulCircleLinkedList<E> extends AbstractList<E> {
......
/**
* 往index位置添加元素 --- 改造
* @param index
* @param element
*/
public void add(int index, E element){
//边界判断
rangeCheckForAdd(index);
// size == 0
// index == 0
if (index == size){//往最后添加元素
Node<E> oldLast = last;
last = new Node<>(element,oldLast,first);
if (oldLast == null){//这是链表的第一个元素
first = last;
//指向第一个节点
first.next = first;
first.prev = first;
}else {
oldLast.next = last;
first.prev = last;
}
}else {// 正常添加元素
//插入位置的原结点，即为新节点的next节点
Node<E> next = node(index);
//新添加结点的上一个节点，即为该位置原节点的上一个节点
Node<E> prev = next.prev;
//创建新结点
Node<E> node = new Node<>(element,prev,next);
//原结点上一个结点的next，即为新添加节点
prev.next = node;
//原结点的上一个结点，为新添加结点
next.prev = node;
if (next == first){//index == 0 即添加的是第一个
first = node;
}
}
size++;
}
......
}
- 删除节点，就是在环上去掉某一个节点，然后根据删除的节点是首节点或者尾节点来处理first和last
- 需要特殊处理只有一个节点的删除操作
public class DulCircleLinkedList<E> extends AbstractList<E> {
......
/**
* 删除index位置对应的元素 --- 改造
* @param index
* @return
*/
public E remove(int index){
//边界判断
rangeCheck(index);
Node<E> node = first;
if (size == 1){
first = null;
last = null;
}else {
//删除的结点
node = node(index);
//删除结点的上一个结点
Node<E> prev = node.prev;
//删除结点的下一个结点
Node<E> next = node.next;
prev.next = next;
next.prev = prev;
//删除结点, 只需去掉对这个结点的引用
if (node == first){//index == 0 即删除的是第一个
first = next;
}
if (next == last){//index == size - 1 即删除的是最后一个
last = prev;
}
}
size --;
return node.element;
}
......
}
完整代码
/**
* 双向循环链表的实现
* @param <E> 泛型
*/
public class DulCircleLinkedList<E> extends AbstractList<E> {
/**
* 元素所在的结点
*/
private Node<E> first;
//增加last节点
private Node<E> last;
/**
* 内部类 结点
* @param <E>
*/
private static class Node<E>{
E element;//元素
Node<E> prev;//增加上一个元素地址
Node<E> next;//下个元素的地址
public Node(E element, Node<E> prev,Node<E> next) {
this.element = element;
this.prev = prev;
this.next = next;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
if (prev !=null){
sb.append(prev.element);
}else {
sb.append("null");
}
sb.append("_").append(element).append("_");
if (next !=null){
sb.append(next.element);
}else {
sb.append("null");
}
return sb.toString();
}
}
/**
* 返回index位置对应的元素
* @param index
* @return
*/
public E get(int index){
return node(index).element;
}
/**
* 设置index位置的元素
* @param index
* @param element
* @return
*/
public E set(int index, E element){
Node<E> node = node(index);
E old = node.element;
node.element = element;
return old;
}
/**
* 往index位置添加元素 --- 改造
* @param index
* @param element
*/
public void add(int index, E element){
//边界判断
rangeCheckForAdd(index);
// size == 0
// index == 0
if (index == size){//往最后添加元素
Node<E> oldLast = last;
last = new Node<>(element,oldLast,first);
if (oldLast == null){//这是链表的第一个元素
first = last;
//指向第一个节点
first.next = first;
first.prev = first;
}else {
oldLast.next = last;
first.prev = last;
}
}else {// 正常添加元素
//插入位置的原结点，即为新节点的next节点
Node<E> next = node(index);
//新添加结点的上一个节点，即为该位置原节点的上一个节点
Node<E> prev = next.prev;
//创建新结点
Node<E> node = new Node<>(element,prev,next);
//原结点上一个结点的next，即为新添加节点
prev.next = node;
//原结点的上一个结点，为新添加结点
next.prev = node;
if (next == first){//index == 0 即添加的是第一个
first = node;
}
}
size++;
}
/**
* 删除index位置对应的元素 --- 改造
* @param index
* @return
*/
public E remove(int index){
//边界判断
rangeCheck(index);
Node<E> node = first;
if (size == 1){
first = null;
last = null;
}else {
//删除的结点
node = node(index);
//删除结点的上一个结点
Node<E> prev = node.prev;
//删除结点的下一个结点
Node<E> next = node.next;
prev.next = next;
next.prev = prev;
//删除结点, 只需去掉对这个结点的引用
if (node == first){//index == 0 即删除的是第一个
first = next;
}
if (next == last){//index == size - 1 即删除的是最后一个
last = prev;
}
}
size --;
return node.element;
}
/**
* 查看元素的位置
* @param element
* @return
*/
public int indexOf(E element){
// 取出头结点
Node<E> node = first;
if(element ==null){// 当element为null时的处理
// 遍历节点, 找到存储为null的节点, 返回索引
for (int i = 0; i < size; i++) {
if (node.element == null) return i;
node = node.next;
}
}else {
// 遍历节点, 找到存储的元素与指定元素相等的节点, 返回索引
for (int i = 0; i < size; i++) {
if (element.equals(node.element)) return i;
node = node.next;
}
}
return ELEMENT_NOT_FOUND;
}
/**
* 清除所有元素
*/
public void clear(){
size = 0;
first = null;
last = null;
}
/**
* 获取index位置对应的节点对象
* @param index
* @return
*/
private Node<E> node(int index){
rangeCheck(index);
//往后
if (index < (size >> 1)){
Node<E> node = first;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node;
}else {//往前
Node<E> node = last;
for (int i = size - 1; i > index; i--) {
node = node.prev;
}
return node;
}
}
/**
* 打印
* @return
*/
@Override
public String toString() {
//Size = ? , [1, 2, 3]
StringBuilder string = new StringBuilder();
string.append("size=").append(size).append(", [");
Node<E> node = first;
for (int i = 0; i < size; i++) {
if (i != 0){
string.append(", ");
}
string.append(node);
node = node.next;
}
string.append("]");
return string.toString();
}
}
如何发挥循环链表的最大威力？
约瑟夫问题
可以考虑增设1个成员变量、3个方法：
- current ：用于指向某个节点
- void reset() ：让 current 指向头结点 first
- E next()：让 current 往后走一步，也就是 current = current.next
- E remove() ：删除 current 指向的节点，删除成功后让 current 指向下一个节点
在双向循环链表的基础上增强
/**
* 双向循环链表的实现 --- 增强
* @param <E> 泛型
*/
public class DulCircleLinkedListPlus<E> extends AbstractList<E> {
/**
* 元素所在的结点
*/
private Node<E> first;
//增加last节点
private Node<E> last;
//用来指向某节点
private Node<E> current;
/**
* 内部类 结点
* @param <E>
*/
private static class Node<E>{
E element;//元素
Node<E> prev;//增加上一个元素地址
Node<E> next;//下个元素的地址
public Node(E element, Node<E> prev,Node<E> next) {
this.element = element;
this.prev = prev;
this.next = next;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
if (prev !=null){
sb.append(prev.element);
}else {
sb.append("null");
}
sb.append("_").append(element).append("_");
if (next !=null){
sb.append(next.element);
}else {
sb.append("null");
}
return sb.toString();
}
}
/**
* 返回index位置对应的元素
* @param index
* @return
*/
public E get(int index){
return node(index).element;
}
/**
* 设置index位置的元素
* @param index
* @param element
* @return
*/
public E set(int index, E element){
Node<E> node = node(index);
E old = node.element;
node.element = element;
return old;
}
/**
* 往index位置添加元素 --- 改造
* @param index
* @param element
*/
public void add(int index, E element){
//边界判断
rangeCheckForAdd(index);
// size == 0
// index == 0
if (index == size){//往最后添加元素
Node<E> oldLast = last;
last = new Node<>(element,oldLast,first);
if (oldLast == null){//这是链表的第一个元素
first = last;
//指向第一个节点
first.next = first;
first.prev = first;
}else {
oldLast.next = last;
first.prev = last;
}
}else {// 正常添加元素
//插入位置的原结点，即为新节点的next节点
Node<E> next = node(index);
//新添加结点的上一个节点，即为该位置原节点的上一个节点
Node<E> prev = next.prev;
//创建新结点
Node<E> node = new Node<>(element,prev,next);
//原结点上一个结点的next，即为新添加节点
prev.next = node;
//原结点的上一个结点，为新添加结点
next.prev = node;
if (next == first){//index == 0 即添加的是第一个
first = node;
}
}
size++;
}
/**
* 删除index位置对应的元素 --- 改造
* @param index
* @return
*/
public E remove(int index){
//边界判断
rangeCheck(index);
return remove(node(index));
}
/**
* 根据节点删除 --- 新增
* @param node
* @return
*/
private E remove(Node<E> node){
if (size == 1){
first = null;
last = null;
}else {
//删除结点的上一个结点
Node<E> prev = node.prev;
//删除结点的下一个结点
Node<E> next = node.next;
prev.next = next;
next.prev = prev;
//删除结点, 只需去掉对这个结点的引用
if (node == first){//index == 0 即删除的是第一个
first = next;
}
if (next == last){//index == size - 1 即删除的是最后一个
last = prev;
}
}
size --;
return node.element;
}
/**
* 查看元素的位置
* @param element
* @return
*/
public int indexOf(E element){
// 取出头结点
Node<E> node = first;
if(element ==null){// 当element为null时的处理
// 遍历节点, 找到存储为null的节点, 返回索引
for (int i = 0; i < size; i++) {
if (node.element == null) return i;
node = node.next;
}
}else {
// 遍历节点, 找到存储的元素与指定元素相等的节点, 返回索引
for (int i = 0; i < size; i++) {
if (element.equals(node.element)) return i;
node = node.next;
}
}
return ELEMENT_NOT_FOUND;
}
/**
* 清除所有元素
*/
public void clear(){
size = 0;
first = null;
last = null;
}
/**
* 获取index位置对应的节点对象
* @param index
* @return
*/
private Node<E> node(int index){
rangeCheck(index);
//往后
if (index < (size >> 1)){
Node<E> node = first;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node;
}else {//往前
Node<E> node = last;
for (int i = size - 1; i > index; i--) {
node = node.prev;
}
return node;
}
}
/**
* 重置 指向头节点 --- 新增
*/
public void reset(){
current = first;
}
/**
* current的下一个节点 --- 新增
* @return
*/
public E next(){
if (current == null) return null;
current = current.next;
return current.element;
}
/**
* 删除current指向的节点，删除成功后让current指向下一个节点 --- 新增
* @return
*/
public E remove(){
if (current == null) return null;
Node<E> next= current.next;
E element = remove(current);
if (size == 0){
current = null;
}else {
current = next;
}
return element;
}
/**
* 打印
* @return
*/
@Override
public String toString() {
//Size = ? , [1, 2, 3]
StringBuilder string = new StringBuilder();
string.append("size=").append(size).append(", [");
Node<E> node = first;
for (int i = 0; i < size; i++) {
if (i != 0){
string.append(", ");
}
string.append(node);
node = node.next;
}
string.append("]");
return string.toString();
}
}
解决约瑟夫问题
public class Test {
public static void main(String[] args) {
josephus();
}
public static void josephus(){
DulCircleLinkedListPlus<Integer> list = new DulCircleLinkedListPlus<>();
for(int i = 1; i <= 8; i++){
list.add(i);
}
list.reset(); // current->1
while(!list.isEmpty()){
list.next();
list.next();
System.out.println(list.remove());
}
}
}
静态链表
前面所学习的链表，是依赖于指针（引用）实现的，有些编程语言是没有指针的，比如早期的 BASIC、FORTRAN 语言，没有指针的情况下，如何实现链表？
- 可以通过数组来模拟链表，称为静态链表
- 数组的每个元素存放 2 个数据：值、下个元素的索引
- 数组 0 位置存放的是头结点信息
可以表示如下结构
思考：如果数组的每个元素只能存放 1 个数据呢？
- 那就使用 2 个数组，1 个数组存放索引关系，1 个数组存放值