数据结构与算法系列之＜5＞----链表（双向）

已于 2022-02-16 15:28:39 修改
阅读量362 收藏
点赞数
分类专栏： # 数据结构 文章标签： 链表 数据结构
于 2022-02-11 19:35:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JH_Cao/article/details/122887383
版权

1、双向链表

在这里插入图片描述

2、clear

	@Override
	public void clear() {
		size = 0;
		first = null;
		last = null;
	}

3、add

  • 1.添加在第一个位置：
    在这里插入图片描述
  • 2.添加在中间
    在这里插入图片描述
  • 3.在末尾
    在这里插入图片描述
  • 4.原来的链表为空
    在这里插入图片描述
public void add(int index, E element) {
		rangeCheckForAdd(index);
		
		if (index == size) {  // 3.往最后面添加元素
			Node<E> oldLast = last;
			last = new Node<>(element, null, oldLast);
			if (oldLast == null) { // size == 0  index == 0 4.原来链表为空
				first = last;
			} else {
				oldLast.next = last;
			}
			
			
		} else {
			Node<E> next = node(index);
			Node<E> prev = next.prev;
			Node<E> node = new Node<>(element, next, prev);
			
			if (prev == null) { // 1.第一个位置添加
				first = node;
			} else { // 2.中间位置添加
				prev.next = node;
			}
			next.prev = node;
		}
		
		size ++;
		
		
	}

4.remove

参考上面的图片，主要分从头部、尾部、中间删除三种情景考虑

public E remove(int index) {
		rangeCheck(index);
		
		Node<E> node = node(index);
		Node<E> prevNode = node.prev;
		Node<E> nexNode = node.next;
		
		if (prevNode == null) { // 删除头部
			nexNode.prev = null;
			first = nexNode;
		} else if (nexNode == null) { // 删除尾部
			prevNode.next = null;
			last = prevNode;
		} else {
			prevNode.next = node.next;
			node.next.prev = prevNode;
		} 
		
		size--;
		
		return node.element;
	}

5、继承关系图

在这里插入图片描述

  • List代码
package com.jh;

public interface List<E> {
    static final int ELEMENT_NOT_FOUND = -1;
    /**
     * 清除所有元素
     */
    void clear();

    /**
     * 元素的数量
     * @return
     */
    int size();

    /**
     * 是否为空
     * @return
     */
    boolean isEmpty();

    /**
     * 是否包含某个元素
     * @param element
     * @return
     */
    boolean contains(E element);

    /**
     * 添加元素到尾部
     * @param element
     */
    void add(E element);

    /**
     * 返回某个元素的索引
     * @param index
     * @return
     */
    E get(int index);

    /**
     * 设置位置的元素
     * @param index
     * @param element
     * @return 原来的元素
     */
    E set(int index, E element);

    /**
     * 在某个位置插入元素
     * @param index
     * @param element
     */
    void add(int index, E element);


    /**
     * 删除某个元素
     * @param index
     * @return
     */
    E remove(int index);

    /**
     * 查看元素的索引
     * @param element
     * @return
     */
    int indexOf(E element);

    @Override
    String toString();


    void rangeCheck(int index);

    /**
     * 保证容量
     * @param capacity
     */
   void ensureCapacity(int capacity);
}
  • AbstractList代码
package com.jh;

public abstract class AbstractList<E> implements List<E> {

    protected int size;

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public boolean contains(E element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

    public void add(E element) {
        add(size, element);
    }

    protected void outOfBounds(int index) {
        throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
    }

    @Override
    public void rangeCheck(int index) {
      if (index < 0 || index >= size) {
    	  outOfBounds(index);
      }
    }

    protected void rangeCheckForAdd(int index) {
        if (index < 0 || index > size) {
            outOfBounds(index);
        }
    }

}
  • LinkedList代码
package com.jh;


public class LinkedList<E> extends AbstractList<E> {

    private Node<E> first;

    private static class Node<E> {
        E element;
        Node<E> next;

        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }
    
    /**
     * 根据索引，获取node
     * @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;
		
	}

    @Override
    public void clear() {
    	size = 0;
    	first = null;
    }




    @Override
    public E get(int index) {
        return (E) node(index);
    }

    @Override
    public E set(int index, E element) {
    	Node<E> node = node(index);
    	E old = node.element;
    	node.element = element;
    	
        return old;
    }

    @Override
    public void add(int index, E element) {
    	if (index == 0) {
			first = new Node<>(element, first);
		} else {
			Node<E> preViousNode = node(index - 1);
	    	preViousNode.next = new Node<>(element, preViousNode.next);
		}
    	
    	size++;
    }

    @Override
    public E remove(int index) {
    	Node<E> node = first;
    	if (index == 0) {
			first = first.next;
		} else {
			Node<E> preNode = node(index - 1);
			node = preNode.next;
	    	preNode.next = node.next;
		}
    	size--;
    	
        return node.element;
    }

    @Override
    public int indexOf(E element) {
    	if (element == null) {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (node.element == null) {
					return i;
				}
				
				node = node.next;
			}
		} else {
			Node<E> node = first;
			for (int i = 0; i < size; i++) {
				if (element.equals(node.element)) {
					return i;
				}
				
				node = node.next;
			}
			
		}
        return ELEMENT_NOT_FOUND;
    }


    @Override
    public void ensureCapacity(int capacity) {

    }


    




//	@Override
//	public void rangeCheck(int index, boolean isForAdd) {
//		// TODO Auto-generated method stub
//		
//	}
	
	@Override
	public String toString() {
		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();
	}
}
  • AbstractList代码
package com.jh;

public abstract class AbstractList<E> implements List<E> {

    protected int size;

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public boolean contains(E element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

    public void add(E element) {
        add(size, element);
    }

    protected void outOfBounds(int index) {
        throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
    }

    @Override
    public void rangeCheck(int index) {
      if (index < 0 || index >= size) {
    	  outOfBounds(index);
      }
    }

    protected void rangeCheckForAdd(int index) {
        if (index < 0 || index > size) {
            outOfBounds(index);
        }
    }

}
  • 打印结果：
    在这里插入图片描述

6、双向循环链表

在这里插入图片描述

package com.jh.circle;
import com.jh.AbstractList;

public class CircleDoubleLinkedList<E> extends AbstractList<E>{
	private Node<E> first;
	private Node<E> last;
	
	private static class Node<E> {
        E element;
        Node<E> next;
        Node<E> prev;

        public Node(E element, Node<E> next, Node<E> prev) {
            this.element = element;
            this.next = next;
            this.prev = prev;
        }
        
        @Override
        public String toString() {
			StringBuilder sBuilder = new StringBuilder();
			
			if (prev != null) {
				sBuilder.append(prev.element);
			} else {
				sBuilder.append("空");
			}
			
			sBuilder.append("<-").append(element).append("->");
			
			if (next != null) {
				sBuilder.append(next.element);
			} else {
				sBuilder.append("空");
			}
			
			return sBuilder.toString();
		}
    }
    
    /**
     * 根据索引，获取node
     * @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;
		
	}

	@Override
	public void clear() {
		// TODO Auto-generated method stub
		size = 0;
		first = null;
		last = null;
		
	}

	@Override
	public E get(int index) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public E set(int index, E element) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void add(int index, E element) {
		rangeCheckForAdd(index);
		
		if (index == size) {  // 往最后面添加元素
			Node<E> oldLast = last;
			last = new Node<>(element, first, oldLast);
			
			if (oldLast == null) { // size == 0  index == 0
				first = last;
				first.next = first;
				first.prev = first;
			} else {
				oldLast.next = last;
				first.prev = last;
			}
			
			
		} else {
			Node<E> next = node(index);
			Node<E> prev = next.prev;
			Node<E> node = new Node<>(element, next, prev);
			next.prev = node;
			prev.next = node;
			if (index == 0) {
				first = node;
			}
		}
		
		size ++;
		
		
	}

	@Override
	public E remove(int index) {
		rangeCheck(index);
		
		Node<E> node = node(index);
		Node<E> prevNode = node.prev;
		Node<E> nexNode = node.next;
		
		if (prevNode == null) { // 删除头部
			nexNode.prev = null;
			first = nexNode;
		} else if (nexNode == null) { // 删除尾部
			prevNode.next = null;
			last = prevNode;
		} else {
			prevNode.next = node.next;
			node.next.prev = prevNode;
		} 
		
		size--;
		
		return node.element;
	}
	
	@Override
	public int indexOf(E element) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public void ensureCapacity(int capacity) {
		// TODO Auto-generated method stub
		
	}
	
	@Override
	public String toString() {
		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.toString());
			
			node = node.next;
		}
		string.append("]");
		return string.toString();
	}

}

在这里插入图片描述

jh_cao
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值