/*
使用接口+抽象类+具体类实现
ArrayList实现原理:添加元素时要判断ArrayList中是否还有多余空间,若没有 则创建大小是当前数组两倍的新数组, 然后在复制原来的数组到新数组中
LinkList实现原理:利用结点(node),当向链表中加入一个新的元素时,就会产生一个包含它的结点 类似与c++使用指针实现
*/
package wangChaoPA实习工作练习.com.进阶篇.线性表;
/**
*
* <p>
* 描述该类情况 {@link 代表跟谁有关系}
* </p>
*
* @author 王超
* @since 1.0
* @date 2017年5月11日 下午1:51:03
* @see 新建|修改|放弃
* @see wangChaoPA实习工作练习.com.进阶篇.线性表.MyList
*/
// 接口中默认的方法都是 public abstract 类型 变量都是 public static final 类型
public interface MyList<E>
{
// 添加
void add(E e);
// 指定位置添加
void add(int index, E e);
// 清空列表
void clear();
// 是否包含元素e
boolean contains(E e);
// 通过索引获取元素
E get(int index);
// 从链表 表头 向表尾 遍历 返回第一个与e相等的元素的索引 若没有相同的元素返回-1
int indexOf(E e);
// 链表是否为空
boolean isEmpty();
// 从链表 表尾 向表头 遍历 返回第一个与e相等的元素的索引 若没有相同的元素返回-1
int lastIndexOf(E e);
// 删除链表中 元素e,并返回删除是否成功
boolean remove(E e);
// 删除链表中 index索引的元素,并返回
E remove(int index);
// 在指定下标处放置元素并返回该元素
Object set(int index, E e);
// 链表大小
int size();
}
//
//抽象类 实现类接口个别方法
package wangChaoPA实习工作练习.com.进阶篇.线性表;
public abstract class MyAbstractList<E> implements MyList<E>
{
// 链表长度
protected int size = 0;
// 默认构造方法
MyAbstractList()
{
}
// 带参的构造方法
MyAbstractList(E[] objects)
{
for (int i = 0; i < objects.length; i++)
{
add(objects[i]);
}
}
@Override
public void add(E e)
{
add(this.size, e);
}
@Override
public boolean isEmpty()
{
return this.size == 0;
}
@Override
public boolean remove(E e)
{
if (indexOf(e) >= 0)
{
remove(indexOf(e));
return true;
}
return false;
}
@Override
public int size()
{
return this.size;
}
}
//ArrayList实现类
package wangChaoPA实习工作练习.com.进阶篇.线性表;
public class MyArrayList<E> extends MyAbstractList<E>
{
// 初始长度
public static final int INITIAL_CAPACITY = 16;
// 泛型不能直接使用new 关键字创建数组
private E[] data = (E[]) new Object[INITIAL_CAPACITY];
// 默认构造方法
public MyArrayList()
{
}
// 带参的构造方法
public MyArrayList(E[] objects)
{
for (int i = 0; i < objects.length; i++)
{
add(objects[i]);
}
}
@Override
public void add(int index, E e)
{
ensureCapacity();
// index以后的元素 后移一位
for (int i = this.size - 1; i >= index; i--)
{
this.data[i + 1] = this.data[i];
}
// 插入e
this.data[index] = e;
// 链表长度加1
this.size++;
}
@Override
public void clear()
{
// 新的data链表
this.data = (E[]) new Object[INITIAL_CAPACITY];
// 长度为0
this.size = 0;
}
@Override
public boolean contains(E e)
{
for (int i = 0; i < this.size; i++)
{
if (e.equals(data[i]))
{
return true;
}
}
return false;
}
// 如果需要就将当前数组的大小加倍
private void ensureCapacity()
{
if (this.size >= this.data.length)
{
E[] newData = (E[]) (new Object[size * 2 + 1]);
System.arraycopy(this.data, 0, newData, 0, this.size);
this.data = newData;
}
}
@Override
public E get(int index)
{
return this.data[index];
}
@Override
public int indexOf(E e)
{
for (int i = 0; i < this.size; i++)
{
if (e.equals(this.data[i]))
{
return i;
}
}
return -1;
}
@Override
public int lastIndexOf(E e)
{
for (int i = size - 1; i >= 0; i--)
{
if (e.equals(this.data[i]))
{
return i;
}
}
return -1;
}
@Override
public E remove(int index)
{
E temp = this.data[index];
if (index >= this.size)
{
return null;
}
else
{
for (int i = index; i < this.size; i++)
{
this.data[i] = this.data[i + 1];
}
// 删除最后一个元素
this.data[this.size - 1] = null;
this.size--;
}
return temp;
}
@Override
public Object set(int index, E e)
{
E oddObject = this.data[index];
if (index >= this.size)
{
return null;
}
else
{
this.data[index] = e;
return oddObject;
}
}
// 当一个Object实例被转化成String时，Java就会自动调用toString()方法返回一个String。
// System.out.println标准输出，只能输出String，所以，所有需要输出的Object都会被转化成String。
// 如果你没有覆盖toString，那么，Java会自动调用最上层父类Object的toString()方法。
@Override
public String toString()
{
StringBuilder result = new StringBuilder("[");
for (int i = 0; i < size; i++)
{
result.append(data[i]);
if (i < size - 1)
{
result.append(", ");
}
}
return result.toString() + "]";
}
public void trimToSize()
{
if (this.size != this.data.length)
{
E[] newData = (E[]) (new Object[size]);
System.arraycopy(this.data, 0, newData, 0, size);
this.data = newData;
}
}
}
//LinkList的实现类
package wangChaoPA实习工作练习.com.进阶篇.线性表;
public class MyLinkList<E> extends MyAbstractList<E>
{
// 头结点,尾结点
private Node<E> head, tail;
// 默认构造方法
public MyLinkList()
{
}
// 带参的构造方法
public MyLinkList(E[] objects)
{
super(objects);
}
@Override
public void add(int index, E e)
{
if (index == 0)
{
addFirst(e);
}
else if (index >= this.size)
{
addLast(e);
}
else
{
Node<E> current = this.head;
// 找到需要添加元素位置的前一个结点
for (int i = 1; i < index; i++)
{
current = current.next;
}
// e插入到current与temp之间
Node<E> temp = current.next;
current.next = new Node<E>(e);
current.next.next = temp;
this.size++;
}
}
// 元素添加到头结点
public void addFirst(E e)
{
Node<E> newNode = new Node<E>(e);
// newNode的next指向head
newNode.next = this.head;
// newNode成为head
this.head = newNode;
// 大小加1
this.size++;
// 当链表中没有结点时
if (this.tail == null)
{
this.tail = this.head;
}
}
// 元素添加到尾结点
public void addLast(E e)
{
Node<E> newNode = new Node<E>(e);
// 当链表中没有结点时
if (this.tail == null)
{
this.tail = this.head = newNode;
}
else
{
// tail与newNode建立联系
this.tail.next = newNode;
// tail指向最后的结点
this.tail = this.tail.next;
}
// 大小加1
this.size++;
}
// 清空链表
@Override
public void clear()
{
this.head = this.tail = null;
}
// 是否包含e
@Override
public boolean contains(E e)
{
Node<E> current = this.head;
for (int i = 0; i < this.size - 1; i++)
{
if (e.equals(current.element))
{
return true;
}
current = current.next;
}
return false;
}
@Override
public E get(int index)
{
if (index < 0 || index >= this.size)
{
return null;
}
else
{
Node<E> current = this.head;
for (int i = 0; i < index; i++)
{
current = current.next;
}
return current.element;
}
}
// 返回头结点的值
public E getFirst()
{
if (this.size == 0)
{
return null;
}
else
{
return this.head.element;
}
}
// 返回尾结点的值
public E getLast()
{
if (this.size == 0)
{
return null;
}
else
{
return this.tail.element;
}
}
// 从表头向表尾遍历 如有和e相同的element则返回其索引值 否则返回-1
@Override
public int indexOf(E e)
{
Node<E> current = this.head;
for (int i = 0; i < this.size - 1; i++)
{
if (e.equals(current.element))
{
return i;
}
current = current.next;
}
return -1;
}
// 暂时没有实现 无法从后到先遍历?????
@Override
public int lastIndexOf(E e)
{
Node<E> current = this.tail;
for (int i = this.size - 1; i >= 0; i--)
{
if (e.equals(current.element))
{
return i;
// current=current.next;
}
}
return -1;
}
@Override
public E remove(int index)
{
if (index < 0 || index >= this.size)
{
return null;
}
else if (index == 0)
{
return removeFirst();
}
else if (index == this.size - 1)
{
return removeLast();
}
else
{
Node<E> previous = this.head;
for (int i = 1; i < index; i++)
{
previous = previous.next;
}
// current 就是要删除的结点
Node<E> current = previous.next;
previous.next = current.next;
this.size--;
return current.element;
}
}
// 删除头结点 并返回头结点中的element
public E removeFirst()
{
if (this.size == 0)
{
return null;
}
else if (this.size == 1)
{
Node<E> temp = this.head;
this.head = this.tail = null;
this.size = 0;
return temp.element;
}
else
{
Node<E> newHead = this.head.next;
E ele = this.head.element;
this.head = newHead;
this.size--;
return ele;
}
}
// 删除尾结点 并返回尾结点中的element
public E removeLast()
{
if (this.size == 0)
{
return null;
}
else if (this.size == 1)
{
Node<E> temp = this.head;
this.head = this.tail = null;
this.size = 0;
return temp.element;
}
else
{
Node<E> current = this.head;
for (int i = 0; i < this.size - 2; i++)
{
current = current.next;
}
Node<E> temp = this.tail;
this.tail = current;
this.tail.next = null;
this.size--;
return temp.element;
}
}
@Override
public Object set(int index, E e)
{
if (index < 0)
{
return null;
}
else if (index == 0)
{
return getFirst();
}
else if (index == this.size - 1)
{
return getLast();
}
else
{
Node<E> current = this.head;
for (int i = 1; i < index; i++)
{
current = current.next;
}
Node<E> temp = current.next;
Node<E> newNode = new Node<E>(e);
current.next = newNode;
newNode.next = temp.next;
return temp.element;
}
}
@Override
public String toString()
{
StringBuilder result = new StringBuilder("[");
Node<E> current = this.head;
for (int i = 0; i < this.size; i++)
{
result.append(current.element);
current = current.next;
if (current != null)
{
result.append(", ");
}
else
{
result.append("]");
}
}
return result.toString();
}
}
// 结点类
class Node<E>
{
E element;
Node<E> next;
public Node(E e)
{
this.element = e;
}
}