/*

　　使用接口+抽象类+具体类实现

　　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;
    }
}