LinkedList 实现

下面是LinkedList实现

package charpter3;

import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class MyLinkedList<AnyType> implements Iterable<AnyType>{

	private static class Node <AnyType>{
		public AnyType data ;
		public Node< AnyType>  prev ;
		public Node<AnyType> next ;
		public Node(AnyType d, Node< AnyType> p, Node<AnyType> n){
			data =d ;
			prev = p;
			next = n ;
		}
	}

	private int theSize ;
	private int modCount =0;
	private Node<AnyType> beginMarker ;
	private Node<AnyType> endMarker;

	public MyLinkedList(){
		clear ();
	}

	public void clear() {
		beginMarker = new Node<AnyType>(null, null, null) ;
		endMarker = new Node<AnyType>(null, beginMarker, null) ;
		beginMarker.next = endMarker;

		theSize =0;
		modCount ++;
	}

	public int size(){
		return theSize;
	}

	public boolean isEmpty (){
		return size()==0;
	}
	/**
	 * add to the last
	 * @param x
	 * @return
	 */
	public boolean add (AnyType x ){
		add(size(), x);
		return true ;
	}

	public void add (int idx , AnyType x){
		addBefore(getNode(idx), x) ;
	}
	public AnyType get (int idx ){
		return getNode(idx).data ;
	}
	/**
	 *
	 * @param idx
	 * @param newVal
	 * @return oldVal
	 */
	public AnyType set(int idx , AnyType newVal ){
		Node<AnyType> p = getNode(idx) ;
		AnyType oldVal = p.data ;
		p.data = newVal ;
		return oldVal ;
	}
	public AnyType remove (int idx ){
		return remove(getNode(idx)) ;
	}

	public Node<AnyType> getNode(int idx){
		Node<AnyType> p;
		if (idx<0|| idx>size()){
			throw new IndexOutOfBoundsException() ;
		}
		//分两种,加快速度
		if (idx>size()/2){
			p= beginMarker.next ;
			for (int i =0;i<idx;i++){
				p=p.next ;
			}
		}else {
			 p= endMarker;
			 for (int i=0;i>idx ;i--){
				 p=p.prev ;
			 }
		}
		return p;
	}

	/**
	 * before add:pre--->p
	 * after add: pre--->x--->p
	 * @param p
	 * @param x
	 */
	public void addBefore(Node<AnyType> p ,AnyType x){
		Node<AnyType> newNode = new Node<AnyType>(x, p.prev, p);
		newNode.prev.next= newNode;
		p.prev = newNode ;
		theSize++;
		modCount++;
	}
	/**
	 * pre--->p--->next
	 * @param p
	 * @return
	 */
	private AnyType remove (Node<AnyType> p){
		p.next.prev= p.prev;
		p.prev.next=p.next;
		theSize--;
		modCount++;
		return p.data ;
	}

	public Iterator<AnyType> iterator() {
		// TODO Auto-generated method stub
		return new LinkedListIterator() ;
	}

	private class LinkedListIterator implements Iterator<AnyType>{
		private Node<AnyType> current = beginMarker.next ;
		private int expectedModCount = modCount ;
		private boolean okToRemove = false ;

		public boolean hasNext() {
			// TODO Auto-generated method stub
			return current!= endMarker;
		}

		public AnyType next() {
			if (modCount!= expectedModCount){
				throw new ConcurrentModificationException() ;
			}
			if (!hasNext()){
				throw new NoSuchElementException() ;
			}
			AnyType nextItem = current.data ;
			current = current.next;
			okToRemove = true ;
			return nextItem;
		}

		@Override
		public void remove() {
			if (modCount!= expectedModCount){
				throw new ConcurrentModificationException() ;
			}
			if (!okToRemove){
				throw new IllegalStateException() ;
			}
			MyLinkedList.this.remove(current.prev) ;
			okToRemove = false ;
			expectedModCount++ ;
		}

	}

}

  

时间: 2024-10-12 02:54:53

LinkedList 实现的相关文章

Java中ArrayList和LinkedList区别

一般大家都知道ArrayList和LinkedList的大致区别:      1.ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构.      2.对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针.      3.对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据. ArrayList和LinkedList是两个集合类,用于存储一系列的对象引用

ArrayList&amp;LinkedList&amp;Map&amp;Arrays

Java集合框架 1:集合接口 1.1:Collection接口 Collection接口是构造集合框架的基础.它声明所有类集合都将拥有的核心方法 Boolean add(Object obj) 将obj加入到调用类集合中,加入返回true 否则 返回 false Boolean addAll(Collection c) 将c中所有元素都加入到类集合中,都加入返回true否则 false Void clean() 从调用类集合中删除所有元素 Boolean contains(Object obj

Java集合类库 LinkedList 源码解析

基于JDK 1.7,和ArrayList进行比较分析 Java已经有了ArrayList,用来存放元素,对元素的操作都很方便.为什么还会有LinkedList呢?我们都知道ArrayList获取元素很快,但是插入一个元素很慢,因为ArrayList底层维护的是一个数组,往数组中的某个位置插入一个元素,是很消耗资源的. 而LinkedList插入元素很快,获取任意位置的元素却很慢.这是为什么呢?底层又是怎样实现的呢? 1.继承关系 LinkedList的继承关系图: LinkedList继承的是A

To Java程序员:切勿用普通for循环遍历LinkedList

ArrayList与LinkedList的普通for循环遍历 对于大部分Java程序员朋友们来说,可能平时使用得最多的List就是ArrayList,对于ArrayList的遍历,一般用如下写法: public static void main(String[] args) { List<Integer> arrayList = new ArrayList<Integer>(); for (int i = 0; i < 100; i++) arrayList.add(i);

从头认识java-9.7 LinkedList

这一章节我们来简单介绍一个LinkedList的一些方法与特性. 1.特性 在中间插入或者删除元素会比ArrayList的性能好,但是有不一定的情况,请点击(List的简介与性能),里面有一个简单的测试 2.方法演示 package com.ray.ch09; import java.util.Arrays; import java.util.LinkedList; public class Test { public static void main(String[] args) { Link

java的List接口的实现类 ArrayList,LinkedList,Vector 的区别

Java的List接口有3个实现类,分别是ArrayList.LinkedList.Vector,他们用于存放多个元素,维护元素的次序,而且允许元素重复. 3个具体实现类的区别如下: 1. ArrayList是最常用的List实现类,内部是通过数组实现的,它允许对元素进行快速随机访问.数组的缺点是每个元素之间不能有间隔,当数组大小不满足时需要增加存储能力,就要将已经有数组的数据复制到新的存储空间中.当从ArrayList的中间位置插入或者删除元素时,需要对数组进行复制.移动.代价比较高.因此,它

Java 集合之LinkedList源码分析

1.介绍 链表是数据结构中一种很重要的数据结构,一个链表含有一个或者多个节点,每个节点处理保存自己的信息之外还需要保存上一个节点以及下一个节点的指针信息.通过链表的表头就可以访问整个链表的信息.Java API中提供了链表的Java实现---LinkedList下.LinkedList是通过节点的连接实现链表的数据结构,向linkedList中插入或删除元素的速度是特别快,而随机访问的速度相对较慢,这个是由于链表本身的性质造成的,在链表中,每个节点都包含了前一个节点的引用,后一个节点的引用和节点

ArrayList和LinkedList的区别

从字面上大概可以猜出ArrayList是用数组实现的的一种数据结构:LinkedList采用链表实现.那么要剖析区别的话大概可以概括到数组和链表的区别.结合在数据结构课上所学,我大概可以猜出几点区别,无外乎数组采用连续的内存空间存储数据,链表中用到了引用,那么存储的内容可以不在连续的内存空间里.以上是假如不会ArrayList和LinkedList的前提下做的假设.实际上两者主要区别有三点. 1.ArrayList是使用动态数组实现的数据结构,LinkedList使用双链表实现   2.Arra

List、ArrayList、LinkedList的区别及使用

首先我们要知道List是java中的接口,而不是实现类,所以它是不能实例化的,例如以下代码: 1 public static void main(String[] args) { 2 List list=new List(); 3 4 } java中会报错,而ArrayList和LinkedList是实现了这个接口的实现类,可以进行实例化,其定义如下: 1 public static void main(String[] args) { 2 3 ArrayList list1=new Array

Java中arraylist和linkedlist源代码分析与性能比較

Java中arraylist和linkedlist源代码分析与性能比較 1,简单介绍 在java开发中比較经常使用的数据结构是arraylist和linkedlist,本文主要从源代码角度分析arraylist和linkedlist的性能. 2,arraylist源代码分析 Arraylist底层的数据结构是一个对象数组.有一个size的成员变量标记数组中元素的个数,例如以下图: * The array buffer into which the elements of the ArrayLis