算法

最新推荐文章于 2021-07-14 22:22:15 发布
最新推荐文章于 2021-07-14 22:22:15 发布
阅读量300 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaoxuyang1997/article/details/102479460
版权

[数据结构][算法][面向对象][Java]
https://github.com/z8g/common

文章目录

1 设计接口

1.1 容器接口Container

package ds;
import java.util.NoSuchElementException;
public interface Container{
   
    int size();
    
    default boolean isEmpty(){
   
        return size() == 0;
    }
    default void notEmptyCheck() {
   
        if (isEmpty()) {
   
            throw new NoSuchElementException("size == 0");
        }
    }
}

1.2 背包接口Bag

package ds;

public interface Bag<T> extends Container {
   
    void add(T data);
}

1.3 栈接口Stack

package ds;

public interface Stack<T>extends Container {
   
    void push(T data);
    T pop();
    T peek();
}

1.4 队列接口Queue

package ds;

public interface Queue<T> extends Container {
   
    T peek();
    void enqueue(T data);
    T dequeue();
}

1.5 Union-Find算法接口UF

package ds;

public interface UF {
   
    int size();
    int find(int p);
    boolean connected(int p, int q);
    void union(int p, int q);
    default void validate(int p, int n) {
   
        if (p < 0 || p >= n) {
   
            throw new IllegalArgumentException("p>=0 && p<n");
        }
    }
}

2 实现接口

为数组和链表定义了公共的结点和迭代器实现。

2.1 结点类Node

package ds.util;

public class Node<T> {
   
   public T data;
   public Node<T> next;
}

2.2 数组迭代器ArrayIterator

package ds.util;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class ArrayIterator<T> implements Iterator<T> {
   
    private int i;
    private final int size;
    private final T[] array;
    public ArrayIterator(T[] array, int size) {
   
        this.array = array;
        this.size = size;
    }
    @Override
    public boolean hasNext() {
   
        return i < size;
    }
    @Override
    public T next() {
   
        if (!hasNext()) {
   
            throw new NoSuchElementException();
        }
        return array[i++];
    }
}

2.3 链表迭代器ListIterator

package ds.util;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class ListIterator<T> implements Iterator<T> {
   
    private Node<T> current;
    public ListIterator(Node<T> first) {
   
        current = first;
    }
    @Override
    public boolean hasNext() {
   
        return current != null;
    }
    @Override
    public T next() {
   
        if (!hasNext()) {
   
            throw new NoSuchElementException();
        }
        T result = current.data;
        current = current.next;
        return result;
    }
}

2.4 背包(Bag)的实现

背包(Bag)是一种不支持从中删除元素的集合数据类型。

2.4.1 能动态调整数组大小的Bag
package ds.impl;
import ds.Bag;
import java.util.Iterator;
import ds.util.ArrayIterator;

public class ArrayBag<T> implements Iterable<T>,Bag<T> {
   
    private T[] array;
    private int size;
    public ArrayBag() {
   
        array = (T[]) new Object[2];
        size = 0;
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public void add(T data) {
   
        if (size == array.length) {
   
            resize(2 * array.length);
        }
        array[size++] = data;
    }
    private void resize(int capacity) {
   
        assert capacity >= 0;
        T[] tmp = (T[]) new Object[capacity];
        System.arraycopy(array, 0, tmp, 0, size);
        array = tmp;
    }
    
    @Override
    public Iterator<T> iterator() {
   
        return new ArrayIterator(array,size);
    }
    
}
2.4.2 链式Bag的实现
package ds.impl;
import ds.util.Node;
import ds.Bag;
import java.util.Iterator;
import ds.util.ListIterator;

public class LinkedBag<T> implements Iterable<T>, Bag<T> {
   
    private Node<T> first;
    private int size;
    public LinkedBag() {
   
        first = null;
        size = 0;
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public void add(T data) {
   
        Node<T> old = first;
        first = new Node<>();
        first.data = data;
        first.next = old;
        size++;
    }
    @Override
    public String toString() {
   
        StringBuilder s = new StringBuilder();
        for (T data : this) {
   
            s.append(data).append(' ');
        }
        return s.toString();
    }
    @Override
    public Iterator<T> iterator() {
   
        return new ListIterator(first);
    }
}

2.5 栈(Stack)的实现

栈(Stack)是一种先进后出的数据类型。

2.5.1 能动态调整数组大小的Stack
package ds.impl;
import ds.Stack;
import java.util.Iterator;
import ds.util.ArrayIterator;

public class ArrayStack<T> implements Iterable<T>,Stack<T> {
   
    private T[] array;
    private int size;
    
    public ArrayStack(){
   
        array = (T[]) new Object[2];
        size = 0;
    }
    
    
    @Override
    public Iterator<T> iterator() {
   
        return new ArrayIterator(array,size);
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public void push(T data) {
   
        if(size == array.length){
   
            resize(2* array.length);
        }
        array[size++] = data;
    }
    private void resize(int capacity) {
   
        assert capacity >= size;
        T[] tmp = (T[]) new Object[capacity];
        System.arraycopy(array, 0, tmp, 0, size);
        array = tmp;
    }
    
    @Override
    public T pop() {
   
        notEmptyCheck();
        T result = array[size-1];
        array[size-1] = null;
        size--;
        if(size>0 && size == array.length/4){
   
            resize(array.length/2);
        }
        return result;
    }
    
    @Override
    public T peek() {
   
        notEmptyCheck();
        return array[size-1];
    }
}
2.5.2 链式Stack的实现
package ds.impl;
import ds.util.Node;
import ds.Stack;
import java.util.Iterator;
import ds.util.ListIterator;

public class LinkedStack<T> implements Iterable<T>,Stack<T> {
   
    private Node<T> first;
    private int size;
    public LinkedStack() {
   
        first = null;
        size = 0;
    }
    @Override
    public int size() {
   
        return size;
    }
    /**
     * 向栈中推入一个新元素
     *
     * @param data 新元素
     */
    @Override
    public void push(T data) {
   
        Node<T> oldFirst = first;
        first = new Node<>();
        first.data = data;
        first.next = oldFirst;
        size++;
    }
    /**
     * 从栈中弹出栈首元素
     *
     * @return 栈首元素
     */
    @Override
    public T pop() {
   
        notEmptyCheck();
        T result = first.data;
        first = first.next;
        size--;
        return result;
    }
    /**
     * 查看栈首元素
     * @return 栈首元素
     */
    @Override
    public T peek() {
   
        notEmptyCheck();
        return first.data;
    }
    @Override
    public String toString() {
   
        StringBuilder s = new StringBuilder();
        for (T data : this) {
   
            s.append(data).append(' ');
        }
        return s.toString();
    }
    @Override
    public Iterator<T> iterator() {
   
        return new ListIterator(first);
    }
}

2.6 队列(Queue)的实现

队列(Queue)是一种先进先出的数据类型。

2.6.1 能动态调整数组大小的Queue
package ds.impl;
import ds.Queue;
import java.util.Iterator;

public class ArrayQueue<T> implements Iterable<T>,Queue<T> {
   
    private T[] array;
    private int size;
    private int first;
    private int last;
    public ArrayQueue() {
   
        array = (T[]) new Object[2];
        size = 0;
        first = 0;
        last = 0;
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public void enqueue(T data) {
   
        if (size == array.length) {
   
            resize(2 * array.length);
        }
        array[last++] = data;
        if (last == array.length) {
   
            last = 0;
        }
        size++;
    }
    @Override
    public T dequeue() {
   
        notEmptyCheck();
        T result = array[first];
        array[first] = null;
        size--;
        first++;
        if (first == array.length) {
   
            first = 0;
        }
        if (size > 0 && size == array.length / 4) {
   
            resize(array.length / 2);
        }
        return result;
    }
    
    @Override
    public T peek(){
   
        notEmptyCheck();
        return array[first];
    }
    private void resize(int capacity) {
   
        assert capacity >= size;
        T[] tmp = (T[]) new Object[capacity];
        for (int i = 0; i < size; i++) {
   
            tmp[i] = array[(first + i) % array.length];
        }
        array = tmp;
        first = 0;
        last = size;
    }
    @Override
    public Iterator<T> iterator() {
   
        return new ds.util.ArrayIterator(array,size);
    }
}
2.6.2 链式Queue的实现
package ds.impl;
import ds.util.Node;
import ds.Queue;
import java.util.Iterator;
import ds.util.ListIterator;

public class LinkedQueue<T> implements Iterable<T>, Queue<T> {
   
    private Node<T> first;
    private Node<T> last;
    private int size;
    public LinkedQueue() {
   
        first = null;
        last = null;
        size = 0;
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public T peek() {
   
        notEmptyCheck();
        return first.data;
    }
    @Override
    public void enqueue(T data) {
   
        Node<T> oldLast = last;
        last = new Node<>();
        last.data = data;
        last.next = null;
        if (isEmpty()) {
   
            first = last;
        } else {
   
            oldLast.next = last;
        }
        size++;
    }
    @Override
    public T dequeue() {
   
        notEmptyCheck();
        T result = first.data;
        first = first.next;
        size--;
        if (isEmpty()) {
   
            last = null;
        }
        return result;
    }
    @Override
    public String toString() {
   
        StringBuilder s = new StringBuilder();
        for (T data : this) {
   
            s.append(data).append(' ');
        }
        return s.toString();
    }
    @Override
    public Iterator<T> iterator() {
   
        return new ListIterator(first);
    }
}

2.7 Union-Find算法的实现

并查集（Union-Find）是解决动态连通性问题的一类非常高效的数据结构。

2.7.1 DefaultUF
package ds.impl;
import ds.UF;

public class DefaultUF implements UF {
   
    private int[] parent;
    private byte[] rank;
    private int size;
    public DefaultUF(int n) {
   
        if (n < 0) {
   
            throw new IllegalArgumentException();
        }
        size = n;
        parent = new int[n];
        rank = new byte[n];
        for (int i = 0; i < n; i++) {
   
            parent[i] = i;
            rank[i] = 0;
        }
    }
    @Override
    public int find(int p) {
   
        validate(p, parent.length);
        while (p != parent[p]) {
   
            parent[p] = parent[parent[p]];
            p = parent[p];
        }
        return p;
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public boolean connected(int p, int q) {
   
        return find(p) == find(q);
    }
    @Override
    public void union(int p, int q) {
   
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ) {
   
            return;
        }
        if (rank[rootP] < rank[rootQ]) {
   
            parent[rootP] = rootQ;
        } else if (rank[rootQ] > rank[rootP]) {
   
            parent[rootQ] = rootP;
        } else {
   
            parent[rootQ] = rootP;
            rank[rootP]++;
        }
        size--;
    }
}
2.7.2 QuickFindUF
package ds.impl;
import ds.UF;

public class QuickFindUF implements UF {
   
    private final int[] id;
    private int size;
    public QuickFindUF(int n) {
   
        size = n;
        id = new int[n];
        for (int i = 0; i < n; i++) {
   
            id[i] = i;
        }
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public int find(int p) {
   
        validate(p, id.length);
        return id[p];
    }
    @Override
    public boolean connected(int p, int q) {
   
        validate(p, id.length);
        validate(q, id.length);
        return id[p] == id[q];
    }
    @Override
    public void union(int p, int q) {
   
        validate(p, id.length);
        validate(q, id.length);
        int pID = id[p];
        int qID = id[q];
        if (pID == qID) {
   
            return;
        }
        for (int i = 0; i < id.length; i++) {
   
            if (id[i] == pID) {
   
                id[i] = qID;
            }
        }
        size--;
    }
}
2.7.3 QuickUnionUF
package ds.impl;
import ds.UF;
public class QuickUnionUF implements UF {
   
    private final int[] parent;
    private int size;
    public QuickUnionUF(int n) {
   
        parent = new int[n];
        size = n;
        for (int i = 0; i < n; i++) {
   
            parent[i] = i;
        }
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public int find(int p) {
   
        validate(p, parent.length);
        while (p != parent[p]) {
   
            p = parent[p];
        }
        return p;
    }
    @Override
    public boolean connected(int p, int q) {
   
        return find(p) == find(q);
    }
    @Override
    public void union(int p, int q) {
   
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ) {
   
            return;
        }
        parent[rootP] = rootQ;
        size--;
    }
}
2.7.4 WeightedQuickUnionUF

加权 quick-union算法，是目前所有实现中最优的算法

package ds.impl;
import ds.UF;

public class WeightedQuickUnionUF implements UF {
   
    private final int[] parent;
    private final int[] num;
    private int size;
    public WeightedQuickUnionUF(int n) {
   
        size = n;
        parent = new int[n];
        num = new int[n];
        for (int i = 0; i < n; i++) {
   
            parent[i] = i;
            num[i] = 1;
        }
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public int find(int p) {
   
        validate(p, parent.length);
        while (p != parent[p]) {
   
            p = parent[p];
        }
        return p;
    }
    @Override
    public boolean connected(int p, int q) {
   
        return find(p) == find(q);
    }
    @Override
    public void union(int p, int q) {
   
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ) {
   
            return;
        }
        // make smaller root point to larger one
        if (num[rootP] < num[rootQ]) {
   
            parent[rootP] = rootQ;
            num[rootQ] += num[rootP];
        } else {
   
            parent[rootQ] = rootP;
            num[rootP] += num[rootQ];
        }
        size--;
    }
}

2.8 测试

2.8.1 测试Stack

Dijkstra的双栈算数表达式求值算法

package test;
import java.util.Scanner;
import ds.impl.LinkedStack;

public class StackTest {
   
    public static void main(String[] args) {
   
        evaluate();
    }
    /**
     * Dijkstra的双栈算数表达式求值算法
     */
    public static void evaluate() {
   
        String str = "( 1 + ( ( 2.3 + 3 ) / ( sqrt ( 16 ) * ( 5 % 9 ) ) ) )";
        LinkedStack<String> opStack = new LinkedStack<>();
        LinkedStack<Double> valStack = new LinkedStack<>();
        Scanner scanner = new Scanner(str);
        while (scanner.hasNext()) {
   
            String s = scanner.next();
            System.out.print(s + ' ');
            switch (s) {
   
                case "+":
                case "-":
                case "*":
                case "/":
                case "%":
                case "sqrt":
                    opStack.push(s);
                    break;
                case "(":
                    break;
                case ")":
                    String op = opStack.pop();
                    double v = valStack.pop();
                    switch (op) {
   
                        case "+":
                            v = valStack.pop() + v;
                            break;
                        case "-":
                            v = valStack.pop() - v;
                            break;
                        case "*":
                            v = valStack.pop() * v;
                            break;
                        case "/":
                            v = valStack.pop() / v;
                            break;
                        case "%":
                            v = valStack.pop() % v;
                            break;
                        case "sqrt":
                            v = Math.sqrt(v);
                            break;
                        default:
                            break;
                    }
                    valStack.push(v);
                    break;
                default:
                    valStack.push(Double.parseDouble(s));
                    break;
            }
        }
        System.out.printf("= %f\n", valStack.pop());
    }
}
2.8.2 测试Union-Find
package test;
import ds.UF;
import ds.impl.DefaultUF;
import ds.impl.QuickFindUF;
import ds.impl.QuickUnionUF;

public class UFTest {
   
    public static void main(String[] args) {
   
        UF uf;
        int findResult;
        uf = new QuickFindUF(10);
        uf.union(4, 3);
        uf.union(3, 8);
        uf.union(6, 5);
        uf.union(9, 4);
        uf.union(2, 1);
        uf.union(5, 0);
        uf.union(7, 2);
        uf.union(6, 1);
        findResult = uf.find(3);
        System.out.println(findResult);
        System.out.println(uf.size());
        System.out.println(uf.connected(4, 3));
        System.out.println(uf.connected(9, 3));
        uf = new DefaultUF(10);
        uf.union(4, 3);
        uf.union(3, 8);
        uf.union(6, 5);
        uf.union(9, 4);
        uf.union(2, 1);
        uf.union(5, 0);
        uf.union(7, 2);
        uf.union(6, 1);
        findResult = uf.find(3);
        System.out.println(findResult);
        System.out.println(uf.size());
        System.out.println(uf.connected(4, 3));
        System.out.println(uf.connected(9, 3));
        uf = new QuickUnionUF(10);
        uf.union(4, 3);
        uf.union(3, 8);
        uf.union(6, 5);
        uf.union(9, 4);
        uf.union(2, 1);
        uf.union(5, 0);
        uf.union(7, 2);
        uf.union(6, 1);
        findResult = uf.find(3);
        System.out.println(findResult);
        System.out.println(uf.size());
        System.out.println(uf.connected(4, 3));
        System.out.println(uf.connected(9, 3));
    }
}

3 排序算法

3.1 定义排序工具的类结构

需要实现排序器，以及通过静态方法调用。

package util;
import java.util.Arrays
最低0.47元/天 解锁文章
z8g
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
普林斯顿大学算法Week1: Percolation 渗透(98分)--总结及代码
littlehaes的博客
01-25 3329
总结 视频讲述了并查集算法的细节,作业是该算法的实际应用 1. 下载algs4.jar,并添加到CLASSPATH中 2. 使用algs4.jar中的工具:求均值,求标准差,输入输出 3. 需要传入外部参数的方法都得进行参数检测,否则扣分 4. UnionFind算法的输入是一维的,Percolation系统是n*n的格子,每个site由坐标对(x,y)表示, 所以要想描述点与点之间的...
Percolation(渗透)问题
tengyuan93的博客
09-06 9994
Percolation(渗透)问题@(算法) Coursera作业链接直接将马克飞象导出的md文件发到博客，排版不是很清晰，抱歉，可查看GitHub详细代码和文档实际问题：将一个不透水的均质方块分割为N*N，最上方为水源，随机打开方块中任意格子，重复此项操作多次，产生一条路径使水能穿过这个方块到达最下方。the modelpercolation系统使用n-n格点，每个格点site有open/blo
Union-Find Algorithm Interpretation
guoliangstyle的博客
01-11 213
本文主要讲述对Union-Find算法的个人理解，以下Union-Find算法简称UF。 本文主要参考普林斯顿大学 Robert Sedgewick and Kevin Wayne教授的书籍算法四，他们的网站是https://algs4.cs.princeton.edu/15uf/ 让我们来看看UF算法在做些什么： 首先会初始化N个站点，用0~n-1个整数值代表（N的数据形式
算法--岛屿问题(DFS/BFS/UF)
大魔王
07-14 5176
与岛屿有关的问题 1.岛屿数量 https://leetcode-cn.com/problems/number-of-islands/ 2.岛屿的最大面积 https://leetcode-cn.com/problems/max-area-of-island/ 3.岛屿周长 https://leetcode-cn.com/problems/island-perimeter/ 4.不同岛屿的数量 https://leetcode-cn.com/problems/number-of-distin
并查集详解：UF——UF_Tree——UF_Tree_Weighted逐步优化
sc179的博客
11-15 654
并查集是一种树型的数据结构，它可以高效地进行如下操作： 查询元素p和元素q是否属于同一组； 合并元素p和元素q所在的组。
JAVA近百种算法大全
05-29
Java算法大全是一个包含约100种常见算法的资源库，专为Java程序员设计，用于深入理解和实践编程中的各种算法。这些算法涵盖了数据结构、排序、搜索、图论等多个领域，是提升编程技能和解决问题能力的重要工具。下面...
落实算法安全主体责任基本情况（模板）
最新发布
08-18
该部分内容应明确算法安全专职机构名称及其组织架构、算法安全专职机构负责人基本信息和主要工作职责、算法安全工作人员的任职要求、算法安全工作人员配备的规模、算法安全技术保障措施等。） 二、算法安全管理制度...
程序员算法大全
05-04
《程序员算法大全》是针对IT专业人士，特别是程序员和软件开发者设计的一份综合资源，它涵盖了数据结构和算法的广泛知识。这份资料集旨在提升程序员在解决复杂问题时的逻辑思维和编程能力，从而提高其在面试和实际...
JAVA经典算法90题【含源码】
10-10
在编程领域，特别是Java开发，熟练掌握算法是提升技术能力的关键。"JAVA经典算法90题【含源码】"的资源集合为Java初学者提供了一个绝佳的学习平台，旨在通过实际操作来理解和应用各种基础及进阶算法。下面将详细阐述...
算法竞赛入门到进阶 课件+源码
06-17
《算法竞赛入门到进阶 课件+源码》这套资源是为想要在算法竞赛中提升自己能力的初学者和进阶者准备的宝贵资料。它涵盖了从基础到高级的各种算法，通过课件和源码的结合，使学习者能够理论与实践相结合，更好地理解和...
DBSCAN聚类算法matlab代码
03-22
DBSCAN（Density-Based Spatial Clustering of Applications with Noise）是一种基于密度的空间聚类算法，它能够发现任意形状的聚类，并且对噪声具有很好的处理能力。在MATLAB中实现DBSCAN，可以帮助我们更方便地...
《落实算法安全主体责任基本情况》模版
07-26
根据《互联网信息服务算法推荐管理规定》第七条　算法推荐服务提供者应当落实算法安全主体责任，建立健全算法机制机理审核、科技伦理审查、用户注册、信息发布审核、数据安全和个人信息保护、反电信网络诈骗、安全...
模型算法大全（20+种常用算法模型+代码实现）
04-24
模型算法大全（20+种常用算法模型+代码实现）模型算法大全（20+种常用算法模型+代码实现）模型算法大全（20+种常用算法模型+代码实现）模型算法大全（20+种常用算法模型+代码实现）模型算法大全（20+种常用算法模型+...
union-find算法(路径压缩+加权quick-union算法 数组实现)
RGBMarco的博客
08-01 2592
算法第四版曾提过,通过路径压缩实现几乎（注意几乎)完全扁平化的树，为何我要说注意几乎,因为书作者数据给的好,我通过实现发现利用 书中数据 自己将结果画图发现和加权quick-union效果一样,然后我检查代码,又上网查找发现代码没错,原来是我理解有误,错误就在几乎这两个字上 注意这图和我上篇博文中的加权quick-union效果一样（上篇博文入口），按照我的错误理解效果应该是除了6–6其他都在
单目标&多目标优化算法的测试函数与解
xuxinrk的博客
10-11 2万+
原文 From Wikipedia, the free encyclopedia In applied mathematics, test functions, known as artificial landscapes, are useful to evaluate characteristics of optimization algorithms, such as: Velocity...
表达式的操作（UF函数）
qq_38344087的博客
03-13 2320
首先创建一个长方体，然后利用函数UF_MODL_ask_exps_of_feature访问长方体特征中的所有表达式的个数和标识，利用函数UF_MODL_ask_exp_tag_string获得表达式字符串，并用函数UF_MODL_dissect_exp_string分离表达式的名称和数值，最后利用函数UF_MODL_rename_exp对表达式重命名，并利用函数UF_MODL_eval_exp计算...
【数据结构与算法】模式匹配——从BF算法到KMP算法（附完整源码）
热门推荐
兰亭风雨的专栏
02-20 2万+
子串的定位操作通常称为串的模式匹配。模式匹配的应用很常见，比如在文字处理软件中经常用到的查找功能。我们用如下函数来表示对字串位置的定位： int index(const string &Tag,const string &Ptn,int pos) 其中，Tag为主串，Ptn为子串（模式串），如果在主串Tag的第pos个位置后存在与子串Ptn相同的子串，返回它在主串Tag中第pos个字符后第一次出现的位置，否则返回-1。 我们先来看BF算法(Brute-Force，最基本的字符串匹配算法)，B
labuladong算法秘籍
02-19
"labuladong算法秘籍" 这篇资源主要围绕labuladong的算法学习方法和刷题策略，涵盖了广泛的算法与数据结构知识。它分为几个篇章，旨在帮助读者系统性地掌握算法思维和实战技巧。 无剑篇——刷题心法与基础数据结构...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值