数据结构：链表

目录

• 1、链表（Linked List）
• 2、单向链表（Single-Linked List）
  • 　　①、单向链表的图解
  • 　　②、单向链表的具体实现
• 3、双向链表
  • 　　①、双向链表的图解
  • 　　②、双向链表的具体实现
• 4、总结

 1、链表（Linked List）

       链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。

　    使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。

2、单向链表

        单链表是链表中结构最简单的。一个单链表的节点(Node)分为两个部分，第一个部分(data)保存或者显示关于节点的信息，另一个部分存储下一个节点的地址。最后一个节点存储地址的部分指向空值。

　　单向链表只可向一个方向遍历，一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。而插入一个节点，对于单向链表，我们只提供在链表头插入，只需要将当前插入的节点设置为头节点，next指向原头节点即可。删除一个节点，我们将该节点的上一个节点的next指向该节点的下一个节点。

 

 

3.双向链表

 双向链表插入和删除操作：

 

Java实现：

public class ExtLinkedList<E> {
	
	private int size;
	
	public Node<E> first;
	
	private Node<E> last;
	
	public static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }

		public Node() {
		}
	}
           
	
	public void add(E e) {
		final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
	}
	
	public Object get(int index) {
		checkElementIndex(index);
		Node<E> node = null;
		
		if(first!=null) {
			node = first ; //默认为第0个
			for (int i = 0; i < index; i++) {
				 node = node.next;
			}
		}
		return node(index).item;
		
	}
	
	//指定下标删除
	public void remove(int index) {
		checkElementIndex(index);
		Node<E> oldNode = node(index);
		if(oldNode!=null) {
			Node<E> prevNode = oldNode.prev;
			Node<E> nextNode = oldNode.next;
			//如果你删除节点的上个节点为null，即删除第一个元素
			if(prevNode==null) {
				//将下个节点置为first节点
				first = nextNode;
			}else{
				prevNode.next = nextNode;
				//为什么
				oldNode.prev = null;
			}
			//删除节点为最后一个节点
			if(nextNode==null) {
				last = prevNode;
			}else{
				nextNode.prev = prevNode;
				//
				oldNode.next = null;
			}
			
			oldNode.item = null;
			size--;
			
		}
		
	}
	
	//根据下标获取node
	Node<E> node(int index) {
		//二分查找
        if (index < (size >> 1)) {
        	Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
        	Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }
	
	 private String outOfBoundsMsg(int index) {
	        return "Index: "+index+", Size: "+size;
	    }

	 private void checkElementIndex(int index) {
	        if (!isElementIndex(index))
	            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
	    }
	 
	 private boolean isElementIndex(int index) {
	        return index >= 0 && index < size;
	    }
	 
	 //查找指定位置元素
	 public void add(int index, E element) {
	        checkElementIndex(index);
	        //在尾节点添加
	        if(index==size) {
	        	add(element);
	        }else{
	        	Node<E> oldNode = node(index);
		        
		        if(oldNode!=null) {
		        	Node<E> prevNode = oldNode.prev; 
		        	Node<E> newNode = new Node<E>();
		        	newNode.item = element;
		        	
		        	newNode.next = oldNode;
		        	
		        	//添加在第0个节点
		        	if(prevNode==null) {
		        		first = newNode;
		        	}else{
		        		newNode.prev = prevNode;
			        	//插入节点的下一个节点是原来当前位置的节点
		        		prevNode.next = newNode;
		        	}
		        	oldNode.prev = newNode;
		        }
	        }
	        
}