表
表的定义
形如 A 0 A_0 A0 , A 1 A_1 A1 ,…, A N − 1 A_{N-1} AN−1的一系列数据
表的简单数组实现
public class Array {
public static void main(String[] args) {
int []arr =new int[10];
//生成一个两倍的新数组
int []newarr= new int[arr.length*2];
for (int i=0;i< arr.length;i++){
newarr[i]=arr[i];
}
}
}
数组实现表分析:
- 打印遍历表 printlist 以线性时间被执行
- 查找表的元素 花费o(1) //直接通过下标查找
- 插入或删除第一个元素,要将整个数组后移 花费o(n)
- 插入或删除表的末尾,花费o(1)
链表
链表由节点组成,每一个节点都含有元素和后继节点的指针
分析:
- 遍历表花费o(n)
- 查找表的数据o(n)
- 删除数据o(1)
collection接口
public interface Collection<E> extends Iterable<E> {
int size(); //返回集合的项数
boolean isEmpty(); //返回集合是否为空
boolean contains(Object o); //如果o在集合中,返回true
Iterator<E> iterator();
Object[] toArray(); //集合变成对象数组
<T> T[] toArray(T[] a);
boolean add(E e);//添加元素进集合
boolean remove(Object o); //删除元素
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c);
}
Iterator接口
通过iterator方法,每个集合可以创建返回一个iterator对象,并将当前位置的概念存储下来
使用iterator的remove会比Collection的remove方法效率要高,不需要寻找位置
对集合修改的时候 iterator会非法
public interface Iterator<E> {
boolean hasNext();//是否存在下一项
E next();//移到下一项
default void remove() { //删除元素
throw new UnsupportedOperationException("remove");
}
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}
List接口
List接口继承了Collection接口
public interface List<E> extends Collection<E> {
//数组内排序
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
//获取位置索引上的元素
E get(int index);
}
ArrayList,LinkedList都实现了List接口
- 在末端添加数据构造List 花费o(n)
- 在前端添加数据 ,ArrayList花费o( N 2 N^2 N2),LinkedList花费O(N)
- 计算List所有元素的和 LinkedList花费o( N 2 N^2 N2),ArrayList花费o(N)
删除数据的讨论
例:删除表中偶数的数据
- 一边遍历,一边remove,o( N 2 N^2 N2)
- 使用迭代器找LinkedList的节点 ,O( N 2 N^2 N2)
public static void main(List<Integer> lst) {
Iterator<Integer> iterator = lst.iterator();
while (iterator.hasNext()){
if (iterator.next()%2==0){
iterator.remove();
}
}
}
实现自己的ArrayList
public class MyArryList<E> implements Iterable<E> {
//默认数组大小
private static final int large= 10;
//数组目前元素个数
private int thisSize;
//数组目前实体
private E [] thisItem;
/**
* 构造器
* @return void
*/
public MyArryList(){
doclear();
}
public void clear(){
doclear();
}
/**
* 初始化数组
*/
private void doclear(){
thisSize=0;
createArray(large);
}
public int size(){
return thisSize;
}
public boolean isEmpty(){
return size()==0;
}
/**
* 数组大小匹配元素
*/
private void trimtoSize(){
createArray(size());
}
/**
* get方法
* @return E
*/
public Object get(int index){
//元素坐标越界
if (index<0||index>size()) {
return new ArrayIndexOutOfBoundsException();
}
return thisItem[index];
}
/**
* set方法
* @param index 更新的坐标
* @param a1 更新的数据
* @return 更新前的数据
*/
public Object set(int index,E a1){
if (index<0||index>size()) {
return new ArrayIndexOutOfBoundsException();
}
E old = thisItem[index];
thisItem[index]=a1;
return old;
}
public boolean add(E x){
add(size(),x);
return true;
}
public void add(int size, E x) {
//数组空间不够
if (thisItem.length==size()){
createArray(size()*2+1);
for (int i = thisSize;i>size;i--) {
//依次后移数据
thisItem[i] = thisItem[i - 1];
}
thisItem[size]=x;
thisSize++;
}
}
public E remove(int index){
E removeitem=thisItem[index];
//集体前移一位
for (int i=index;i<size()-1;i++){
thisItem[i]=thisItem[i+1];
}
thisSize--;
return removeitem;
}
/**
* 扩容数组
* 如果元素个数大于先有容量,则扩充数组
* @param size
*/
public void createArray(int size){
if (size<thisSize){
return;
}
E [] old= thisItem;
E[] es = (E[]) new Object[size];
//复制数据
for (int i=0;i<thisSize;i++){
es[i]=old[i];
}
}
@Override
public java.util.Iterator iterator() {
return new ArrayListIterator();
}
private class ArrayListIterator implements java.util.Iterator<E>{
private int current=0;
@Override
public boolean hasNext() {
return current<size();
}
@Override
public E next() {
if (!hasNext()){
throw new java.util.NoSuchElementException();
}
return thisItem[current++];
}
@Override
public void remove() {
MyArryList.this.remove(--current);
}
}
@Override
public void forEach(Consumer<? super E> action) {
}
@Override
public Spliterator<E> spliterator() {
return null;
}
}
栈
定义
限制插入和删除只能在一个位置上的表,该位置是表的末端,叫做栈的顶
实现
- 链表实现,插入表的顶端实现push,删除表的顶端实现pop
- 数组实现,用一个数值指针N指向栈顶,空栈N=-1,push进栈后N+1,POP后N-1
应用
-
平衡符号
左右匹配符号就出栈,用来检查符号缺失
-
后缀表达式
-
方法调用,将本身函数的变量推进栈中(保护现场),失控递归可能使用掉全部的栈帧空间
队列
定义
插入在一端进行而删除则在另一端进行
实现
- 数组实现
- 链表实现
应用
缓冲队列
表的顶端实现push,删除表的顶端实现pop
2. 数组实现,用一个数值指针N指向栈顶,空栈N=-1,push进栈后N+1,POP后N-1
应用
-
平衡符号
左右匹配符号就出栈,用来检查符号缺失
-
后缀表达式
-
方法调用,将本身函数的变量推进栈中(保护现场),失控递归可能使用掉全部的栈帧空间
队列
定义
插入在一端进行而删除则在另一端进行
实现
- 数组实现
- 链表实现
应用
缓冲队列