数组
-
存储区间是连续的,占用内存严重,故空间复杂度很大。但数组的二分查找(前提是必须有序)
-
时间复杂度小,为O(logN);
-
数组的特点是:
-
- 寻址容易(arr[n]=arr[0]+n*每个元素的长度,时间复杂度为O(1))
-
- 插入和删除困难(可能会引发一半以上的数据元素移动,时间复杂度为O(n));
-
- Java中的数组是定长的,如果需要变长则需要自行编程实现
public class ArrayList {
private Object[] data; // 真正存储数据
private int size = 0; // 记录存储的数据个数
public ArrayList() {
// data=new Object[10];
this(10);
}
public ArrayList(int len) {
data = new Object[len];
}
public void add(Object obj) {
data[size++] = obj;
if (size >= data.length)
resize(); //扩容处理
}
public void insert(int pos,Object obj) {
if(pos<0 || pos>=size)
throw new ArrayIndexOutOfBoundsException();
System.arraycopy(data, pos, data, pos+1, size-pos);
data[pos]=obj;
size++;
if (size >= data.length)
resize(); //扩容处理
}
private void resize() {
System.out.println(size);
Object[] res=new Object[data.length*3/2];
System.arraycopy(data, 0, res, 0, size);
this.data=res;
}
public void delete(int position) {
if(position<0 || position>=size)
throw new ArrayIndexOutOfBoundsException();
System.arraycopy(data, position+1, data, position, size-position-1);
data[--size]=null;
}
public void update(int pos,Object obj) {
if(pos<0 || pos>=size)
throw new ArrayIndexOutOfBoundsException();
data[pos]=obj;
}
public static void main(String[] args) {
ArrayList list=new ArrayList(5);
list.add(0);
for(int i=1;i<10;i++)
// list.add(i);
list.insert(0, i);
System.out.println(Arrays.toString(list.data));
//容器为15,浪费了6个存储空间
// list.delete(3);
// System.out.println(Arrays.toString(list.data));
// list.update(0, 99);
// System.out.println(Arrays.toString(list.data));
}
}
线性表
-
存储区间离散(数据不是连续存放的),占用内存比较宽松,故空间复杂度很小,
-
但时间复杂度很大O(N)。
-
链表的特点是:
-
- 寻址困难(可能需要通过遍历的方式查找元素,时间复杂度为O(n))
-
- 插入和删除容易(不需要引发元素的移动,仅仅只是进行地址的拷贝,时间复杂度为O(1))。
public class LinkedList { //单向链表,实现不够完善,重点是原理
private Node header;// 头指针,指向链表中的第一个元素
public void add(Object data) {
if (header == null) {
header = new Node(data);
} else {
Node p = header;
for (; p.next != null; p = p.next)
;
p.next = new Node(data);
}
}
//增加和实际长度无关,但是为了查询到对应的位置,时间复杂度还是O(n)
public void insert(int pos,Object data) {
Node p=header;
for(int i=1;i<=pos;i++) {
p=p.next;
}
Node tmp=new Node(data);
tmp.next=p.next;
p.next=tmp;
}
//功能并不完善
//删除和实际长度无关,O(1);但是实际上为了查询到对应的位置,时间复杂度还是O(n)
public void delete(int pos) {
Node p=header;
for(int i=1;i<pos;i++)
p=p.next;
p.next=p.next.next;
}
public void show() {
Node p = header;
for (; p != null; p = p.next)
System.out.print(p.data + "\t");
}
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.add(99);
for (int i = 0; i < 10; i++)
list.insert(0,i);
list.show();
list.delete(3);
System.out.println();
list.show();
}
class Node {
private Object data;// 存储的数据
private Node next;// 指向下一个Node对象的指针
public Node(Object data) {
this.data = data;
}
}
}