数据结构之表、栈、队列

自己用代码实现表 ArrayList

package Java_advance.Link_Array;

/**
 * ArrayList 类的实现
 * @param <AnyType>
 */
public class MyArrayList<AnyType> implements Iterable<AnyType> {
    public static final int DEFAULT_CAPACITY = 10;

    // MyArrayList 把大小和数组作为数据成员进行存储
    private int theSize;
    private AnyType [] theItems;

    public MyArrayList()
    {
        doClear();
    }

    public void clear()
    {
        doClear();
    }

    private void doClear()
    {
        theSize = 0; ensureCapacity(DEFAULT_CAPACITY);
    }

    public int size()
    {
        return theSize;
    }

    public boolean isEmpty()
    {
        return size() == 0;
    }

    public void trimToSize()
    {
        ensureCapacity(size());
    }

    public AnyType get(int idx)
    {
        if (idx < 0 || idx >= size())
            throw new ArrayIndexOutOfBoundsException();
        return theItems[idx];
    }

    public AnyType set(int idx, AnyType newVal)
    {
        if (idx < 0 || idx >= size())
            throw new ArrayIndexOutOfBoundsException();

        AnyType old = theItems[idx];
        theItems[idx] = newVal;
        return old;
    }

    /**
     *  容量的扩容
     * @param newCapacity
     */
    public void ensureCapacity(int newCapacity)
    {
        // 收缩基本数组，当指定的新容量至少和原大小一样时才试用
        if (newCapacity < theSize)
            return;

        // 存储对原始数组的一个引用
        AnyType [] old = theItems;
        // 为新数组分配内存, 这里类型转换原因是 泛型数组的创建是非法的
        theItems = (AnyType[]) new Object[newCapacity];

        // 将旧的内容拷贝进新数组
        for (int i = 0; i <size(); i++)
            theItems[i] = old[i];
    }

    /**
     * 添加到表的末端并通过调用添加到指定位置
     * @param x
     * @return
     */
    public boolean add(AnyType x)
    {
        add(size(),x);
        return true;
    }

    public void add(int idx, AnyType x)
    {
        if (theItems.length == size())
            ensureCapacity(size() * 2 + 1);
        for (int i = theSize; i > idx; i--)
            theItems[i] = theItems[i - 1];
        theItems[idx] = x;

        theSize++;
    }


    public AnyType remove(int idx)
    {
        AnyType removedItem = theItems[idx];

        for (int i = idx; i < size() - 1; i++)
            theItems[i] = theItems[i + 1];

        theSize--;
        return removedItem;
    }

    public java.util.Iterator<AnyType> iterator()
    {
        // 返回 ArrayListIterator 类的一个实例，该类是一个实现 Iterator接口的类，ArayListIterator存储当前位置的概念
        return new ArrayListIterator();
    }

    // 迭代器三号版本，，迭代器是一个嵌套类并存储当前位置和一个连接到 MyArrayList 的链。它能够使用是因为该嵌套类被认为是 MyArrayList类的一部分
    private class ArrayListIterator implements java.util.Iterator<AnyType>
    {
        private int current = 0;
//        private MyArrayList<AnyType> theList;
//        public ArrayListIterator(MyArrayList<AnyType> list)
//        {
//            theList = list;
//        }

        public boolean hasNext()
        {
//            return current < theList.size();
            return current < size();
        }

        public AnyType next()
        {
            if (!hasNext())
                throw new java.util.NoSuchElementException();

//            return theItems[current++];   这句有问题，theItems 不是 ArrayListIterator的一部分，它是 MyArrayList 的一部分, 因此程序没有意义
//            return theList.theItems[current++];
            return theItems[current++];
        }

        public void remove()
        {
            MyArrayList.this.remove(--current);
        }

    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub    
    }

}

用代码实现 LinkedList

package Java_advance.Link_Array;

import org.omg.CORBA.Any;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.ListIterator;

/**
 * @author 小喵钓鱼
 * @date 2020-02-14 14:11
 * @veision 1.10
 * MyLinkedList 类本身，包含两端的链表，的大小和一些方法
 * Node类
 * LinkedListIterator类
 */
public class MyLinkedList<AnyType> implements Iterable<AnyType>{

    // 嵌套 Node 类
    private static class Node<AnyType>
    {
        // 私有类
        private Node(AnyType d, Node<AnyType> p, Node<AnyType> n )
        {
            data = d;
            prev = p;
            next = n;
        }

        public AnyType data;
        public Node<AnyType> prev;
        public Node<AnyType> next;
    }
    public MyLinkedList()
    {
        doClear();
    }

    public void clear()
    {
        doClear();
    }

    // 创建并连接头节点和尾节点，然后设置大小为0
   private void doClear()
    {
        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 theSize == 0;
    }

    public boolean add(AnyType x)
    {
        add(size(), x); return true;
    }
    public void add(int idx, AnyType x)
    {
        addBefore(getNode(idx, 0, size()), x);
    }
    public AnyType get(int idx)
    {
        return getNode(idx).data;
    }

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

    private 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++;
    }
    private AnyType remove(Node<AnyType> p)
    {
        p.next.prev = p.prev;
        p.prev.next = p.next;

        theSize--;
        modCount++;

        return p.data;
    }
    private Node<AnyType> getNode(int idx)
    {
        return getNode(idx, 0, size() - 1);
    }
    private Node<AnyType> getNode(int idx, int lower, int upper)
    {
        Node<AnyType> p;
        if (idx < lower || idx > upper)
            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 = size(); i > idx; i--)
            {
                p = p.prev;
            }
        }

        return p;
    }

    public java.util.Iterator<AnyType> iterator()
    {
        return new LinkedListIterator();
    }

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

        public boolean hasNext()
        {
            return current != endMarker;
        }

        public AnyType next()
        {
            if (modCount != expectedModCount)
                throw new  java.util.ConcurrentModificationException();
            if (!hasNext())
                throw new java.util.NoSuchElementException();

            AnyType nextItem = current.data;
            current = current.next;
            okToRemove = true;
            return nextItem;
        }

        public void remove()
        {
            if (modCount != expectedModCount)
                throw new java.util.ConcurrentModificationException();

            if (!okToRemove)
                throw new IllegalStateException();

            MyLinkedList.this.remove(current.prev);
            expectedModCount++;
            okToRemove = false;
        }
    }

    public boolean contains(AnyType x)
    {
        Node<AnyType> p = beginMarker.next;

        while (p != endMarker && !(p.data.equals(x)))
        {
            p = p.next;
        }
        return (p != endMarker);
    }
    private int theSize;
    // 代表构造以来对链表所改变的次数
    private int modCount = 0;
    // 头节点，尾节点的引用
    private Node<AnyType> beginMarker;
    private Node<AnyType> endMarker;


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        pass(2, 10);  // 下面例题调用
    }
}

一些关于其的例题

1. 给定两个已经排好序的 L1 和 L2， 用基本的表操作写出 计算 L1 且 L2 的过程

 public static <AnyType extends Comparable<? super AnyType>> void insertsection(List<AnyType> L1, List<AnyType> L2, List<AnyType> Intersect)
    {
        ListIterator<AnyType> iterL1 = L1.listIterator();
        ListIterator<AnyType> iterL2 = L2.listIterator();

        AnyType item1 = null, item2 = null;
        if (iterL1.hasNext() && iterL2.hasNext())
        {
            item1 = iterL1.next();
            item2 = iterL2.next();
        }

        while (item1 != null && item2 != null)
        {
            // 比较
            int compareResult = item1.compareTo(item2);
            if (compareResult == 0)
            {
                Intersect.add(item1);
                item1 = iterL1.hasNext()?iterL1.next():null;
                item2 = iterL2.hasNext()?iterL2.next():null;
            }
            else if(compareResult < 0)
            {
                item1 = iterL1.hasNext()?iterL1.next():null;
            }
            else {
                item2 = iterL2.hasNext()?iterL2.next():null;
            }
        }
    }

2. 给定两个已经排好序的 L1 和 L2， 用基本的表操作写出 计算 L1 并 L2 的过程

public static <AnyType extends Comparable<? super AnyType>> void insertSection1(List<AnyType> L1, List<AnyType> L2, List<AnyType> L3)
    {
        // 迭代化
        ListIterator<AnyType> iter1 = L1.listIterator();
        ListIterator<AnyType> iter2 = L2.listIterator();

        // 第一个值
        AnyType item1 = null,item2 = null;
        while (iter1.hasNext() && iter2.hasNext())
        {
            item1 = iter1.next();
            item2 = iter2.next();
        }
        while (item1 != null && item2 !=null)
        {
            int result = item1.compareTo(item2);
            if (result == 0)
            {
                L3.add(item1);
                item1 = iter1.hasNext()?iter1.next():null;
                item2 = iter2.hasNext()?iter2.next():null;
            }
            else if (result < 0)
            {
                // item1 > item2
                L3.add(item1);
                item1 = iter1.hasNext()?iter1.next():null;
            }
            else {
                L3.add(item2);
                item2 = iter2.hasNext()?iter2.next():null;
            }
        }

        while (item1 != null)
        {
            L3.add(item1);
            item1 = iter1.hasNext()?iter1.next():null;
        }
        while (item2 != null)
        {
            L3.add(item2);
            item2 = iter2.hasNext()?iter2.next():null;
        }
    }

3. 传土豆问题，传入 m， n。 n 为圆桌人长度，从 1开始 传递土豆，每传m次，就干掉一个人，直到最后一个人

  public static void pass(int m, int n)
    {
        int i, j, mPrime, numLeft;
        ArrayList<Integer> L = new ArrayList<Integer>();
        for (i = 1; i <= n; i++)
        {
            L.add(i);
        }

        // 转换为迭代
        ListIterator<Integer> iter = L.listIterator();
        Integer item = 0;
        numLeft = n;
        mPrime = m % n;

        for (i = 0; i < n; i++)
        {
            mPrime = m % numLeft;
            if (mPrime <= numLeft / 2)
            {
                if (iter.hasNext())
                {
                    item = iter.next();
                }
                for (j = 0; j < mPrime; j++)
                {
                    if (!iter.hasNext())
                        iter = L.listIterator();
                    item = iter.next();
                }
            }
            else {
                for (j = 0; j < numLeft - mPrime; j++){
                    if (!iter.hasPrevious())
                        iter = L.listIterator(L.size());

                    item = iter.previous();
                }

            }

            System.out.println("Removed " + item + " ");
            iter.remove();
            if (!iter.hasNext())
                iter = L.listIterator();

            System.out.println();
            for (Integer x: L)
                System.out.println(x + " ");
            System.out.println();
            numLeft--;
        }
        System.out.println();
    }

4. 交换链上两个相邻的元素

public class Pratice<AnyType>{

    // 假定一个 Node 类
    private class Node<AnyType>
    {
        private int dData;
        private Node pre;
        private Node next;
    }

    // 1. 只调整链来交换两个相邻的元素, 单链
    public void  swapLink(Node beforeP)
    {
        Node p, afterP;
        p = beforeP.next;
        afterP = p.next;
        // beforeP -> p -> afterP
        beforeP.next = afterP;
        p.next = afterP.next;
        afterP.next = p;
        // beforeP -> afterP -> P;
    }

    // 2. 双向链
    public void doubleSwapLink(Node p)
    {
        Node beforeP, afterP;
        beforeP = p.pre;
        afterP = p.next;

        beforeP.next = afterP;
        p.next = afterP.next;
        afterP.next = p;
        // 因为是双向
        p.next.pre = p;
        p.pre = afterP;
        afterP.pre = beforeP;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub    
    }
}