数据结构——线性表

数据结构——线性表

因为动态数组是顺序存储结构的具体实现，接下来要学习的线性表、栈结构、还是队列，它都是基于动态数组实现的。因此，我们先了解下动态数组。

一、动态数组

在我们使用Java内置数组时，我们知道它有以下的特点：

• 数组的长度一旦确定则不可更改
• 数组只能存储同一类型的数据
• 数组中每个存储空间大小一致且地址连续
• 数组提供角标的访问元素

而当我们继续学习时，可能会遇到

• 容量不够用
• 在指定位置插入或者删除元素
• length属性不够用

而当我们遇到上面的问题时，我们可以使用面向对象的思想，将数组的相关属性和行为再度封装，来解决上面的问题。

 

二、线性表

 

1.什么是线性表？

它是零个或者多个数据元素的有限序列

其数据方式的定义如下：

 若将线性表记为（a1,...,ai-1,ai,ai+1,...,an）,则表中ai-1领先于ai,ai领先于ai+1,称ai-1是ai的直接前驱元素，ai+1是ai的直接后继元素。当i=1,2,...,n-1时，ai有且仅有一个直接后继，当i=2,3,...,n时，ai有且仅有一个直接前驱。如下图：

2.线性表的接口

线性表的接口：

package 线性表;
/**
 * List是线性表的最终父接口
 * 
 * */
public interface List<E> {//<E>表示你这个线性表存什么样的元素是外界决定，这里我们需要指定一个范泛型，名为E（）
	/**
	 * 获取线性表的个数（线性表的长度）
	 * @return 线性表中有效元素的个数
	 * */
	public int getSize();
	/**
	 * 判断线性表是否为空
	 * @return 布尔类型值
	 * */
	public boolean isEmpty();
	/**
	 * 在线性表角标为index处添加元素e
	 * @param index 角标 0<=index<=Size(有效长度)
	 * @param e      需要插入的元素
	 * */
	public void add(int index,E e);
	/**
	 * 在线性表的表头插入一个元素
	 * @param e 需要插入的元素index=0
	 * */
	public void addFirst(E e);
	/**
	 * 在线性表的表尾插入一个元素
	 * @param e 需要插入index=size 的元素
	 * */
	public void addLast(E e);
	/**
	 * 获取角标index处的元素
	 * @param index 元素的角标 0<=index<size
	 * @return 角标所对应的的元素
	 * */
	public E get(int index);
	/**
	 * 获取表头的元素
	 * @return 表头元素 index=0
	 * */
	public E getFirst();
	/**
	 * @return 表尾元素 index=size-1
	 * */
	public E getLast();
	/**
	 * 修改线性表中的元素
	 * @param index 所要修改元素的对于的角标
	 * */
	public void set(int index,E e);
	/**
	 * 判断线性表中是否包含e元素
	 * @param e 需要查询的元素
	 * @return 元素的存在性布尔类型值
	 * */
	public boolean contains(E e);
	/**
	  * 查找指定元素的角标
	  * @param e 要查询的数据
	  * @return 数据在线性表中的角标
	 * */
	public int find(E e);
	/**
	  * 删除指定角标处的元素
	 * @param index 需要删除的元素角标 0<=index<size
	 * @return E 返回删除后的元素
	 * */
	public E remove(int index);
	/**
	  * 删除指定角标处的元素
	 * @param index 需要删除的元素角标 0<=index<size
	 * @return E 返回删除后的线性表
	 * */
	public E removeFirst();
	/**
	  * 删除指定角标处的元素
	 * @return E 返回删除后的线性表
	 * */
	public E removeLast();
	/**
	  * 删除指定元素
	 * @param e 需要删除的元素
	 * @return E 返回删除后的线性表
	 * */
	public void removeElement(E e);
	/**
	  * 清空线性表
	 * */
	public void clear();
}

接着我们用数组实现它，它实现了List接口中的所有方法，并且根据自己的性质和属性有自己特有的方法 

 

 

package 线性表;

/**
 * 用顺序存储结构实现的List-顺序表
 * 
 * */
public class ArrayList<E> implements List<E> {
	
	private E[] data;//存储数据元素的容器
	private int size;//线性表的有效元素个数
					 //data.length表示线性表的最大容量
	private static int DEFAULT_SIZE=10;//容器默认的容量
	/**
	 * 创建一个容量默认为10的一个线性表
	 * */
	
	public ArrayList() {
		this(DEFAULT_SIZE);
		/*this.data=(E[]) new Object[DEFAULT_SIZE];//
		this.size=0;*/
		// TODO Auto-generated constructor stub
	}
	/**
	 * 创建一个为指定容量capacity的线性表
	 * */
	@SuppressWarnings("unchecked")
	public ArrayList(int capacity) {
		this.data=(E[]) new Object[capacity];//
		this.size=0;
	}
	
	/**
	 * 将数组封装成一个线性表
	 * */
	@SuppressWarnings("unchecked")
	public ArrayList(E[] arr) { 
		/*
		 * data=arr;
		 * size=arr.length;
		 * 为什么不这样做？
		 * 这样操作后arr和data都会指向同一个地址的数组，如果对arr修改，会影响data，不安全
		 * 解决办法：
		 * 	创建一个完全一样的新数组，将arr指向的数组，复制到新的数组，再让data指向新数组，避免冲突
		 * */
		data =(E[]) new Object[arr.length];
		for(int i=0;i<data.length;i++) {
			data[i]=arr[i];
		}
		size=arr.length;
	}
	
	@Override
	public int getSize() {
		return this.size;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return size==0;
	}

	@Override
	public void add(int index, E e) {
		if(index<0||index>size) {
			throw new ArrayIndexOutOfBoundsException("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]=e;
		size++;
	}
	/**
	 * 改变data的长度(扩容,缩容)
	 * @param 新数组的长度
	 * */
	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 addFirst(E e) {
		add(0,e);
	}

	@Override
	public void addLast(E e) {
		add(size,e);
	}

	@Override
	public E get(int index) {
		if(index<0||index>size-1) {
			throw new ArrayIndexOutOfBoundsException("get():index out of range");
		}
		return data[index];
	}

	@Override
	public E getFirst() {
		return get(0);
	}

	@Override
	public E getLast() {
		return get(size-1);
	}

	@Override
	public void set(int index, E e) {
		if(index<0||index>size-1) {
			throw new ArrayIndexOutOfBoundsException("set():index out of range");
		}
		data[index]=e;
	}

	@Override
	public boolean contains(E e) {
		if(isEmpty()) {
			return false;
		}
		for(int i=0;i<size;i++) {
			if(data[i]==e) {
				return true;
			}
		}
		return false;
	}

	@Override
	public int find(E e) {
		if(isEmpty()) {
			return -1;
		}
		for(int i=0;i<size-1;i++) {
			if(data[i]==e) {
				return i;
			}
		}
		return -1;
	}

	@Override
	public E remove(int index) {
		if(index<0||index>size-1) {
			throw new ArrayIndexOutOfBoundsException("remove():index out of range");
		}
		E e=get(index);
		for(int i=index+1;i<size;i++) {
			data[i-1]=data[i];
		}
		size--;
		//判断是否需要缩容
		//两个条件：
		//1.缩容最小不能低于10
		//2.当前有效长度size最好低于1/4（如果大于这个，例如1/2，会遇到频繁扩缩的情况）
		if(data.length>=DEFAULT_SIZE && size<=data.length/4) {
			resize(data.length/2);
		}
		
		return e;
	}

	@Override
	public E removeFirst() {
		return remove(0);
	}

	@Override
	public E removeLast() {
		return remove(size-1);
	}

	@Override
	public void removeElement(E e) {
		int index=find(e);
		if(index==-1) {
			throw new IllegalArgumentException("Don't find e");
		}
		remove(index);
	}

	public void clear() {
		size=0;
	}
	
	public String toString() {
		StringBuffer sb=new StringBuffer();
		sb.append("ArrayList:size="+size+",capacity="+data.length+"\n");
		if(isEmpty()) {
			sb.append("[]");
		}else {
			sb.append('[');
			for(int i=0;i<size;i++) {
				sb.append(data[i]);
				if(i==size-1) {
					sb.append(']');//为什么是'  '?因为如果是" "会产生好多字符串
				}else {
					sb.append(',');
				}
			}
		}
		return sb.toString();
	}
	public int getCapacity(){
		return data.length;
	}
	public void swap(int i,int j){
		//i j 判断
		E temp=data[i];
		data[i]=data[j];
		data[j]=temp;
	}
	@Override
	public boolean equals(Object obj) {
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(obj instanceof ArrayList){
			ArrayList l=(ArrayList) obj;
			if(getSize()==l.getSize()){
				for(int i=0;i<getSize();i++){
					if(get(i)!=l.get(i)){
						return false;
					}
				}
				return true;
			}
		}
		return false;
	}
}

下面是部分，具体的功能测试：

package 线性表;

import java.util.Arrays;

public class Main {
	public static void main(String[] args) {
		
		
		Integer[] arr=new Integer[]{1,2,3};
		ArrayList<Integer> list3=new ArrayList<Integer>(arr);
		arr[0]=10;
		System.out.println(Arrays.toString(arr));
		System.out.println(list3);
	}
}