ArrayList和LinkedList

算法

面试题目：

有“非常大量”的数据，取最大的前100大的数据。

代码：
public static void main(String[] args) {
/**
* 有“非常大量”的数据，取最大的前100大的数据。
* 1. 利用随机数模拟非常大量的数据
* 2. 先找到前5个大的
* 3. 然后扩大到100个大的
*/

Random r = new Random();
		long[] arr = new long[5];
		for(int i=0; i<100; i++) {
			long num = r.nextInt(100);
			int index = Arrays.binarySearch(arr, num);
			if(index<0) {
				index = -(index+1);
			}
			if(index==0) { //比第一个元素小或与第一个元素一样
				continue;
			}
			for(int j=1; j<index; j++) {
				arr[j-1]=arr[j];
			}
			arr[index-1]=num;
			System.out.print(index);
			System.out.println(Arrays.toString(arr)); 
		}
		System.out.println(Arrays.toString(arr));
	}

经典数据结构

ArrayList LinkedList TreeSet HashMap

ArrayList 实现

实现 ArrayList 的追加，插入，删除，遍历
代码：
public class MyArrayList{
private Object[] elementData = {};
private int size=0;
/**
* 追加元素
* @param e
* @return
*/

public boolean add(E e) {
			expand();
			elementData[size++]=e;
			return true;
		}
	
	public boolean add(int index, E e) {
		if(index<0 || index>size) {
			throw new ArrayIndexOutOfBoundsException();
		}
		if(index==size) {
			return add(e);
		}
		expand();
		for(int i=size-1; i>=index; i--) {
			elementData[i+1]=elementData[i];
		}
		elementData[index]=e;
		size++;
		return true;
	}

	private void expand() {
		if(size==0) {
			elementData = new Object[10];
		}
		if(size==elementData.length) {
			elementData = Arrays.copyOf(elementData,
					size+(size>>1));
		}
	}
	
	public E remove(int index) {
		if(index<0 || index>=size) {
			throw new ArrayIndexOutOfBoundsException();
		}
		E e = (E)elementData[index];
		for(int i=index+1; i<size; i++) {
			elementData[i-1]=elementData[i];
		}
		elementData[--size]=null;
		return e;
	}

	public String toString() {
		// [A, B, C, D, E, F]
		if (size == 0) {
			return "[]";
		}
		StringBuilder buf = new StringBuilder("[");
		buf.append(elementData[0]);
		for (int i = 1; i < size; i++) {
			buf.append(", ").append(elementData[i]);
		}
		buf.append("]");
		return buf.toString();
	}
}

测试：

public class Demo04 {
		public static void main(String[] args) {
			/**
			 * 利用Debug 研究 MyArrayList
			 */
			 MyArrayList<String> list=new MyArrayList<>();
			 list.add("Andy");
			 list.add("Tom");
			 list.add("Jerry");
			 list.add("Guo");
			 list.add("光头强");
			 list.add("李大嘴");
			 list.add(2, "熊二");
			 list.add("熊大");
			 list.add("Andy");
			 list.remove(3);
			 System.out.println(list); 
		}
	}

LinkedList

链表：

1. 1.8以前内部是双向循环链表
2. 1.8改成了双不循环链表，双向链表

双向循环链表的 追加，插入，删除，遍历操作
代码：

public class MyLinkedList<E> {
		private Node head;
		private int size = 0;
		private class Node{
			E data;
			Node next;
			Node prev;
			public Node(E e) {
				data = e;
			}
		}
	/** 追加元素方法 */
	
public boolean add(E e) {
			if(head==null) { //添加第一个元素
				head = new Node(e);
				//创建循环关系
				head.next = head;
				head.prev = head;
				size++;
				return true;
			}else {
				Node last = head.prev;
				Node node = new Node(e);
				head.prev = node;
				node.prev = last;
				last.next = node;
				node.next = head;
				size++;
				return true;
			}
		}
	
	//插入元素算法
	public boolean add(int index, E e) {
		if(index<0||index>size) {
			throw new IndexOutOfBoundsException();
		}
		if(index==size) { //追加
			return add(e); 
		}
		Node node = find(index);
		Node next = node;
		Node prev = node.prev;
		node = new Node(e);
		prev.next = node;
		node.next = next;
		next.prev = node;
		node.prev = prev;
		size++;
		if(index==0) {
			head = node;
		}
		return true;
	}

	private Node find(int index) {
		//查找插入位置
		Node node;
		if(index>size>>1) { //反向查找
			node = head.prev;
			for(int i=size-1; i>index; i--) {
				node = node.prev;
			}
		} else {  //正向查找
			node = head;
			for(int i=0; i<index; i++) {
				node = node.next;
			}
		}
		return node;
	}
	
	public E remove(int index) {
		if(index<0||index>=size) {
			throw new IndexOutOfBoundsException();
		}
		Node node = find(index);
		E e = node.data;
		node.prev.next=node.next;
		node.next.prev=node.prev;
		if(index==0) {
			head = node.next;
		}
		node.next = null;
		node.prev = null;
		size--;
		return e;
	}
	
	

public String toString() {
			if(head==null) {
				return "[]";
			}
			StringBuilder buf = new StringBuilder("[");
			buf.append(head.data);
			Node node=head.next;
			for(int i=1; i<size; i++) {
				buf.append(", ").append(node.data);
				node = node.next;
			}
			return buf.append("]").toString();
		}
	}

测试：

public class Demo05 {
		public static void main(String[] args) {
			/**
			 * 利用Debug 研究 MyLinkedList内部结构
			 */
			 MyLinkedList<String> list=new MyLinkedList<>();
			 list.add("Andy");
			 list.add("Fan");
			 list.add("Cheng");
			 list.add("Guo");
			 list.add("光头强");
			 list.add("李大嘴"); 
			 list.add(6, "熊二");
			 list.add("熊大");
			 list.add("Andy");
			 list.remove(3);
			 System.out.println(list); 
		}
	}