数据结构与算法Java 02

线性表

数据结构的四种逻辑结构： 集合、线性、 树形、网状。
linearlity = (D,R)
D = {a1,a2,a3,a4}
R = {<a1,a2>,<a2,a3>,<a3,a4>}

线性表的抽象数据类型

抽样数据类型可以对应的一个java类
数据对象：类当中的成员变量存储和表示
数据关系：类当中的成员变量
数据操作：方法实现
getsize():返回线性表中的元素的个数
isEmpty():
insert(i,e):
contains(e):
indexOf(e): 返回元素e在线性表中的索引值
remove(e):
replace(i,e): 把线性表中索引值为i 的元素替换为元素e
insertBefore(p,e) :元素p前边插入元素
insertAfter(p,e)：元素p后边插入元素
remove(i):

list接口

通过接口定义一组线性表中的操作

public interface MyList{
   int getsize();
   boolean isEmpty();
   void insert(int i ,Object e);
   boolean contains(Object e);
   int indexOf(Object e);
   Object remove(Object e);
   Object remove(int i);
   Object replace(int i, Object e);
   Object get(int i);
   boolean insertBefore(Object p, Object e); 
   boolean insertAfter(Object p, Object e); 
 }

线性表的顺序存储和实现

线性表的顺序存储就是用一组地址连续的存储空间来一次存储线性表中的数据元素。

public class MyArrayList implements MyList{
    private Object[] elements;
    private static final int DEFAULT_CAPACITY = 16;
    private int size;
    public MyArrayList(){
      elements  = new Object[DEFAULT_CAPACITY];
   }
   public MyArrayList(int initialCapacity){
        elements = new Object[initialCapacity];   
   }
   public int getSize(){
        return size;
   }
   public boolean isEmpty(){
       return size == 0;
   }
}

顺序存储的特点

优点：

顺序存储是使用数组实现的，数组可以通过索引值快速访问每个元素。

缺点：

在插入或者删除元素时，需要移动大量的元素
当线性表的长度变化较大时，很难确定存储空间的容量。

应用

适合存储的元素，插入、删除操作比较少，主要是查询。

线性表的链式存储与实现

单向链表

单向链表，即单链表，每个存储单元至少有两个存储域。分为所存储的数据，保存下一个元素的存储空间的地址（引用）
每个存储单元为节点 (node)。

public class MySingleLink implements MyList{
    private Node head;
    private int size;

    @Override
    public String toString() {
        return "MySingleLink{" +
                "head=" + head +
                ", size=" + size +
                '}';
    }

    @Override
    public int getSize() {
        return size;
    }

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

    @Override
    public void insert(int i, Object e) {
        if (i < 0 || i > size){
            throw new IndexOutOfBoundsException(i + "越界");
        }
        Node newNode = new Node();
        if (head == null) {
            head = newNode;
        }else{
            if (i == 0) {
                newNode.next = head;
                head = newNode;
            }else{
                Node pNode = head;
                for (int x = 0; x < i; x++) {
                    pNode = pNode.next;
                }
                // 先修改新节点的next再修改前一个节点的next
                newNode.next = pNode.next;
                pNode.next = newNode;
            }
        }
        size++;

    }

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

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

    @Override
    public Object remove(Object e) {
        return null;
    }

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

    @Override
    public Object replace(int i, Object e) {
        return null;
    }

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

    @Override
    public boolean insertBefore(Object p, Object e) {
        return false;
    }

    @Override
    public boolean insertAfter(Object p, Object e) {
        return false;
    }
    private class Node{
        Object data;
        Node next;

        public Node() {
        }

        public Node(Object data, Node next) {
            this.data = data;
            this.next = next;
        }
    }
}

双向链表