数据结构---线性表

一、静态数组与动态数组

将数组再次进行封装，其中数组和size为类的成员属性，增删查找为类的成员方法，构成动态数组。

Size表示数据的有效个数，也表示新元素要进入的位置（当为表尾添加数据）

动态数组是顺序存储结构具体实现的核心思想

二、线性表

1.线性表的定义

• a（i-1）是ai的直接前驱
• a（i+1）是ai的直接后继
• n表示线性表的长度，n=0时称为空表

2.List接口的定义

将顺序存储和链式存储对线性结构共同的操作进行抽取，定义出线性结构的接口

ackage p1.接口;

        import java.util.Comparator;

public interface List<E>extends Iterable<E> {
    public void add(E element);
    public void add(int index,E element);
    public void remove (E element);
    public E remove(int index);

    public int size();
    public int indexOf(E element);
    public void clear();
    public void sort(Comparator<E> c);
    public List<E> subList(int fromIndex, int toIndex);
    public E get(int index);
    public E set(int index,E element);
    public boolean contains(E element);
    public  boolean isEmpty();
}

3.ArrayList实现线性表

ArrayList是线性结构顺序存储的具体实现，称为线性表

• 创建ArrayList实现List接口
• 定义相关成员属性和构造函数和成员函数

• package p2.线性结构;
  
  import p1.接口.List;
  
  import java.util.Comparator;
  import java.util.Iterator;
  
  //自定义的线性表的顺序存储方式
  public class Arraylist <E> implements List<E> {
      //定义数组容器 data.length指当前线性表容量
      private E[] data;
      //元素个数 size==0线性表为空 size==data.length 线性表满了
      //size 新元素默认尾部添加时要去的角标
      private int size;
      //定义默认容量
      private  static int DEFAULT_CAPACITY=10;
       //创建一个默认含量的线性表
      public Arraylist(){
         data= (E[])new Object[DEFAULT_CAPACITY];
         size=0;
      }
      //指定默认容量的构造函数：创建一个指定容量的线性表
  public Arraylist(int capacity){
          if(capacity<=0){
              throw new IllegalArgumentException("capacity必须大于0");
          }
          DEFAULT_CAPACITY=capacity;
      data= (E[])new Object[DEFAULT_CAPACITY];
      size=0;
  }
  //指定数组的构造函数：传入一个数组，将该数组封装称为一个线性表
  public Arraylist(E[] arr){
          if (arr==null||arr.length==0){
              throw new IllegalArgumentException("arr can not be null");
          }
      data= (E[])new Object[DEFAULT_CAPACITY];
          for(int i=0;i<arr.length;i++){
              add(arr[i]);
          }
  }
      @Override
      public void add(E element) {
          add(size,element);
      }
  
      @Override
      public void add(int index, E element) {
  
          if(index<0||index>size) {
              throw new IllegalArgumentException("add index out of range");
          }
          //判断线性表是否是满状态
          if(size==data.length){
              resize(2*data.length);
          }
          //向后移动元素
          for (int i=size-1;i>=index;i--){
              data[i+1]=data[i];
          }
          data[index]=element;
          size++;
      }
      //扩容/缩容 操作
  private void resize(int newlen){
          E[] newData= (E[]) new Object[newlen];
          for(int i=0;i<size;i++){
              newData[i]=data[i];
          }
          data=newData;
  }
      @Override
      public void remove(E element) {
          int index=indexOf(element);
          if(index!=-1){
              remove(index);
          }
      }
  
      @Override
      public E remove(int index) {
          if(index<0||index>=size){
              throw new IllegalArgumentException("remove index out of range");
          }
          //先保存要删除的值
          E ret =data[index];
          //移动元素
          for(int i=index+1;i<size;i++){
              data[i-1]=data[i];
          }
          size--;
          //什么时候缩容
          //有效元素是容量的1/4
          //当前容量不得小于默认容量
          if(size==data.length/4&&data.length>DEFAULT_CAPACITY){
              resize(data.length/2);
          }
          return ret;
      }
  public  E get(int index){
          if(index <0||index>=size){
              throw new IllegalArgumentException("out of range");
          }
      return data[index];
  }
  
      @Override
      public E set(int index, E element) {
          if(index<0||index>=size){
              throw  new IllegalArgumentException("out of range");
          }
          E ret=data[index];
          data[index]=element;
          return ret;
      }
  
  
      @Override
      public int size() {
          return size;
      }
  //额外添加一个函数，获取线性表中数组的容量
      private int getCapacity(){
          return data.length;
      }
      @Override
      public int indexOf(E element) {
          for(int i=0;i<=size;i++){
              if(data[i].equals(element)){
                  return i;
              }
          }
          return -1;
      }
  public boolean contains(E element){
          return indexOf(element)!=-1;
  }
  
      @Override
      public boolean isEmpty() {
          return size==0;
      }
  
      @Override
      public void clear() {
  data= (E[]) new Object[DEFAULT_CAPACITY];
      }
  
      @Override
      public void sort(Comparator<E> c) {
          if(c==null){
              throw new IllegalArgumentException("comparator can not be null");
          }
          for(int i=0;i<size;i++){
              E e=data[i];
              int j=0;
              for( j=i;j>0&&c.compare(data[j-1],e)>0;j--){
                  data[j]=data[j-1];
              }
              data[j]=e;
          }
  
  
      }
  
      @Override
      public List<E> subList(int fromIndex, int toIndex) {
          if(fromIndex<0||toIndex>size||fromIndex>toIndex){
              throw new IllegalArgumentException("must 0<fromIndex<toIndex<size");
          }
          Arraylist<E> list=new Arraylist<E>();
          for(int i=fromIndex;i<=toIndex;i++){
              list.add(data[i]);
          }
          return list;
      }
      public boolean equals(Object o){
          //1.判空
          if(o==null){
              return false;
          }
          //2.判自己
          if(this==o){
              return true;
          }
          //3.判类型
          if(o instanceof Arraylist){
              Arraylist<E> other= (Arraylist<E>) o;
              //判断有效元素个数
              if(other.size!=size){
                  return false;
              }
              //逐个比较元素
              for(int i=0;i<size;i++){
                  if(!other.data[i].equals(data[i])){
                      return false;
                  }
              }
              return true;
          }
          return false;
      }
      /*
      [1， 2， 3， 4， 5 ]
      []
      */
      public String tostring(){
          StringBuilder sb=new StringBuilder();
          sb.append('[');
          if(isEmpty()){
              sb.append(']');
          }else{
              for(int i=0;i<size;i++){
                  sb.append(data[i]);
                  if(i==size-1){
                      sb.append(']');
                  }else {
                      sb.append(',');
                      sb.append(' ');
                  }
              }
  
          }
  return sb.toString();
      }
      @Override
      public Iterator<E> iterator() {
          return new ArrayListIterator();
      }
      class ArrayListIterator implements Iterator<E>{
  private int cur=0;
          @Override
          public boolean hasNext() {
  
              return cur<size;
          }
  
          @Override
          public E next() {
              return data[cur++];
          }
      }
  }