前言
为了面试,时隔一年不得不重新复习数据结构与算法,这次重新复习很有收获,以前在上课总有不清晰的知识,通过这次手写一遍和敲一遍代码,以前不清晰的知识都变得清晰了,果然学编程还是得多敲代码,多敲代码,多敲代码,也要多总结,多总结,多总结。
学习资源
视频 黑马程序员 数据结构与算法
单向链表
单向链表是链表的一种,它由多个结点组成,每个结点都由一个数据域和一个指针域组成,数据域用来存储数据,指针域用来指向其后继结点。链表的头结点的数据域不存储数据,指针域指向第一个真正存储数据的结点。
import java.util.Iterator;
//单向链表
public class LinkList<T> implements Iterable<T> {
private Node head; //记录头结点
private int N; //记录链表的长度
//节点类
private class Node {
T item; //存储数据
Node next; //下一个结点
public Node(T item,Node next){
this.item = item;
this.next =next;
}
}
//初始化头结点和元素个数
public LinkList(){
this.head = new Node(null,null);
this.N=0;
}
//清空链表
public void clear(){
head.next=null;
this.N=0;
}
//获取链表的长度
public int length(){
return N;
}
//判断链表是否为空
public boolean isEmpty(){
return N==0;
}
//获取指定位置i出的元素
public T get(int i){
//通过循环,从头结点开始往后找,依次找i次,就可以找到对应的元素
Node n = head;
for(int index=0; index<i;index++){ //1->2->3->4 i=2 找到 2 的位置值为3
n=n.next;
}
return n.item;
}
//向链表中添加元素t
public void insert(T t){
//找到最后一个结点
Node n = head;
while (n.next!=null){
n=n.next;
}
//创建新结点,保存元素t
Node newNode = new Node(t,null); //t->null
//让当前最后一个结点指向新结点
n.next = newNode; //1->2->3->4 -> t->null
N++; //元素的个数+1
}
//向指定位置i出,添加元素t 1->3->4 i=1 t=2
public void insert(int i,T t){
//找到i位置前一个结点
Node pre = head;
for(int index = 0; index<=i-1;index++){
pre=pre.next;
}
//找到i位置的结点 3
Node curr = pre.next;
//创建新结点,并且新结点需要指向原来i位置的结点
Node newNode = new Node(t,curr); //2->3
//原来i位置的前一个节点指向新结点即可
pre.next = newNode; //1->2 1->2->3->4
}
public T remove(int i){
//找到i位置的前一个节点
Node pre = head;
for(int index=0;index<=i-1;index++){
pre = pre.next;
}
//要找到i位置的结点
Node curr = pre.next;
//找到i位置的下一个结点
Node nextNode = curr.next;
//前一个结点指向下一个结点
pre.next = nextNode;
N--; //元素个数-1
return curr.item;
}
//查找元素t在链表中第一次出现的位置
public int indexOf(T t){
//从头结点开始,依次找到每一个结点,取出item,和t比较,如果相同,就找到了
Node n = head;
for(int i=0;n.next!=null;i++){
if(n.item.equals(t)){
return i;
}
}
return -1;
}
//重写迭代器遍历方法
//实现Iterable接口,重写接口的iterator方法;
@Override
public Iterator<T> iterator() {
return new LIterator();
}
//实现Iterator接口,重写hasNext方法和next方法;
private class LIterator implements Iterator{
private Node n;
public LIterator(){
this.n=head;
}
@Override
public boolean hasNext() {
return n.next!=null;
}
@Override
public Object next() {
n=n.next;
return n.item;
}
}
public static void main(String[] args) {
//创建顺序表对象
LinkList<String> sl = new LinkList<>();
//测试插入
sl.insert("张三");
sl.insert("王五");
sl.insert("赵六");
sl.insert(1,"李四");
//迭代器遍历
for (String s : sl) {
System.out.println(s);
}
System.out.println("------------------------------------------");
//测试获取
String getResult = sl.get(1);
System.out.println("获取索引1处的结果为:"+getResult);
//测试删除
String removeResult = sl.remove(0);
System.out.println("删除0处的元素是:"+removeResult);
//测试清空
sl.clear();
System.out.println("清空后的线性表中的元素个数为:"+sl.length());
}
}
链表的时间复杂度
get(int i):每一次查询,都需要从链表的头部开始,依次向后查找,时间复杂度为O(n)
insert(int i,T t):每一次插入,需要先找到i位置的前一个元素,然后完成插入操作,时间复杂度为O(n);
remove(int i):每一次移除,需要先找到i位置的前一个元素,然后完成插入操作,时间复杂度为O(n)相比较顺序表,链表插入和删除的时间复杂度虽然一样,但仍然有很大的优势,因为链表的物理地址是不连续的,它不需要预先指定存储空间大小,或者在存储过程中涉及到扩容等操作,同时它并没有涉及的元素的交换。
结论: 链表增删快,查询慢