数据结构与算法概括、动态数组

数据结构（data structure）：

数据：能被计算机存储、识别、和计算的东西都叫数据
结构：数据与数据之间的一种或多种特定的关系
数据结构：数据结构=数据+数据之间的关系
逻辑结构：是指数据对象中数据元素之间的相互关系。包括集合结构、线性结构、树形结构、图形结构。

1. 集合结构：集合结构中的数据元素除了同属于一个集合外，它们之间没有其它关系。

2. 线性结构：线性结构中的数据之间是一对一的关系。

3. 树形结构：树形结构中的数据之间存在一种一对多的层次关系。

4. 图（网）状结构：图形结构的数据元素是多对多的关系。

物理结构（存储结构）–是指数据的逻辑结构在计算机中的存储形式：

1. 顺序存储结构： 是把数据元素存放在地址连续的存储单元里。
2. 链式存储结构：是把数据元素存放在任意的存储单元里，这组存储单元可以是连续的，也可以是不连续的。
   顺序存储结构 查改快 增删慢
   链式存储结构 查改慢 增删快

算法：求解一个问题的步骤。

算法是解决问题步骤的有限集合，通常用某一种计算机语言进行伪码描述。通常用时间复杂度和空间复杂度来衡量算法的优劣。
算法的五大特征：输入、输出、有穷性、确定性、可行性。

输入：零个或多个输入。

输出：一个或多个输出。

有穷性：有限步骤后在可接受时间内完成。

确定性：每个步骤都有确定含义，无二义性。

可行性：每一步都是可行的。

算法设计要求：正确性、可读性、健壮性、时间效率高和存储低。

正确性：有输入输出，无二义性，有正确答案。

可读性：方便阅读。

健壮性：输入不合法能处理

时间效率高和存储低：时间空间复杂度越低越好。
算法时间复杂度：
常数阶o(1)：随着N的增大，运行次数不变，其时间复杂度都为O(1)
线性阶o(n)：忽略常数，忽略N的系数，如2N+3
对数阶o(logn）：如2^x=N，则log2(N)
平方阶o(n^2)

动态数组

1、Java内置数组的特点
（1）数组的长度一旦确定则不可更改
（2）数组只能存储同一类型的数据
（3）数据中每个存储空间大小一致且地址连续
（4）数据提供角标的方式访问元素
2、线性表的顺序存储结构
线性表：零个或多个数据元素的有限序列
3、线性表接口List 的定义

package com.线性表;
/**
 * List是线性表的最终父接口 
 * */
public interface List<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 要插入的元素 指定在角标0处
	 * */
	public void addFirst(E e);
	
	/**
	 * 在线性表的表尾位置插入一个元素
	 * @param e 要插入的元素 指定在角标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();
	
	/**
	 * 修改线性表中指定index处的元素为新元素e
	 * @param index 指定的角标
	 * @param e 新元素
	 * */
	public void set(int index,E e);
	
	/**
	 * 判断线性表中是否包含指定元素e 默认从前往后找
	 * @param e 要判断是否存在的元素
	 * @return 元素的存在性布尔类型值
	 * */
	public boolean contains(E e);
	
	/**
	 * 在线性表中获取指定元素e的角标 默认从前往后找
	 * @param e 要查询的数据
	 * @return 数据在线性表中的角标
	 * */
	public int find(E e);
	
	/**
	 * 在线性表中删除指定角标处的元素 并返回
	 * @param index 指定的角标 0<=index<size
	 * @return 删除掉的老元素
	 * */
	public E remove(int index);
	
	/**
	 * 删除线性表中的表头元素
	 * @return 表头元素
	 * */
	public E removeFirst();
	
	/**
	 * 删除线性表中的表尾元素
	 * @return 表尾元素
	 * */
	public E removeLast();
	
	/**
	 * 在线性表中删除指定元素e
	 * */
	public void removeElement(E e);
	
	/**
	 * 清空线性表
	 * */
	public void clear();
	
}

4、线性表的顺序存储结构ArrayList的定义

package com.线性表;

import java.util.Arrays;

/**
 * 用顺序存储结构实现的List-顺序线性表-顺序表
 * */
public class ArrayList<E> implements List<E> {
	
	private static int DEFAULT_SIZE=10; //容器的默认容量
	private E[] data;	//存储数据元素的容器
	private int size;	//线性表的有效元素的个数 
						//data.length表示线性表的最大容量Capacity
	/**
	 * 创建一个容量默认为10的一个线性表
	 * */
	public ArrayList(){
		this(DEFAULT_SIZE);
	}
	/**
	 * 创建一个容量为指定capacity的一个线性表
	 * */
	public ArrayList(int capacity){
		this.data=(E[]) new Object[capacity];
		this.size=0;
	}
	/**
	 * 将一个数组封装成为一个线性表
	 * */
	public ArrayList(E[] arr){
		// TODO
	}
	
	@Override
	public int getSize() {	
		return size;
	}

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

	@Override
	public void add(int index, E e) {
		if(index<0||index>size){
			throw new ArrayIndexOutOfBoundsException("add函数角标越界");
		}
		//判断是否以满
		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函数角标越界");
		}
		
		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函数角标越界");
		}
		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;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函数角标越界");
		}
		E e=get(index);
		for(int i=index+1;i<=size-1;i++){
			data[i-1]=data[i];
		}
		size--;
		
		//判断是否缩容
		//1.最短不能缩过默认容量
		//2.有效元素的个数小于等于容量的1/4
		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("删除元素不存在");
		}
		remove(index);
	}

	@Override
	public void clear() {
		size=0;
	}
	
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		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){
		//对data[i]、data[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;
	}
}