链式存储是基于指针实现的,由于Java中没有指针这东西,但是我们常用就是一个数据元素+一个指针形成结点的方式去完成这个结构.而在Java中使用链式存储的其实就是我们的LinkList.链表的链接主要是通过直接来将相互关联的结点链接起来.
每一个结点的结构是: 数据元素 | 指针域
我们认为的一般的单链表结构
头指针—>头结点—>第一个有数据的元素–>元素结点
(只有指针) (无数据,可放长度) (有数据跟指针)
我们需要区分的概念:
1. 一般来说我们的链表是通过我们指针域来连接
2. 我们的长度是不受限制的,但是必须是一系列的集合,不能空缺,其实顺序表也不能空缺,但是一般没存数据的位置都默认值存了.
3. 我们的数据是从整个存储空间,找到对应的那个指针地址找到的.(java的Debug看出的应该是Id)
定义结构(即是Node类):
/**
*
* @author Administrator
* 结点的结构: 数据域+指针域
* 增加了每一个结点的消耗,但是能动态运用表结构
*
*/
public class Node {
Object element; //数据域
Node next; //指针域
//头结点的构造方法,头结点只有一个指针域 用来指向下一个结点,本身是没有数据的
//这里我们需要区分头结点还有第一个结点的差别
public Node(Node nextval) {
this.next = nextval;
}
//非头结点的构造方法
public Node(Object obj, Node nextval) {
this.element = obj;
this.next = nextval;
}
//获得当前结点的指针域
public Node getNext() {
return this.next;
}
//获得当前结点数据域的值
public Object getElement() {
return this.element;
}
//设置当前结点的指针域
public void setNext(Node nextval) {
this.next = nextval;
}
//设置当前结点数据域的值
public void setElement(Object obj) {
this.element = obj;
}
public String toString() {
return this.element.toString();
}
}
具体操作实现:(注意可以没有头结点,但是不能有没有指针)
/**
* 链表结构
* -2 -1 0
* 头指针-->头结点--->第一个数据结点
* @author Administrator
*
*/
public class LinkedListSample {
Node head; // 头指针
Node current;// 当前结点对象
int size;// 结点个数
public LinkedListSample() {
// 初始化头结点,让头指针指向头结点,并且让当前结点对象等于头结点,这时候没有任何数据
this.head = current = new Node(null);
this.size = 0;
}
// 目的是获取到操作的结点
public void index(int index) {
if (index < -1 || index > size) {
System.out.println("参数错误");
}
if (index == -1) {
// 这个说明是为了表示这个是头指针的存在
return; // 这里要有一个思想:头指针的下标是-1,第一个元素的下标是0
}
current = head.next;
int j = 0;// 循环变量
while (current != null && j < index) {
current = current.next;
j++;
}
}
// 插入操作
public void insert(int index, Object object) {
if (index < 0 || index > size) {
System.out.println("插入位置不对");
}
index(index - 1);// 确定位置,获取到操作结点的前一个对象,就是现在current就是在这个节点的前一个对象
current.setNext(new Node(object, current.next));
size++;
}
// 删除操作
public void delete(int index) {
if (index < 0 || index > size - 1) {
System.out.println("参数错误");
}
if (isEmpty()) {
System.out.println("表为空");
}
index(index - 1);
current.setNext(current.next.next);
size--;
}
// 获取具体元素
public Object get(int index) {
if (index < 0 || index > size - 1) {
System.out.println("参数错误");
}
index(index);
return current.getElement();
}
public int getSize() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public static void main(String[] args) {
LinkedListSample linkedListSample = new LinkedListSample();
linkedListSample.insert(0, "小明");
linkedListSample.insert(1, "小明");
linkedListSample.insert(2, "小黄");
Object f = linkedListSample.get(3);
System.out.println(f);
}
}
时间复杂度:
1. 查找–O(n)
2. 插入/删除–O(1)
优劣分析:
1. 不用分配空间,凡是需要每个结点多出存储指针的空间.
2. 任意的储存单位
3. 插入和删除操作时不需要移动数据元素;
劣势:
1. 单链表不支持随机读取,等于从头找到尾.