数据结构与算法（1）

第一章概述

为何要学习数据结构与算法

主要考虑到以下三个方面：
1、校招必考内容，占比30%，基础知识30%，框架40%。出题格式为选择题、问答题、编程题
2、考察自己的逻辑思维能力，数据结构与算法也可以称为语言的灵魂
3、长远的角度看，总结一点，程序=数据结构+算法，在对应的就是底层和源码级别的开发离不开数据结构预算法
那么需要学习到什么程度？
需要自己能写出来以下的东西：
最平常的线性表、单链表、循环链表、栈、队列、二叉树、二叉线索树、二叉搜索树
常见于编程题中的AVL平衡树、最大堆/最小堆、优先队列、字符串、Tire前缀树、线段树、并查集、哈希表
接下里就是算法方面图的邻接矩阵、图的邻接表、图的深度优先遍历、图的广度优先遍历、最小生成树、最短路径、排序算法、搜索算法、背包算法、分治算法、回溯算法、动态规划算法、贪心算法
需要自己能大概了解懂得以下知识：
B树、B+树、2-3树、红黑树、有权图算法、以及更高级的数据结构和算法

数据结构概述

什么是数据？
数据：通俗的说但凡能被计算机存储、识别和计算的东西（二进制计算）
例如：硬盘中的MP4等
内存中的常量、变量等
何为结构？
结构：数据与数据之间的一种或多种特定的关系
何为数据结构？
用通俗化的字面意思：数据结构=数据+结构
用官方用语则是：是相互之间存在一种或多种特定关系的数据元素的集合《大话数据结构》
数据结构主要解决什么样的问题？
为编写出一个好程序，必须分析待处理对象的特性及各处理对象之间存在的关系，这就是研究数据结构的意义
Java中有哪些数据结构？
数组
数据结构的逻辑结构
逻辑结构：指数据元素之间的相互关系，是我们想象出来的，并没有实质性的将其存储在计算机中
逻辑结构可以分为以下四种：
1、集合结构：集合结构中的数据元素除了同属于一个集合外，它们之间没有其他关系。
2、线性结构：线性结构中的数据元素之间是一对一的关系
3、树形结构：树形结构中的数据元素之间存在一种一对多的层次关系
4、图形结构：图形结构的数据元素是多对多的关系
数据结构的 物理结构
物理结构：指数据的逻辑结构在计算机中的存储形式
物理结构可以为分以下两种：
顺序存储结构：开辟了一组连续的空间存储数据，通常用数组来实现，数组中空间本身是连续的，保证了数据之间的关系
官方说法：是把数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的
链式存储结构：开辟一组随机的空间存储数据，通常用节点来实现，节点不仅要存储数据，还要存储下一个节点的位置以保证数据之间的关系
官方说法：是把数据元素存放在任意存储单元里，这组存储单元可以是连续的，也可以是不连续的

总结一点：我们需要根据应用场景的不同，灵活的选择最适合的数据结构与算法

算法的概述

什么是算法？
算法：解决特定问题求解步骤的描述，在计算机中表现为指令的有序序列，并且每条指令表示一个或多个操作

例如：求解1到100的和
就有至少两种算法，并且仔细斟酌发现其中的问题，侧面说明一个问题，同一个问题，可以有多种的解决方案，也就是说可以不用不同的算法去解决同一个问题

算法的特性：
1、输入输出：具有零个或者多个输入输出
2、有穷性：算法在执行有限的步骤之后，自动结束而不会出现无限循环
3、确定性：算法的每一个步骤都具有确定的含义，不会出现二义性
4、可行性：算法的每一步都必须是可行的，也就是说，每一步都能通过执行有限次数完成

评价一个算法的好坏
事后统计法：这种方法主要i通过设计好的程序和数据，利用计算机对不同算法程序的运行时间进行比较，从而确定算法效率的高低
缺陷：数据量大，则会耗费人力物力
依赖计算机硬件和软件
数据量小的时候，只会有看不到的微小的差别
事前分析估算方法：这种方法主要在计算机程序编制前，依据统计方法对算法进行估算

总结一下：一个高级程序语言编写的程序在计算机上运行所消耗的时间取决于下列因素：
1、算法采用的策略、方法
2、编译产生的代码质量
3、问题的输入规模
4、机器执行指令的速度

算法时间复杂度的定义
在进行算法分析时，语句总的执行次数T（n）是关于问题规模n的函数，进而分析T（n）随n的变化情况并确定T（n）的数量级，算法执行时间的增长率和F（n）的增长率相同，称作算法的渐进时间复杂度
常见的时间复杂度：
常数阶O（1）
线性阶O（n）
对数阶O（logn）
平方阶O（n^2）

这里注意：我们考虑的时间复杂度都是最坏情况

第二章动态数组

动态数组

java内置数组的特点
数组的长度一旦确定则不可改变
数组只能存储同一类型的数据
数组中每个存储空间大小一致且地址连续
数组提供角标的方式访问元素
java内置数组的潜在问题
容量不够时、指定位置插入或者删除元素、数组对象只有length属性
动态数组的封装
将其里面的属性私有化，提供公开的方法
如何实现动态数组的封装
属性方面：
int size 数组的有效元素个数
int capacity 数组的最大容量data.length
E[] data 数据的存储容器
行为方面：
增删改查其他方面

注意：动态数组就是顺序存储结构的具体表现

线性表的顺序存储结构

线性表的定义
零个或者多个数据元素的有限序列
线性表元素的个数定义为线性表的长度，当线性表元素的个数为零时候，称为空表
线性表接口List的定义

package com.study.shuzu;
/**
 * 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 指定的角标
	 * @return该角标所对应的元素
	 * */
	public E get(int index);
	/**
	 * 获取线性表中表头的元素
	 * */
	public E getFirst();
	/**
	 * 获取线性表中表尾的元素
	 * */
	public E getLast();
	/**
	 * 修改线性表中指定index处的元素为新元素e
	 * */
	public void set(int index,E e);
	/**
	 * 判断线性表中是否包含指定元素e(默认从前往后查找)
	 * */
	public boolean contains(E e);
	/**
	 * 在线性表中获取指定元素e的角标默认从前往后找
	 * */
	public int find(E e);
	/**
	 * 在线性表中删除指定角标处的元素，并返回
	 * */
	public E remove(int index);
	/**
	 * 删除线性表中表头元素
	 * */
	public E removeFirst();
	/**
	 * 删除线性表中的表尾元素
	 * */
	public E removeLast();
	/**
	 * 在线性表中删除指定的元素
	 * */
	public void removeElement(E e);
	/**
	 * 清空线性表
	 * */
	public void clear();
	
}

线性表顺序存储结构的定义
指的是用一段地址连续的存储单元依次存储线性表的数据元素
线性表的顺序存储结构ArrayList的定义

package com.study.shuzu;

/**
 * 用顺序存储结构实现的List-顺序线性表-顺序表
 */
public class ArrayList<E> implements List<E> {

	private static int DEFAULT_SIZE = 10;
	private E[] data; // 存储数据的容器
	private int size; // 线性表的有效元素的个数 data.length表示线性表的最大容量

	/**
	 * 创建一个容量默认为10的一个线性表
	 */
	public ArrayList() {
		this(DEFAULT_SIZE);
	}

	/**
	 * 创建一个容量为指定capacity的一个线性表
	 */
	public ArrayList(int capacity) {
		this.data = (E[]) new Object[capacity];
		this.size = 0;
	}

	/**
	 * 将一个数组封装为一个线性表
	 */
	public ArrayList(E[] arr) {
		data = (E[]) new Object[arr.length];
		for(int i = 0;i < data.length;i++) {
			data[i]=arr[i];
		}
		size=data.length;
	}

	@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的长度（扩容，缩容）
	 * */
	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、有效元素的个数小于等于容量的四分之一
		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  void swap(int i, int j) {
		//判断i,j
		E temp = data[i];
		data[i] = data[j];
		data[j] = temp; 
	}

	public int getCapacity() {
		return data.length;
	}
	
	@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 com.study.shuzu;

public class TestList {

	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		System.out.println(list);
		for(int i = 1;i < 10;i++) {
			list.addFirst(i);
		}
		System.out.println(list);
		list.remove(0);
		System.out.println(list);
		
	}

}