慕课网《玩转数据结构》–链表
在线性数据结构中,如:
- 动态数组 -----|
- 栈 -----|---------->都在底层依托静态数组:靠resize解决固定容量问题
- 队列 -----|
- 链表 -------------------->真正动态的数据数据结构
为什么链表很重要?
- 链表为真正动态的数据结构
- 最简单的动态数据结构
- 更深入的理解引用(或者指针)
- 更深入理解递归
- 辅助组成其他数据结构
链表Linked List
-
数据储存在“节点”(Node)中
class Node{ E e; Node next; }
-
优点:真正的动态,不需要处理固定容量的问题
-
缺点:丧失了随机访问的能力
数组与链表的对比
数组:
- 数组最要用在索引有语义的情况,如score[2];
- 最大的优点:支持快速查询
链表:
- 链表不适合用于索引有语义的情况
- 最大的有点:动态
链表的代码实现:
public class LinkedList<E>{
//链表的内部类:节点
private class Node{
public E e;
public Node next;
//带参构造函数,为后续节点的移动作准备
public Node (E e,Node next){
this.e = e;
this.next = next;
}
public Node(E e){
this(e,null);
}
public Node(){
this(null,null);
}
@Override
public String toString(){
return e.toString();
}
}
//链表的属性
//链表的头节点,可看作下标为“-1”的节点,方便后期增加操作
private Node dummyHead;
//链表的长度,方便维护链表
private int size;
public LinkedList(){
dummyHead = new Node();
size = 0;
}
// 获取链表中的元素个数
public int getSize(){
return size;
}
// 返回链表是否为空
public boolean isEmpty(){
return size == 0;
}
//在链表的index(0-based)的位置添加新的元素e
//在链表中不是一个常用的操作,因为链表不会常用下标进行操作,当练习用:
public void add(int index,E e){
//维护下标的合法性,当插入节点的索引小于0或者超过size长度,报错:
if(index < 0 || index > size){
throw new IllegalArgumentException("Add failed. Illegal index.")
}
Node prev = dummyHead;//在链表的“-1”头节点开始遍历
for(int i = 0 ; i < index ; i++){
//遍历(index-1-(-1))次就到了需要添加的位置的前一个
//prev为所插入节点的前一个,prev.next即为所要插入的节点
prev = prev.next;
}
// Node node = new Node(e); //new一个节点,存储所要插入的数据
// node.next = prev.next; //找到插入节点的下一位的指向,并赋值给node的下一位
// prev.next = node; //插入节点的下一位指向node(见图2)
//上面3行代码可以压缩为下面一句:
prev.next = new Node(e,prev.next);
size ++;//维护链表的长度
}
// 在链表头添加新的元素e
public void addFirst(E e){
add(0, e);
}
// 在链表末尾添加新的元素e
public void addLast(E e){
add(size, e);
}
// 获得链表的第index(0-based)个位置的元素
// 在链表中不是一个常用的操作,练习用
public E get(int index){
if(index < 0 || index >= size){
throw new IllegalArgumentException("Get failed. Illegal index.");
}
Node cur = dummyHead.next; //从链表为0的节点开始遍历
for(int i = 0 ; i < index ; i++){
//相当于从0开始遍历,遍历index次就到了所要获取的上一位,next则获取到想要的节点
cur = cur.next;
}
return cur.e;
}
// 获得链表的第一个元素
public E getFirst(){
return get(0);
}
// 获得链表的最后一个元素
public E getLast(){
return get(size - 1);
}
// 修改链表的第index(0-based)个位置的元素为e
// 在链表中不是一个常用的操作,练习用:)
// 思路与get方法类似,最后需要对cur.e 赋值。
public void set(int index, E e){
if(index < 0 || index >= size){
throw new IllegalArgumentException("Set failed. Illegal index.");
}
Node cur = dummyHead.next;
for(int i = 0 ; i < index ; i ++){
cur = cur.next;
}
cur.e = e;
}
// 查找链表中是否有元素e
public boolean contains(E e){
Node cur = dummyHead.next;
//从下标为0的节点开始遍历,如果节点的下一个节点不为零就继续遍历
while(cur != null){
if(cur.e.equals(e)){
return true;
}
cur = cur.next;
}
return false;
}
// 从链表中删除index(0-based)位置的元素, 返回删除的元素
// 在链表中不是一个常用的操作,练习用:)
public E remove(int index){
if(index < 0 || index >= size){
throw new IllegalArgumentException("Remove failed. Index is illegal.");
}
//从-1开始
Node prev = dummyHead;
for(int i = 0 ; i < index ; i ++){
prev = prev.next;
}
Node retNode = prev.next;
prev.next = retNode.next;
retNode.next = null;
size --;
return retNode.e;
}
// 从链表中删除第一个元素, 返回删除的元素
public E removeFirst(){
return remove(0);
}
// 从链表中删除最后一个元素, 返回删除的元素
public E removeLast(){
return remove(size - 1);
}
// 从链表中删除元素e
public void removeElement(E e){
Node prev = dummyHead;
while(prev.next != null){
if(prev.next.e.equals(e))
break;
prev = prev.next;
}
if(prev.next != null){
Node delNode = prev.next;
prev.next = delNode.next;
delNode.next = null;
size --;
}
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
Node cur = dummyHead.next;
while(cur != null){
res.append(cur + "->");
cur = cur.next;
}
res.append("NULL");
return res.toString();
}
}
删除节点的步骤:
新增节点的步骤: