环形单链表

一）链表简介

链表概念：链表是一种物理存储单元上非连续、非顺序的存储结构，也就是说链表存储的数据不一定是有序的。

链表结构：链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

 

单链表：每一个结点中，包含一个数据域，一个指针域，该指针域一直指向下一个结点。

单链表缺点：查找某个元素时，要从头开始找起。

环形单链表图解：头部结点（head），数据域（data）、指针域（next），尾部结点next指向head。

 

二）环形单链表

第一步：初始化环形单链表结构

/**
 * 自定义环形单链表
 * @author ouyangjun
 */
public class LoopSingleChainTable<E> {
    
    /** 初始化单链表结构 */
    static class Node<E> {
        E data; // 数据域
        Node<E> next; // 指针域, 指向下一结点
        
        Node(E x) { data = x; }
    }
    
    private Node<E> head; // 指向头部结点
    private final AtomicInteger count = new AtomicInteger(); // 环形链表结点数量
}

 

第二步：添加结点。

场景一：在头部添加结点a，把结点a的next指向a1结点，再把结点an的next指向结点a，最后把结点a作为新的head结点。

 

场景二：在尾部添加结点a，把结点a的next指向a1结点，再把尾部结点an的next指向结点a。

/** 在头部添加结点 */
public Node<E> addHead(E e) {
    return addNode(e, true);
}
    
/** 在尾部添加结点 */
public Node<E> addEnd(E e) {
    return addNode(e, false);
}
    
private Node<E> addNode(E e, boolean position) {
    if (e == null) throw new NullPointerException();
        
    Node<E> newNode = new Node<E>(e); // 新结点
        
    Node<E> headNode = head;
    if (headNode == null) {
        head = newNode; // 把新结点直接作为头部结点
        newNode.next = head; // 把新结点的next指向头部结点, 构造成一个环形链表
    } else {
        newNode.next = headNode; // 把新结点的next指向头部结点
    		
        while (headNode.next != head) { // 判断next的结点是否和头结点一致, 如一致, 表示链表循环完了
            headNode = headNode.next; // 一直循环到最后一个结点
        }
        headNode.next = newNode; // 把环形链表尾部结点的next指向新节点, 构造成一个环形链表
        	
        // 默认在头部添加结点
        if (position) {
            head = newNode; // 把head指向新结点,相当于在头部添加结点
        }
    }
        
    // 累计环形链表结点数量
    final AtomicInteger count = this.count;
    count.getAndIncrement();
    return newNode;
}
    
/** 环形链表结点数量 */
public int size() {
    return count.get();
}

 

场景三：在指定下标位置添加结点。在结点a2和a3直接添加结点a，需要用到两个临时辅助结点，一个临时辅助结点记录结点a2的位置，一个临时结点记录结点a3的位置。把结点a2的next指向结点a，再把结点a的next指向结点a3，即完成添加。需考虑在头部、在中间、在尾部添加的情况。

/** 在指定下标位置添加结点 */
public Node<E> add(int index, E e) {
    if (index < 0 || index > size()) throw new IllegalArgumentException();
    if (e == null) throw new NullPointerException();
        
    Node<E> newNode = new Node<E>(e); // 新结点
        
    Node<E> headNode = head;
    if (index == 0) { // 在头部添加结点
        return addHead(e);
    } else if (index == size()) { // 在尾部添加结点
        return addEnd(e);
    } else {
        Node<E> currentNode = head;
        int position = 0;
        	
        while (currentNode.next != head) { // 判断next的结点是否和头结点一致, 如一致, 表示链表循环完了
            if (index == position++) {
                headNode.next = newNode;
                newNode.next = currentNode;
        			
                // 累计环形链表结点数量
                final AtomicInteger count = this.count;
                count.getAndIncrement();
                break;
            } else {
                headNode = currentNode;
                currentNode = currentNode.next;
            }
        }
         return newNode;
    }
}

 

第三步：删除结点

场景一：删除一个head结点a1，把尾部结点an的next指向结点a2，最后把结点a2作为新的head结点。

/** 删除一个头部结点 */
public Node<E> removeHead() {
    if (size() > 0) {
        Node<E> headNode = head; // 头部结点
        	
        Node<E> currentNode = head;
        while (currentNode.next != head) {
            currentNode = currentNode.next;
        }
        head = head.next; // 把head结点的下一个结点作为新的head结点
        currentNode.next = head; // 把尾部结点的next指向新的head结点
        	
        // 累减
        count.getAndDecrement();
        // 返回
        return headNode;
    }
    return null;
}

 

场景二：删除一个尾部结点an，把结点a3的next指向head结点a1，结点a3为尾部结点。

/** 删除一个尾部结点 */
public Node<E> removeEnd() {
    if (size() > 0) {
        Node<E> headNode = head; // 头部结点
        	
        Node<E> currentNode = head; // 临时辅助结点
        while (currentNode.next != head) {
            headNode = currentNode;
            currentNode = currentNode.next;
        }
        headNode.next = head; // 把倒数第二个结点指向head结点
        	
        // 累减
        count.getAndDecrement();
        // 返回
        return currentNode;
    }
    return null;
}

 

场景三：删除指定下标位置的结点a2，把head结点a1的next指向a3即可。需考虑在头部、在中间、在尾部删除的情况。

/** 删除指定下标位置的结点 */
public Node<E> remove(int index) {
    if (index < 0 || index > size()) throw new IllegalArgumentException();
    	
    if (index == 0) { // 删除头部结点
        return removeHead();
    } else if (index == size()) { // 删除尾部结点
        return removeEnd();
    } else {
        Node<E> headNode = head;
        Node<E> currentNode = head;
    		
        int position = 0;
        while (index != position++) {
            headNode = currentNode;
            currentNode = currentNode.next;
        }
        headNode.next = currentNode.next;
        	
        // 累减
        count.getAndDecrement();
        return currentNode;
    }
}

 

场景四：删除指定data的结点，和场景三类似。

/** 删除指定data的结点 */
public Node<E> remove(E e) {
    if (e == null) throw new NullPointerException();
    	
    Node<E> headNode = head;
    if (e.equals(headNode.data)) {
        return removeHead();
    } else {
        Node<E> currentNode = head;
        while (currentNode.next != null) {
            if (e.equals(currentNode.next.data)) {
                headNode = currentNode;
                currentNode = currentNode.next;
                    
                // 累减
                count.getAndDecrement();
                break;
            } else {
                headNode = headNode.next;
                currentNode = currentNode.next;
            }
        }
        headNode.next = currentNode.next;
        // 返回
        return currentNode;
    }
}

 

第四步：查找结点，判断结点是否存在环形链表中

/** 判断结点是否存在环形链表中 */
public boolean get(E e) {
    if (e == null) throw new NullPointerException();
    	
    Node<E> headNode = head;
    int position = 0;
    while (position != size()) {
        if (e.equals(headNode.data)) {
            return true;
        } else {
            headNode = headNode.next;
            position++;
        }
    }
    return false;
}

 

第五步：正序输出环形单链表结点

/** 正序输出环形单链表结点 */
public void inProperOrder() {
    System.out.print("正序输出环形单链表结点:\t");
    	
    Node<E> headNode = head;
    int position = 0;
    while (position != size()) {
        System.out.print(headNode.data + "\t");
        headNode = headNode.next;
			
        position++;
    }
}

 

第六步：利用Stack的“先进后出、后进先出”的特性, 高效逆序输出环形单链表结点

/**利用Stack的“先进后出、后进先出”的特性, 高效逆序输出环形单链表结点*/
public void  invertedSequence() {
    Stack<E> stack = new Stack<E>();
		
    Node<E> headNode = head;
    int position = 0;
    while (position != size()) {
        stack.push(headNode.data);
        headNode = headNode.next;
			
        position++;
    }
		
    System.out.print("高效逆序输出环形单链表结点:\t");
    while (!stack.isEmpty()) {
        System.out.print(stack.pop()+"\t");
    }
}

 

识别二维码关注个人微信公众号

本章完结，待续，欢迎转载！
 
本文说明：该文章属于原创，如需转载，请标明文章转载来源！