【Java】数组和线性表

数组

• 存储区间是连续的，占用内存严重，故空间复杂度很大。但数组的二分查找(前提是必须有序)

• 时间复杂度小，为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;
		}
	}
}