Java数据结构--------2.线性表和链表

数组线性表:  

• 数组是一种固定大小的数据结构,尽管如此,仍然可以使用数组实现动态结构.处理方法是,当数组不能再存储新的元素是,创建一个更大的数组来代替当前数组.
• 查询较快,插入和删除较慢
• 开始时,用默认大小创建一个数组data,设置为Object[]型,像数组中插入一个新元素时,首先确认数组是否有做够的空间.如数组不够空间,则创建当前数组中的元素复制到新数组中,并将新数组设为当前数组,并将该集合的size增加.具体实现如下

public class MyArrayList extends MyAbstractList {

	// 初始化数组大小
	public static final int INTIIAL_CAPACITY = 16;

	// 构建数组
	private Object[] data = new Object[INTIIAL_CAPACITY];

	public MyArrayList() {
	}

	// 构造传参
	public MyArrayList(Object[] objects) {
		data = objects;
		size = objects.length;
	}

	@Override
	public void add(int i, Object o) {
		ensureCapacity();
		// 所有数组向右移
		for (int j = size - 1; j >= i; j--)
			data[j + 1] = data[j];
		data[i] = o;
		size++;
	}

	// 检测数据是否超出原数组大小
	private void ensureCapacity() {
		if (size >= data.length) {
			Object[] newData = new Object[data.length * 2];
			// copy原数组信息到新数组
			System.arraycopy(data, 0, newData, 0, data.length);
			data = newData;
		}
	}

	@Override
	public void clear() {
		data = new Object[INTIIAL_CAPACITY];
	}

	@Override
	public boolean contains(Object o) {
		for (int i = 0; i < data.length; i++)
			if (data[i].equals(o))
				return true;
		return false;
	}

	@Override
	public Object get(int i) {
		return data[i];
	}

	@Override
	public int indexOf(Object o) {
		for (int i = 0; i < data.length; i++)
			if (data[i].equals(o))
				return i;
		return -1;
	}

	@Override
	public int lastIndexOf(Object o) {
		for (int i = data.length - 1; i >= 0; i--)
			if (data[i].equals(o))
				return i;
		return -1;
	}

	@Override
	public boolean isEmpty(Object o) {
		for (int i = 0; i < data.length; i++)
			if (data[i].equals(o))
				return false;
		return true;
	}

	@Override
	public boolean remove(Object o) {
		for (int i = 0; i < data.length; i++)
			if (data[i].equals(o))
				return true;
		return true;
	}

	@Override
	public Object remove(int i) {
		Object o = data[i];
		for (int j = i; j < size - 1; j++) {
			data[j] = data[j + 1];
		}
		size--;
		return o;

	}

	@Override
	public Object set(int i, Object o) {
		Object old = data[i];
		data[i] = o;
		return old;
	}
}

链表(LinkedList)

• 由于MyArrayList在进行插入和删除等操作时需要移动大量元素,为了提高效率,通过节点的形式,来指定下一个元素是谁,从而实现高效率插入和删除
• 删除插入快,查询慢

节点:将元素存储在element中,再把指定它下一个元素是谁,从而实现链表.具体实现如下

public class Node {
	// 需要存储的元素
	Object element;
	// 下一个元素
	Node next;

	public Node(Object o) {
		element = 0;
	}
}

链表实现:

// 链表数据结构
public class MyLinkedList extends MyAbstractList {
	// 头尾节点
	private Node first, last;

	public MyLinkedList() {
	}

	public MyLinkedList(Object[] objects) {
		super(objects);
	}

	// 获取头结点
	public Object getFist() {
		if (size == 0)
			return null;
		return first.element;
	}

	// 获取尾节点
	public Object getLast() {
		if (size == 0)
			return null;
		return last.element;
	}

	public void addFist(Object o) {
		Node newNode = new Node(o);
		// 下个节点指向原 头节点
		newNode.next = first;
		first = newNode;
		size++;
		if (last == null)
			last = first;
	}

	public void addLast(Object o) {
		if (last == null)
			first = last = new Node(o);
	}

	@Override
	public void add(int i, Object o) {
		if (i == 0)
			addFist(o);
		else if (i >= size)
			addLast(o);
		else {
			Node current = first;
			for (int j = 0; j < i; j++)
				current = current.next;
			Node temp = current.next;
			current.next = new Node(o);
			(current.next).next = temp;
			size++;
		}
	}

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

	public Object removeFirst() {
		if (size == 0)
			return null;
		else {
			Node temp = first;
			first = first.next;
			size--;
			if (first == null)
				last = null;
			return temp.element;
		}
	}

	public Object removeLast() {
		if (size == 0)
			return null;
		else {
			Node current = first;
			for (int i = 0; i < size - 1; i++)
				current = current.next;
			Object temp = current.next;
			current.next = null;
			size--;
			return temp;
		}
	}

	@Override
	public Object remove(int i) {
		if ((i < 0) || (i >= size))
			return null;
		else if (i == 0)
			return removeFirst();
		else if (i == size - 1)
			return removeLast();
		else {
			Node previous = first;
			for (int j = 0; j < i; j++)
				previous = previous.next;
			Node current = previous.next;
			previous.next = current.next;
			size--;
			return current.element;
		}
	}

	// 下面方法有空在写
	@Override
	public Object set(int i, Object o) {
		return null;
	}

	@Override
	public boolean contains(Object o) {
		return false;
	}

	@Override
	public Object get(int i) {
		return null;
	}

	@Override
	public int indexOf(Object o) {
		return 0;
	}

	@Override
	public int lastIndexOf(Object o) {
		return 0;
	}

	@Override
	public boolean isEmpty(Object o) {
		return false;
	}
}