重学数据结构 - 链表

链表的基本概念

最基本的动态数据结构,与数组,栈,队列依赖于静态数组封装而来的实现不同,链表底层实现了真正的动态数组。
链表一种线性的数据结构,通过指针将一个个零散的内存块连接起来,链表的每个内存块称为结点。

  • 最简单的动态数据结构
  • 链表更重要的作用(引用/指针) - 涉及到内存管理
  • 有清晰的递归结构和性质

链表 Linked List

  • 数据存储在节点中(Node)
	//一个Node节点中一般来说只包含两个属性
    class Node {
        //当前位置的实际数据
        E e;
        //指向下一个节点的引用,如果节点是最后一个,那么该节点的next值为NULL
        Node next;
    }

例如火车,每一节车厢都可以看成一个Node节点,中间的链接锁可以看成是next,如图所示
在这里插入图片描述

优点

  • 真正的动态数据结构,不需要处理固定容量的问题

缺点

  • 不能随机访问,数组通过索引访问,且在内存中开辟空间是连续分布的。但是链表是靠next链接,计算机底层每个节点所在内存的位置是不同的,只能依靠next去进行顺序查找。

实现一个简单的链表

实现一个链表的几个关键元素

  • Node节点对象
  • 头节点
  • 链表长度
package com.yunhuxi.cloudeyes.util.data.structure.linked.list;

public class LinkedList<E> {

    //使用private保证节点只允许在链表内部访问,对于用户来说,不需要了解底层实现,不关注节点的实现细节,所以该类应该基于封装的思想进行隐藏。
    private class Node {
        public E e;
        public Node next;

        //构造方法,需要考虑多个情况对构造进行方法重载
        public Node() {
            this(null, null);
        }

        public Node(E e) {
            this(e, null);
        }

        public Node(E e, Node node) {
            this.e = e;
            this.next = node;
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    //定义头节点
    private Node head;

    //定义链表长度
    private int size;

    public LinkedList(){
        head = null;
        size = 0;
    }

    // 获取链表中的元素个数
    public int getSize(){
        return size;
    }

    // 返回链表是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    // 在链表头添加新的元素e
    public void addFirst(E e){
        add(0, e);
    }

    // 在链表的index位置添加新的元素e,如果是0,代表没有前节点
    public void add(int index, E e){

        if(index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Illegal index.");
        }

        if (index != 0) {
            Node prev = head;
            int i = 0 ;
            while (i < index - 1) {
                prev = prev.next;
                i++;
            }
            prev.next = new Node(e, prev.next);
            size ++;
        } else {
            addFirst(e);
        }
    }

    // 在链表末尾添加新的元素e
    public void addLast(E e){
        add(size, e);
    }
}

上面的代码存在问题

头插入的特殊处理

由于链表头部和在其他位置添加逻辑上会有差别,因为头部插入时要找到待添加前的一个节点,链表头并没有前面的节点。所以头插是比较特殊的。

统一处理这种特殊节点

目前的核心问题是链表头并没有前面的节点。那么是否可以添加一个虚拟的头节点来解决这个问题。

将链表头设置为null,不存储为任何元素,将这个节点称之为head node.
改后的代码
核心改动点就是在初始化head时,不再赋值为null而是初始化一个无参的node对象。
原代码
	public LinkedList(){
        head = null;
        size = 0;
    }
新代码
	public LinkedList(){
        //改动位置
        head = new Node();
        size = 0;
    }


	// 在链表的index位置添加新的元素e,如果是0,代表没有前节点
    public void add(int index, E e){

        if(index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Illegal index.");
        }

        //改动位置
        Node prev = head;
        int i = 0 ;
        while (i < index) {
            prev = prev.next;
            i++;
        }

        prev.next = new Node(e, prev.next);
        size ++;
    }

链表的查询

	// 获得链表的第index个位置的元素
    public E get(int index){
    
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Get failed. Illegal index.");
        }
     
		//由于这里是为了查询元素,所以应该从虚拟节点head的下一个实际数据的节点来开始查找,这是Node cur = head.next在这里的的原因
        Node cur = head.next;
        int i = 0 ;
        while (i < index) {
            cur = cur.next;
            i++;
        }
        return cur.e;
    }

	// 获得链表的第一个元素
    public E getFirst(){
        return get(0);
    }

    // 获得链表的最后一个元素
    public E getLast(){
        return get(size - 1);
    }
    
	// 查找链表中是包含元素
    public boolean contains(E e){
        Node cur = head.next;
        if (cur != null) {
            do {
                if (cur.e.equals(e)) {
                    return true;
                }
                cur = cur.next;
            } while (cur != null);
        }
        return false;
    }

链表的修改

 	// 修改链表的第index个位置的元素,
    public void set(int index, E e){
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Set failed. Illegal index.");
        }
		
		//这个位置需要不断遍历这个链表,查询是否包含元素,不包含返回false,包含返回true
        Node cur = head.next;
        int i = 0 ;
        while (i < index) {
            cur = cur.next;
            i++;
        }
        cur.e = e;
    }
    
	//重写toString,处理一下返回值格式
	@Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        Node cur = head.next ;
        while (cur != null) {
            res.append(cur + "->");
            cur = cur.next;
        }
        res.append("NULL");
        return res.toString();
    }

链表的删除

	// 从链表中删除第一个元素, 返回删除的元素
    public E removeFirst(){
        return remove(0);
    }

    // 从链表中删除最后一个元素, 返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }

    // 从链表中删除元素e
    public void removeElement(E e){
		
		//断开头节点
        Node prev = head;
        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 --;
        }
    }

链表的扩展性分析

使用链表实现一个栈

基于之前的Stack接口实现一个栈,可以去看前面的博客
package com.yunhuxi.cloudeyes.util.data.structure.linked.list;

import com.yunhuxi.cloudeyes.util.data.structure.stack.Stack;
import java.util.stream.IntStream;

public class LinkedListStack<E> implements Stack<E> {

    private LinkedList<E> list;

    public LinkedListStack(){
        list = new LinkedList<>();
    }

    @Override
    public int getSize(){
        return list.getSize();
    }

    @Override
    public boolean isEmpty(){
        return list.isEmpty();
    }

    @Override
    public void push(E e){
        list.addFirst(e);
    }

    @Override
    public E pop(){
        return list.removeFirst();
    }

    @Override
    public E peek(){
        return list.getFirst();
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Stack: top ");
        res.append(list);
        return res.toString();
    }

    public static void main(String[] args) {

        LinkedListStack<Integer> stack = new LinkedListStack<>();

        IntStream.range(0, 5).forEach(i -> {
            stack.push(i);
            System.out.println(stack);
        });

        stack.pop();
        System.out.println(stack);
    }
}

1.算法是程序的灵魂,优秀的程序在对海量数据处理时,依然保持高速计算,就需要高效的数据结构和算法支撑。2.网上数据结构和算法的课程不少,但存在两个问题:1)授课方式单一,大多是照着代码念一遍,数据结构和算法本身就比较难理解,对基础好的学员来说,还好一点,对基础不好的学生来说,基本上就是听天书了2)说是讲数据结构和算法,但大多是挂羊头卖狗肉,算法讲的很少。 本课程针对上述问题,有针对性的进行了升级 3)授课方式采用图解+算法游戏的方式,让课程生动有趣好理解 4)系统全面的讲解了数据结构和算法, 除常用数据结构和算法外,还包括程序员常用10大算法:二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题,让你秒杀其他面试小伙伴3.如果你不想永远都是代码工人,就需要花时间来研究下数据结构和算法。教程内容:本教程是使用Java来讲解数据结构和算法,考虑到数据结构和算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。学习目标:通过学习,学员能掌握主流数据结构和算法的实现机制,开阔编程思路,提高优化程序的能力。
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页