恋上数据结构与算法第一季笔记（一）——单链表、双向链表、单向循环链表

最新推荐文章于 2022-11-27 00:54:12 发布
最新推荐文章于 2022-11-27 00:54:12 发布
阅读量158 收藏
点赞数
分类专栏： 恋上数据结构与算法第一季  数据结构 文章标签： 单链表 双向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44855907/article/details/114700590
版权

单链表

在这里插入图片描述

链表设计

在这里插入图片描述

接口设计

在这里插入图片描述

LinkedList 类

构造方法和头结点

       /**
     * 头结点
     */
    private Node<E> head;

    /**
     * 构造方法
     * @param <E>
     */
    private static class Node<E>{
    	//节点元素
        E element;
        //下一个节点引用
        Node<E> next;
        public Node(E element, Node<E>  next) {
            this.element = element;
            this.next = next;
        }
    }

清空链表 clear()

头指针指向空，链表长度置为0

    /**
     * 清除所有元素
     */
    @Override
    public void clear() {
        size = 0;
        head = null;
    }

添加节点 add( int index, E e)

要注意边界情况，index = 0时，index = size - 1时

1、 插入位置为头结点后面
在这里插入图片描述

2 、 插入位置为头结点之后的位置
在这里插入图片描述

/**
     * 在index位置插入一个元素
     * @param index
     * @param e
     */
    @Override
    public void add(int index, E e) {
        //特判往头结点后插入元素的情况
        if( index == 0){
            Node<E> node = new Node(e, head);
            head = node;
        }else{
	         //获取前驱节点
	        Node<E> pre = get_Node(index - 1);
	        Node<E> node = new Node(e,pre.next);
	        pre.next = node;
        }
       size ++;

    }

尾部节点插入 元素的方法add(E element)也是使用add(int index, E e)方法，只需在AbstractList调用该方法并指定index = size即可。这是多态的表现，接口（List）声明的变量 （list）被赋值为该接口实现类（ArrayList）的对象的引用。则调用该接口的方法，就可以调用到接口的实现类的方法。

调用接口List的void add(E i)，会调用其实现类AbstracList的void add(E element)

public void add(E element) {
add(size, element);
}

而该方法又会去调用 add(size, element);调用add(size, element)的过程与之类似，最后调用的是LinkedList的add(int index, E e)

public void add(E element) {
        add(size, element);
    }

删除节点 remove(int index)

在这里插入图片描述

注意边界情况，当index == 0时，一般情况是index >= 1

    /**
     * 按索引删除元素，返回被删除元素的值
     *
     * @param index
     */
    @Override
    public E remove(int index) {
        Node<E> node = head;
        if( index == 0){
            head = head.next;
        }else{
            Node<E> pre = get_Node(index - 1);
            node = pre.next;
            pre.next = node.next;
        }
        //size要减1
        size --;
        return node.element;
    }

indexOf(Element e) 返回元素所在节点下标

 /**
     *  返回元素所在节点下标
     *
     * @param element
     */
    @Override
    public int indexOf(E element) {
        Node<E> p = head;
        //i记录下标
        int i = 0;
        //遍历链表
        while( p != null)
        {
            if( p.element == element){
                return i;
            }
            p = p.next;
            i ++;
        }
        return ELEMENT_NOT_FOUND ;
    }

接口与抽象类

单链表和双链表的接口和抽象类都是一样的，如下

List接口



package DoubleList;

interface List<E> {
    /**
     * 公共接口，将共有的且每个子类具体实现都不一样的地方抽象出来放在接口处.
     * 接口本身就是交由子类实现的，因此其权限本身就是public的，无需写
     */

    static final int ELEMENT_NOT_FOUND = - 1;
    /**
     * 清除所有元素
     */
     void clear();

    /**
     * 返回长度
     */
     int size();

    /**
     * 判断是否为空
     */
     boolean isEmpty();

    /**
     * 判断是否包含该元素
     */
     boolean  contains(E element);

    /**
     * 在index位置插入一个元素
     */
     void add(int index, E e);

     /**
      * 按索引获取节点元素值
      *
      * @param i
      */
     E get(int i);

     /**
      * 设置index位置的元素 返回原来元素
      */
     E set(int index, E element);

    /**
     * 按索引删除元素
     */
     E remove(int index);

    /**
     * 返回给定元素在的位置
     */
     int indexOf(E element);

     void add(E i);
 }

AbstractList

package DoubleList;

abstract class AbstractList<E> implements List<E> {

    /**
     * 该类实现子类共有的方法
     */
    /**
     * Constructs a new object.
     */
    public AbstractList() {
        super();
    }

    /**
     * 元素的数量
     */
    protected int size;
    /**
     * 元素的数量
     * @return
     */
    public int size() {
        return size;
    }

    /**
     * 是否为空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 是否包含某个元素
     * @param element
     * @return
     */
    public boolean contains(E element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

    /**
     * 添加元素到尾部
     *
     * @param element
     */
    @Override
    public void add(E element) {
        add(size, element);
    }




    protected void outOfBounds(int index) {
        throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
    }

    protected void rangeCheck(int index) {
        if (index < 0 || index >= size) {
            outOfBounds(index);
        }
    }

    protected void rangeCheckForAdd(int index) {
        if (index < 0 || index > size) {
            outOfBounds(index);
        }
    }
}

SingleList

package SingleList;

public class SingleList<E> extends AbstractList<E> {
    /**
     * 内部类且声明为私有（只在链表LinkedList内部使用 对外部是不可见的）和静态
     */


    /**
     * 头结点：是对第一个节点的引用
     */
    private Node<E> head;

    /**
     * 构造方法
     * @param <E>
     */
    private static class Node<E>{
        E element;
        Node<E> next;
        public Node(E element, Node<E>  next) {
            this.element = element;
            this.next = next;
        }

    }
    /**
     * 清除所有节点
     */
    @Override
    public void clear() {
        //数量置为0 同时头结点也要指向空
        size = 0;
        head = null;
    }


    /**
     * 在index位置插入一个节点
     * @param index
     * @param e
     */
    @Override
    public void add(int index, E e) {
        System.out.println("SingleList.LinkedList……");
        //先判断索引是否合法
        rangeCheckForAdd(index);
        //特判往头结点后插入节点的情况
        if( index == 0){
            //新节点
            Node<E> node = new Node(e, head);
            head = node;
        }else{
            //获取前驱节点
            Node<E> pre = get_Node(index - 1);
            //新节点
            Node<E> node = new Node(e,pre.next);
            pre.next = node;
        }
        //长度加1
        size ++;
    }


    /**
     * 按索引获取节点值
     *
     * @param i
     */
    @Override
    public E get(int i) {
        return get_Node(i).element;
    }

    /**
     * 设置index位置的节点，返回原来节点的元素值
     * @param index
     * @param element
     */
    @Override
    public E set(int index, E element) {
        Node<E> node = get_Node(index);
        E val = node.element;
        node.element = element;
        return val;
    }

    /**
     * 按索引删除节点，返回被删除节点的元素值
     *
     * @param index
     */
    @Override
    public E remove(int index) {
        Node<E> node = head;
        if( index == 0){
            head = head.next;
        }else{
            Node<E> pre = get_Node(index - 1);
            node = pre.next;
            pre.next = node.next;
        }
        //size要减1
        size --;
        return node.element;
    }

    /**
     *  返回元素所在节点下标
     *
     * @param element
     */
    @Override
    public int indexOf(E element) {
        Node<E> p = head;
        //i记录下标
        int i = 0;
        //遍历链表
        while( p != null)
        {
            if( p.element == element){
                return i;
            }
            p = p.next;
            i ++;
        }
        return List.ELEMENT_NOT_FOUND ;
    }

    /**
     * 按索引获取某个节点
     * @param index
     * @return
     */
    public Node<E> get_Node(int index){
        rangeCheck(index);
        Node<E> node = head;
        for(int i = 0; i < index; i ++) node = node.next;
        return node;
    }

    public String toString() {
        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append(", [");
        Node<E> node = head;
        for (int i = 0; i < size; i++) {
            if (i != 0) {
                string.append(", ");
            }

            string.append(node.element);

            node = node.next;
        }
        string.append("]");
        return string.toString();
    }
}

测试：

public class Main {
    public static void main(String[] args) {
        //父类引用指向子类对象 add方法也要在List接口中声明
        //如果是只在LinkedList子类中定义 是无法通过父类引用来调用子类特有的方法的
        List<Integer> list = new LinkedList<>();
        list.add(20);
        list.add(0,10);
        list.add(30);
        list.add(list.size() , 40);
        [10, 20, 30, 40]
        list.remove(0);
        list.remove(list.size() - 1);
        System.out.println(list);
        System.out.println( list.get(1)  );
        System.out.println( list.contains(20) );




    }
}

复杂度分析

最好平均最坏
add(int index, Element e)O(1)O(n)O(n)
remove(int index)O(1)O(n)O(n)
set(int index, Element e)O(1)O(n)O(n)
get(int index)O(1)O(n)O(n)

双向链表

在这里插入图片描述

LinkedList类方法及属性

 /**
     * 头结点（head）：是对第一个节点的引用
     * 尾结点（tail）： 对最后一个节点的引用
     */
    private Node<E> head;
    private Node<E> tail;

    /**
     * 构造方法
     * @param <E>
     */
    private static class Node<E>{
        E element;
        Node<E> prev;  //前驱
        Node<E> next;  //后继
        public Node(Node<E>  prev, E element, Node<E>  next) {
            this.prev = prev;
            this.element = element;
            this.next = next;
        }

    }

clear

    /**
     * 清除所有节点
     */
    @Override
    public void clear() {
        //数量置为0 同时头结点、尾结点也要指向空
        size = 0;
        tail = null;
        head = null;
    }

tail = null;head = null;之后，虽然每个节点存在相互引用，但是根据GC root是否可达，JVM中的GC会自动释放一连串的Node对象。
GC root对象是：

  1. 被局部变量所指向的对象

Node get_Node(int index)

待查找元素在左半边 从前往后查找。待查找元素在右半边 从后往前查找


    /**
     * 按索引获取某个节点
     * @param index
     * @return
     */
    public Node<E> get_Node(int index){
        rangeCheck(index);
        if( index < (size >> 1) ){//待查找元素在左半边 从前往后查找
            Node<E> node = head;
            for(int i = 0; i < index; i ++) node = node.next;
            return node;

        }else{//待查找元素在右半边 从后往前查找
            Node<E> node = tail;
            for(int i = size - 1; i > index; i --) node = node.prev;
            return node;
        }
    }

add(int index, E e)

【思路】
插入的位置可能在
1、尾部插入：涉及到tail尾结点。尾部插入时，也有特殊情况。即 index== size == 0，此时oldTail 为null，前一个节点应该为null，head 和tail都指向该新节点。
2、头部及中间位置插入：涉及到head头结点。头部插入（index==0且size > 0时），头结点head指向该节点。其他情况都是prev.next = current;

/**
     * 在index位置插入一个节点
     * @param index
     * @param e
     */
    @Override
    public void add(int index, E e) {
        //先判断索引是否合法
        rangeCheckForAdd(index);

        //往尾部添加节点 涉及到尾结点tail
        if( index == size){
            Node oldTail = tail;
            tail = new  Node(oldTail,e ,null);
            //oldTail可能为null：当index == 0且size == 0时
            if( oldTail == null ) head = tail;
            else  oldTail.next = tail;
        }else{
            //往[0,size - 1)位置添加节点
            //且往0添加时 不是第一个节点 其后已经有节点存在了
            Node next = get_Node(index);
            Node prev = next.prev;
            Node current =  new Node(prev, e, next);
            next.prev = current;
            
            //插入位置是0  则head = current
            if(prev == null) head = current;
            //插入位置是除0和尾结点外的位置
            else prev.next = current;

        }
        //长度加1
        size ++;
    }

E remove(int index)

  /**
     * 按索引删除节点，返回被删除节点的元素值
     *
     * @param index
     */
    @Override
    public E remove(int index) {
        //检查索引是否合法
        rangeCheck(index);
        
        Node<E> node = get_Node(index);
        Node prev = node.prev;
        Node next = node.next;

        //头结点
        if( prev == null) head = next;
        else  prev.next = next;
        
        //尾结点
        if( next == null) tail = prev;
        else next.prev = prev;
        
        //size --
        size --;
        
        return  node.element;
     
    }

DoubleList.LinkedList

package DoubleList;

public class LinkedList<E> extends AbstractList<E> {
    /**
     * 内部类且声明为私有（只在链表LinkedList内部使用 对外部是不可见的）和静态
     */


    /**
     * 头结点（head）：是对第一个节点的引用
     * 尾结点（tail）： 对最后一个节点的引用
     */
    private Node<E> head;
    private Node<E> tail;


    /**
     * 构造方法
     * @param <E>
     */
    private static class Node<E>{
        E element;
        Node<E> prev;  //前驱
        Node<E> next;  //后继
        public Node(Node<E>  prev, E element, Node<E>  next) {
            this.prev = prev;
            this.element = element;
            this.next = next;
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            if( this.prev != null) sb.append( this.prev.element);
            else sb.append("null");
            sb.append( "__").append( this.element ).append( "__");

            if( this.next != null) sb.append( this.next.element);
            else sb.append("null");


            return sb.toString();
        }
    }
    /**
     * 清除所有节点
     */
    @Override
    public void clear() {
        //数量置为0 同时头结点、尾结点也要指向空
        size = 0;
        tail = null;
        head = null;
    }


    /**
     * 在index位置插入一个节点
     * @param index
     * @param e
     */
    @Override
    public void add(int index, E e) {
        //先判断索引是否合法
        rangeCheckForAdd(index);

        //往尾部添加节点 涉及到尾结点tail
        if( index == size){
            Node oldTail = tail;
            tail = new  Node(oldTail,e ,null);
            //oldTail可能为null：当index == 0且size == 0时
            if( oldTail == null ) head = tail;
            else  oldTail.next = tail;
        }else{
            //往[0,size - 1)位置添加节点
            //且往0添加时 不是第一个节点 其后已经有节点存在了
            Node next = get_Node(index);
            Node prev = next.prev;
            Node current =  new Node(prev, e, next);
            next.prev = current;

            //插入位置是0  则head = current
            if(prev == null) head = current;
            //插入位置是除0和尾结点外的位置
            else prev.next = current;

        }
        //长度加1
        size ++;
    }


    /**
     * 按索引获取节点值
     *
     * @param i
     */
    @Override
    public E get(int i) {
        return get_Node(i).element;
    }

    /**
     * 设置index位置的节点，返回原来节点的元素值
     * @param index
     * @param element
     */
    @Override
    public E set(int index, E element) {
        Node<E> node = get_Node(index);
        E val = node.element;
        node.element = element;
        return val;
    }

    /**
     * 按索引删除节点，返回被删除节点的元素值
     *
     * @param index
     */
    @Override
    public E remove(int index) {
        //检查索引是否合法
        rangeCheck(index);

        Node<E> node = get_Node(index);
        Node prev = node.prev;
        Node next = node.next;

        //头结点
        if( prev == null) head = next;
        else  prev.next = next;

        //尾结点
        if( next == null) tail = prev;
        else next.prev = prev;

        //size --
        size --;

        return  node.element;

    }

    /**
     *  返回元素所在节点下标
     *
     * @param element
     */
    @Override
    public int indexOf(E element) {
        Node<E> p = head;
        //i记录下标
        int i = 0;
        //遍历链表
        while( p != null)
        {
            if( p.element == element){
                return i;
            }
            p = p.next;
            i ++;
        }
        return List.ELEMENT_NOT_FOUND ;
    }

    /**
     * 按索引获取某个节点
     * @param index
     * @return
     */
    public Node<E> get_Node(int index){
        rangeCheck(index);
        if( index < (size >> 1) ){//带查找元素在左半边 从前往后查找
            Node<E> node = head;
            for(int i = 0; i < index; i ++) node = node.next;
            return node;

        }else{
            Node<E> node = tail;
            for(int i = size - 1; i > index; i --) node = node.prev;
            return node;
        }
    }

    public String toString() {
        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append(", [");
        Node<E> node = head;
        for (int i = 0; i < size; i++) {
            if (i != 0) {
                string.append(", ");
            }

            string.append(node);

            node = node.next;
        }
        string.append("]");
        return string.toString();
    }
}

单链表与双链表的比较

在这里插入图片描述

双向链表与动态数组

在这里插入图片描述

单向循环链表

在这里插入图片描述

add

注意只有一个节点时的插入

在这里插入图片描述

/**
     * 在index位置插入一个节点
     * @param index
     * @param e
     */
    @Override
    public void add(int index, E e) {
        //先判断索引是否合法
        rangeCheckForAdd(index);
        //特判往头结点后插入节点的情况
        if( index == 0){
            //新节点
            Node<E> node = new Node(e, head);
            //size == 0时，最后一个节点即为 node
            //在修改线之前去查找
            Node<E> last= size == 0 ? node : get_Node(size - 1);
            head = node; //头结点指向新节点
            last.next = node;


        }else{
            //获取前驱节点
            Node<E> pre = get_Node(index - 1);
            //新节点
            Node<E> node = new Node(e,pre.next);
            pre.next = node;
        }
        //长度加1
        size ++;
    }

remove

/**
     * 按索引删除节点，返回被删除节点的元素值
     *
     * @param index
     */
    @Override
    public E remove(int index) {
        Node<E> node = head;

        if( index == 0){
            //index == 0 &&size == 1 头结点指向null
            if( size == 1) head = null;
            else{
                Node last = get_Node(size - 1); //最后一个节点
                head = head.next;
                last.next = head;
            }
        }else{
            Node<E> pre = get_Node(index - 1);
            node = pre.next;
            pre.next = node.next;
        }
        //size要减1
        size --;
        return node.element;
    }
JohnnyLin00
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
小码哥《恋上数据结构与算法》笔记（一）：动态数组
Guizy
03-28 2073
目录 一、数组(Array) 二、动态数组（Dynamic Array）接口设计 三、动态数组的实现 1、构造方法 2、添加元素 2.1、数组越界 2.2、数组扩容 3、删除元素 3.1、数组越界 3.2、数组缩容 4、清空数组 5、修改元素 6、查询元素 7、查看元素位置 8、是否包含某元素 9、元素的数量 10、数组是否为空 11、动态数组打印 四、动态数组的复杂度 五、A...
恋上数据结构与算法_恋上数据结构与算法笔记（一）：数据结构与算法基本知识...
weixin_39844267的博客
12-20 228
什么是数据结构数据结构是计算机存储、组织数据的方式，大致划分为：线性结构数组、链表、栈、队列、哈希表树形结构AVL树、红黑树、B树、堆、Trie、哈夫曼树、并查集图形结构邻接矩阵、邻接表什么是算法基本概念算法是用于解决特定问题的一系列的执行步骤。解决同一个问题，可能有多种算法，应该选用最易读的，并且执行效率最高的代码。以下代码示例都是算法：计算两个数的和：public int plus(int a...
恋上数据结构与算法第三季课程笔记01
dream_loverm的博客
01-09 511
注：有的图参来源于网络资源 1._88合并两个有序数组 标签：归并排序，三指针 思路：设置三个指针，分别指向实际数组一的尾部 i1、数组i2、整体数组的尾部i3。 每次比较i1和i2指向的值，若i2 > i1,则将i2指向的值与i3指向的值交换，同时i2--,i3--. 若i2 <= i1,则将i1指向的值与i3指向的值交换，同时i1--,i3--. ...
《恋上数据结构第1季》二叉树基础、真二叉树、满二叉树、完全二叉树、二叉树的遍历（重点）
萌宅鹿的技术小屋
05-04 3167
二叉树树（Tree）的基本概念有序树、无序树、森林二叉树（Binary Tree）二叉树的性质真二叉树（Proper Binary Tree）满二叉树（Full Binary Tree）完全二叉树（Complete Binary Tree）面试题（完全二叉树）二叉树的遍历 + 练习题前序遍历（Preorder Traversal）中序遍历（Inorder Traversal）后序遍历（Postor...
【恋上数据结构与算法】学习笔记-动态数组（C++）
Ref.Ptr.的博客
12-18 229
2020.12.18 学习笔记，未完待续。 即将硕士毕业从事C++开发人员，修炼内功，欢迎纠错与讨论。 动态数组（C++）一、什么是数据结构？二、线性表三、数组（Array）四、动态数组（Dynamic Array）1、动态数组接口设计2、构造函数与析构函数3、元素数量4、是否为空5、根据索引查看元素6、设置元素7、查看元素位置8、包含元素9、清除所有元素10、打印数组-重载<<11、删除元素12、添加元素 一、什么是数据结构？ 数据结构是计算机存储、组织数据的方式 二、线性表 线性表是.
《恋上数据结构与算法》第1季：双向链表实现（超详细笔记，图文并茂）
weixin_46312449的博客
11-27 477
之前我们所学的链表也叫做单向链表，单向链表的其中一个不好之处就是 无论添加，删除，查询，修改等操作，都需要从头结点开始依次查询要操作的节点。因此，为了解决这一问题，我们就需要使用双向链表，使用双向链表可以提升链表的综合性能。
《恋上数据结构与算法》第1季：链表原理实现（图文并茂）
weixin_46312449的博客
11-27 493
动态数组有个明显的缺点，可能会造成内存空间的大量浪费；第一种：插入到0的位置，需要使用first指向新节点。第二种：插入到非0的位置，直接找到前一个节点进行处理。的线性表，所有元素的内存地址不一定是连续的。到此为止，我们成功的实现了链表。first 指向 null。size 是否等于 0。0 到 size-1。
小码哥《恋上数据结构与算法》学习笔记.zip
01-01
小码哥的《恋上数据结构与算法》学习笔记涵盖了这一主题的关键知识点，通过深入浅出的方式帮助学习者理解和掌握数据结构的基本概念。 1. **数组**：数组是最基础的数据结构，它是一系列相同类型元素的集合，可以...
c语言数据结构与算法 5天培训原码与笔记
12-02
链表分为单向链表、双向链表和循环链表，C语言中通常通过结构体定义节点。 4. **二叉树（Binary Tree）**：每个节点最多有两个子节点的数据结构，分为左子节点和右子节点。常见的二叉树类型有满二叉树、完全二叉树...
数据结构和算法笔记与快速入门.zip
最新发布
06-17
这份"数据结构和算法笔记与快速入门.zip"压缩包文件显然旨在为学习者提供一个全面的起点，帮助他们掌握这个领域的核心概念。 数据结构是计算机存储、组织数据的方式，它决定了数据的逻辑结构、物理存储以及对数据的...
恋上数据结构课件.rar
07-29
小码哥恋上数据结构课程课件pdf格式 01-学前须知.pdf 02-开发环境，pdf 03-复杂度.pdf 04-动态数组.pdf 05-链表.pdf 06-栈.pdf 07-队列.pdf 08-二叉树.pdf 09-二又搜索树.pdf 10-平衡二又搜索树.pdf 11-AVL树.pdf 12-B树.pdf 园13-红黑树.pdf 14-集合.pdf 15-映射.pdf 16-哈希表.pdf 圆17-二叉堆.pdf 18-优先级队列.pdf 19-哈夫曼树.pdf 20-Trie.pdf 21-总结.pdf
数据结构课程设计 单链表操作
05-27
问题描述： 针对带头结点的单循环链表，编写实现以下操作的算法函数。 实现要求： ⑴ 单链表建立函数create：先输入数据到一维数组A[M]中，然后根据一维数组A[M]建立一个单循环链表，使链表中个元素的次序与A[M]中各元素的次序相同，要求该函数的时间复杂度为O(m)； ⑵ 定位查找函数Locate：在所建立的单循环链表中查找并返回值为key的第1个元素的结点指针；若找不到，则返回NULL； ⑶ 求出该链表中值最大和次大的元素值，要求该算法的时间复杂度为O(m)，最大和次大的元素值通过指针变量带回，函数不需要返回值； ⑷ 将链表中所有值比key(值key通过形参传入)小的结点作为值为key的结点前驱，所有值比key大的结点作为值为key的结点后继，并尽量保持原有结点之间的顺序，要求该算法的时间复杂度为O(m); ⑸ 设计一个菜单，具有上述处理要求和退出系统功能。
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
Data Structure and Algorithms（常用数据结构与算法）.zip
06-16
链表分为单向链表、双向链表和循环链表，适合频繁的插入和删除操作。 3. **栈**：是一种后进先出（LIFO）的数据结构，常用于函数调用、表达式求值等场景。栈的主要操作有压栈（push）和弹栈（pop）。 4. **队列**...
【恋上数据结构】串匹配算法（蛮力匹配、KMP【重点】、Boyer-Moore、Karp-Rabin、Sunday）
萌宅鹿的技术小屋
04-27 1397
串（Sequence）串（前缀、后缀）串匹配算法蛮力（Brute Force）蛮力1 – 执行过程 + 实现蛮力1 – 优化蛮力2 – 执行过程 + 实现蛮力 – 性能分析KMP蛮力 vs KMPKMP – next表的使用KMP – 核心原理（构造next表）真前缀后缀的最大公共子串长度构造 next 表-1的精妙之处KMP – 主算法代码实现KMP – 为什么是“最大“公共子串长度？KMP –...
恋上数据结构完整笔记（第1季 + 第2季）
热门推荐
萌宅鹿的技术小屋
03-13 2万+
Java 数据结构目录 整理一下。。。 【动态扩容数组】动态扩容数组 ArrayList实现源码（Java、C++） 【链表List】单向链表 SingleLinkedList、双向链表 LinkedList 实现源码 【循环链表CircleList】单向循环链表、双向循环链表以及约瑟夫环问题 【队列Queue】队列 Queue、双端队列 DeQueue、循环队列 CircleQueue、双端循环...
小码哥《恋上数据结构与算法》笔记（四）：循环链表
Guizy
04-12 501
具体代码在 LinkedList , 欢迎 star 目录 一、单向循环链表（Simple LinkedList） 二、单向循环链表接口设计 三、单向循环链表的实现 1、插入结点 2、删除结点 3、清空结点 4、插入结点 (重点) 5、删除结点 6、测试双向链表 六、双向链表和动态数组比较 一、单向循环链表 尾结点的next，指向头结点。 二、单向循环链表接口设计 相对于单...
《恋上数据结构与算法》笔记（十六）：二叉堆
Guizy
12-27 428
目录 一、二叉堆（Heap） 1、问题 2、二叉堆概念 3、堆的接口设计 二、二叉堆（Binary Heap） 三、二叉堆（Binary Heap）接口实现 1、构造方法 2、添加 3、删除 4、replace操作 5、批量建堆 6、TopK问题 四、leetcode算法题 五、二叉堆代码(完整) 一、二叉堆（Heap） 1、问题 设计一种数据结构，用来存放整数，要求提3个接口。 添加元素 获取最大值 删除最大值 更优秀的数据结构：堆，获取最大值复杂度O(1)，删除最大值O(l
小码哥《恋上数据结构与算法》笔记（六）：队列、双端队列、循环队列、循环双端队列
Guizy
04-15 575
具体代码在 Queue , 欢迎 star 目录 一、队列（Queue） 二、队列接口设计 三、队列的实现 四、leetcode-栈实现队列 五、双端队列（Deque） 六、双端队列的接口设计与实现 七、循环队列（Circle Queue） 八、循环队列的接口设计 九、循环队列的实现 1、构造方法 2、入队 2.1、数组扩容 2.2、索引计算 3、出队 十、循环双端队列 一、...
链表数据结构详解：单链表、双向链表与循环链表
文档详细讲解了链表与数组的区别、链表的三种类型：单链表、双向链表和循环链表，并阐述了每种链表的操作方法。" 链表作为一种重要的数据结构，它的特点是存储元素的位置不必连续，而是通过指针链接。这种特性使得...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值