自定义 LinkedList （附代码）

首先定义Node（节点）类，我们需要节点来完成这个LinkedList，每一个节点有三个元素，previous·obj·next（前一个节点现在的对象下一个节点），这里我们定义的是双向链表，除第一个（可以寻找下一个，但不可以寻找上一个，因为没有）和最后一个（同理）以外，我们都可以通过某一个节点寻找上一个节点或者下一个节点。（根据三个元素来寻找上下节点）

/**
 * 定义Node内部类
 */
package CHUTIAN;

public class Node {
	Node previous;			//上一个节点
	Object obj;
	Node next;				//下一个节点
	public Node() {
		
	}
	
	public Node(Node previous, Object obj, Node next) {
		super();
		this.previous = previous;
		this.obj = obj;
		this.next = next;
	}

	public Node getPrevious() {
		return previous;
	}
	public void setPrevious(Node previous) {
		this.previous = previous;
	}
	public Object getObj() {
		return obj;
	}
	public void setObj(Object obj) {
		this.obj = obj;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
	
}

第二步：开始建立容器，把我定义好的节点串起来，将所要添加的对象放进去（重点：自定义add方法）

由于第一个和最后一个节点的特殊性，所以我们需要单独定义这两个节点，当我们往容器里面增加第一个对象的时候，此时容器里面只有一个对象，所以它即是第一个也是最后一个（即是first也是last）因为只有它一个（唯我独尊）

某一天这个容器又增添了新的内容，毕竟他太嫩了，干不过老的，所以它撼动不了first对象，但是它却可以影响它。怎么影响呢？图来说明：

当我们放入第一个节点的时候就是这样子的，p/o/n分别表示节点的三个元素这在我们一开始就已经说明了。

将first = n; last = n;

当我们放入第二个节点的时候：

第一个节点就不再是的最后一个节点，第二个节点成了最后一个节点（终于有对手了[手动维西奥]）：

在first节点里，previous是null，obj是aaa，next是bbb；

在last节点里，previous是aaa，obj是bbb，next是null；

当第三个节点来的时候，第三个就成了last，而bbb也就是中间的既可以通过它寻找到aaa（上一个）也可以通过它寻找到bbb（下一个）：

可能有些人对add方法中else块中的

n.setPrevious(last);
           n.setObj(obj);
           n.setNext(null);

           last.setNext(n);

last = n;

不太理解,前面的两个last在使用的时候都是表示的是上一个节点的last，也就是在我们放这个对象之前放的那个（之前放的对象不就是最后一个吗？就好比如一条管子，一次只能放一个柠檬，一共十个柠檬，当我们放第五个柠檬的时候，第五个就是最后一个柠檬，当我们放第六个的时候，第六个柠檬就成了最后一个柠檬，是不是同个道理？）

最后一个last：我们放了一个对象，那最后一个对象，自然就是我们刚刚放的那个对象（联想一下刚刚说的柠檬)

package CHUTIAN;

public class LinkedList /*implements List*/{
	private Node first;
	private Node last;
	private int size;
	
	public void add(Object obj) {
			Node n = new Node();
		if(first==null) {
			//节点有三个元素：previous obj next
			n.setPrevious(null);
			n.setObj(obj);
			n.setNext(null);
			
			first = n;
			last = n;
			
		}else {
			//直接往节点后面增加一个新的节点
			n.setPrevious(last);
			n.setObj(obj);
			n.setNext(null);
			
			last.setNext(n);
			last = n;
		}
		size++;
	}
	
	public void add(int index,Object obj) {
		/*Node n = new Node();
		if(index!=0) {
		Node tempup = node(index--);		
		Node tempdown = node(index);
		n.previo6us = tempup;
		n.obj = obj;
		n.next = tempdown;
		}else {
			Node tempdown = first;
			n.previous = null;
			n.obj = obj;
			n.next = first;
			first = n;
		}*/
		
		//更好的写法
		Node temp = node(index);
		Node newNode = new Node();
		newNode.obj = obj;
		
		if(temp!=null) {
			Node up = temp.previous;
			up.next = newNode;
			newNode.previous = up;
			
			newNode.next = temp;
			temp.previous = newNode;
					
			size++;
		}

	}
	
	public void RangeCheck(int index) {
		if(index<0||index>=size) {
			try {
				throw new Exception();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	public Node node(int index) {
		RangeCheck(index);
		Node temp = null;
		if(first!=null) {
			temp = first;
			for(int i=0;i<index;i++) {
				//i=0的时候 temp.next（first的下一个即第二个）赋给temp.
				//i=1的时候 temp.next（ 第二个的下一个即第三个）赋给temp.
				//以此类推
				temp = temp.next;
			}
		}
		return temp;
	}	
	
	public Object get(int index) {
		Node temp = node(index);
		if(temp!=null)
			return temp.obj;
		else
			return null;
	}

	//删除指定索引位置的对象
	public void remove(int index) {
		Node temp = node(index);
		if(temp!=null) {
			Node up = temp.previous;
			Node down = temp.next;
			up.next = down;
			down.previous = up;
		}
		size--;
	}
	
	public boolean isEmpty() {
		return size==0;
	}
	
	public int size() {
		return size;
	}
	
	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add(0,"ddd");
		System.out.println(list.get(0));
		System.out.println(list.get(1));
		System.out.println(list.size());
	}
}

:自行服用DeBug 效果更佳

自定义 LinkedList （附代码）

猜你喜欢