数据结构

最新推荐文章于 2023-11-08 11:06:42 发布
最新推荐文章于 2023-11-08 11:06:42 发布
阅读量244 收藏 1
点赞数 1
分类专栏： 算法和数据结构 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32843395/article/details/112323809
版权

数据结构

1. 数组模拟链表

在这里插入图片描述

// 用数组模拟单链表

import java.util.*;
public class Main {
    
    // head表示头节点下标
    // e[i]表示节点i的值
    // ne[i]表示节点i的next指针是多少
    // idx 存储当前已经用到了哪个点
    static final int N = 100010; 
    static int head, idx;           
    static int[] e = new int[N], ne = new int[N];
    
    // 初始化
    static void init() {
        head = -1;
        idx = 0;
    }
    
    // 将x插入头节点
    static void add_to_head(int x) {
        e[idx] = x;
        ne[idx] = head;
        head = idx;
        idx++;
        
    }
    
    // 将x插入到下标是k的点后面
    static void add(int k, int x) {
        e[idx] = x;
        ne[idx] = ne[k];
        ne[k] = idx;
        idx++;
    }
    
    // 将下标为k的点后面的点删掉
    static void remove(int k) {
        ne[k] = ne[ne[k]];
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int m = Integer.parseInt(in.nextLine());
        init();
        while (m -- > 0) {
            String[] s = in.nextLine().split(" ");
            if (s[0].equals("H")) {
                int x = Integer.parseInt(s[1]);
                add_to_head(x);
            } else if (s[0].equals("I")) {
                int k = Integer.parseInt(s[1]);
                int x = Integer.parseInt(s[2]);
                add(k - 1, x);
            } else {
                int k = Integer.parseInt(s[1]);
                if (k == 0) {
                    head = ne[head];
                }
                else remove(k - 1);
            }
        }
        for (int i = head; i!= -1; i = ne[i]) {
            System.out.print(e[i] + " ");
        }
    }
}

// 用数组模拟双链表
static final int N = 100010; 
static int idx;           
static int[] e = new int[N], l = new int[N], r = new int[N];

static void init() {
	// 0表示左端点, 1表示右端点
	r[0] = 1, l[0] = 0;
	idx = 2;
}

// 在下标是k的点的右边，插入x
static void add(int k, int x) {
	e[idx] = x;
	r[idx] = r[k];
	l[idx] = k;
	l[r[k]] = idx;
	r[k] = idx;
}

// 删除第k个点
void remove(int k) {
	r[l[k]] = r[k];
	l[r[k]] = l[k];
}

2. 数组模拟栈 队列

// 数组模拟栈
int[] stk = new int[N];
int tt = 0;
stk[tt++] = x; // 插入
tt--;		// 删除
if (tt > 0) not empty // 判断是否为空
stk[tt]	// 栈顶元素

// 用数组模拟队列
int[] q = new int[N];
int hh = 0, tt = -1;  // 队头， 队尾
q[++tt] = x; // 插入
hh++;       // 删除
if (hh <= tt) not empty
q[hh]      // 队头元素
q[tt]      // 队尾元素

3. 单调栈

一般问题：数组中每个数，找到其左边（右边）离它最近的小于（大于）它的数
在这里插入图片描述

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] stk = new int[100010]; // 单调增栈
        int tt = -1;
        while (n -- > 0) {
            int x = in.nextInt();
            while (tt >= 0 && stk[tt] >= x) tt--;
            if (tt >= 0) System.out.print(stk[tt] + " ");
            else System.out.print("-1 ");
            stk[++tt] = x;
        }
    }
}

4. 单调队列

在这里插入图片描述

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), k = in.nextInt();
        int[] q = new int[1000010];
        int[] a = new int[1000010];
        for (int i = 0; i < n; i++) a[i] = in.nextInt();
        
        // 单调递增队列
        int hh = 0, tt = -1;
        for (int i = 0; i < n; i++) {
            if (hh <= tt && i - k + 1 > q[hh]) hh++;
            while (hh <= tt && a[q[tt]] >= a[i]) tt--;
            q[++tt] = i;
            if(i >= k - 1) System.out.print(a[q[hh]] + " ");
        }
        
        System.out.println();
        
        // 单调递减队列
        hh = 0;
        tt = -1;
        for (int i = 0; i < n; i++) {
            if (hh <= tt && i - k + 1 > q[hh]) hh++;
            while (hh <= tt && a[q[tt]] <= a[i]) tt--;
            q[++tt] = i;
            if(i >= k - 1) System.out.print(a[q[hh]] + " ");
        }
    }
}

5. KMP算法

KMP算法及next数组

6. Trie树

高效地存储和查找字符串
在这里插入图片描述

import java.util.*;
public class Main {
    static int N = 100010, idx = 0;  // 字符串最大总长度100000， idx表示当前用到的节点
    // 下标是0的点，既是根节点，又是空节点
    static int[][] son = new int[N][26];  // 小写字母，每个节点最多26条边
    static int[] cnt = new int[N];       // cnt[i]以第i个节点结尾的字符串 的数目
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        while (n -- > 0) {
            String[] str = in.nextLine().split(" ");
            if (str[0].equals("I")) {
                insert(str[1].toCharArray());            
            } else {
                System.out.println(query(str[1].toCharArray()));
            }
        }
    }
    
    public static void insert(char[] str) {
        int p = 0;
        for (int i = 0; i < str.length; i++) {
            int u = str[i] - 'a';         // 'a' - 'z' 映射到 0 - 25
            if (son[p][u] == 0) son[p][u] = ++idx; // 不存在字符为u的节点，则创建（第idx个节点）
            p = son[p][u];
        }
        cnt[p] ++;
    }
    
    public static int query(char[] str) {
        int p = 0;
        for (int i = 0; i < str.length; i++) {
            int u = str[i] - 'a';
            if (son[p][u] == 0) return 0;
            p = son[p][u];
        }
        return cnt[p];
    }
}

7. 并查集

在这里插入图片描述
在这里插入图片描述

import java.util.*;
public class Main {
    static final int N = 100010; 
    static int[] p = new int[N];
	
	// 返回x的祖宗节点 + 路径压缩
    public static int find(int x) {
        if (p[x] != x) p[x] = find(p[x]); // 如果x不是祖宗节点，则令x的父节点为祖宗节点
        return p[x];
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] a = in.nextLine().split(" ");
        int n = Integer.parseInt(a[0]);
        int m = Integer.parseInt(a[1]);
        
        // 节点[1, n]
        for (int i = 1; i <= n; i++) p[i] = i;
        
        while (m -- > 0) {
            a = in.nextLine().split(" ");
            int x = Integer.parseInt(a[1]);
            int y = Integer.parseInt(a[2]);
            if (a[0].equals("M")) {
                p[find(x)] = find(y); // 将x所在集合 和 y所在集合 合并
            } else {
                if (find(x) == find(y)) System.out.println("Yes");
                else System.out.println("No");
            }
        }
    }
}

在这里插入图片描述

import java.util.*;
public class Main {
    static final int N = 100010; 
    static int[] p = new int[N];
	static int[] size = new int[N]; // 存储了集合大小，只有根节点有效，求节点所在集合大小需先求根节点，size[root]
	
	// 返回x的祖宗节点 + 路径压缩
    public static int find(int x) {
        if (p[x] != x) p[x] = find(p[x]); // 如果x不是祖宗节点，则令x的父节点为祖宗节点
        return p[x];
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] a = in.nextLine().split(" ");
        int n = Integer.parseInt(a[0]);
        int m = Integer.parseInt(a[1]);
        
        // 节点[1, n]
        for (int i = 1; i <= n; i++)  {
            p[i] = i;
            size[i] = 1;
        }
        
        while (m -- > 0) {
            a = in.nextLine().split(" ");
            if (a[0].equals("C")) {
                int x = Integer.parseInt(a[1]);
                int y = Integer.parseInt(a[2]);
                if (find(x) == find(y)) continue;  // x y已在一个集合
                size[find(y)] += size[find(x)]; // 合并后y的根节点 作为合并集合的根节点，其size存储了集合中所有节点的size
                p[find(x)] = find(y); // 将x所在集合 和 y所在集合 合并
            } else if (a[0].equals("Q1")){
                int x = Integer.parseInt(a[1]);
                int y = Integer.parseInt(a[2]);
                if (find(x) == find(y)) System.out.println("Yes");
                else System.out.println("No");
            } else {
                int x = Integer.parseInt(a[1]);
                System.out.println(size[find(x)]);
            }
        }
    }
}

8. 堆

在这里插入图片描述
删除或修改任意元素时，只会执行down(k) 或者 up(k) （当新数大于原数，执行down，否则执行up）
在这里插入图片描述

import java.util.*;
public class Main {
    static final int N = 100010;
    static int[] h = new int[N]; // 堆 [1, size]
    static int size;			 // 堆大小
    
    public static void down(int u) {
        int t = u;		// 求解三个节点中最小下标
        if (u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
        if (u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
        if (u != t) {	// 如果u不是最小节点，则交换值 并继续down
            int tmp = h[u];
            h[u] = h[t];
            h[t] = tmp;
            down(t);
        }
    }
    
    public static void up (int u) {
    	// 如果当前节点大于父节点，则循环交换两值
        while (u / 2 >= 1 && h[u / 2] > h[u]) {
            int tmp = h[u];
            h[u] = h[u / 2];
            h[u / 2] = tmp;
            u /= 2;
        }
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), m = in.nextInt();
        size = n;

        for (int i = 1; i <= n; i++) h[i] = in.nextInt();
        for (int i = n / 2; i >= 1; i--) down(i); // 从最后第二层开始，将每层元素down，复杂度O(n)  即从下层往上，慢慢变成堆
        //如果用插入元素建堆，则复杂度O(nlogn)
        
        while (m -- > 0) {
            System.out.print(h[1] + " ");	// 输出堆最小值
            // 删除h[1], 即把最后一个元素赋值给h[1]，并执行down操作
            h[1] = h[size];		
            size -- ;			
            down(1);			
        }
    }
}

在这里插入图片描述

import java.util.*;
public class Main {
    static final int N = 100010;
    static int[] h = new int[N]; // 堆 [1, size]
    static int size = 0;			 // 堆大小
    
    static int[] ph = new int[N]; // ph[k] = i 第k个插入的数 对应的 堆中坐标i
    static int[] hp = new int[N]; // hp[i] = i 堆中坐标i 对应的 k
    
    // 模拟c++中swap函数
    public static void swap(int [] nums, int a, int b) {
        int tmp = nums[a];
        nums[a] = nums[b];
        nums[b] = tmp;
    }
    
    // 堆中元素交换时，维护映射关系hp和ph
    public static void heap_swap(int a, int b) {
        swap(ph, hp[a], hp[b]);
        swap(hp, a, b);
        swap(h, a, b);
    }
    
    public static void down(int u) {
        int t = u;		// 求解三个节点中最小下标
        if (u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
        if (u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
        if (u != t) {	// 如果u不是最小节点，则交换值 并继续down
            heap_swap(u, t);
            down(t);
        }
    }
    
    public static void up (int u) {
    	// 如果当前节点大于父节点，则循环交换两值
        while (u / 2 >= 1 && h[u / 2] > h[u]) {
            heap_swap(u, u / 2);
            u /= 2;
        }
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        int m = 0; // 当前 第m个插入的数
        while (n -- > 0) {
            String[] str = in.nextLine().split(" ");
            if (str[0].equals("I")) { // 插入第m个数
                size ++ ;
                m ++;		
                
				// 第m个数 先放到 最后的位置size
                ph[m] = size;	
                hp[size] = m;	
                h[size] = Integer.parseInt(str[1]);
                
                up(size); 
            } else if (str[0].equals("PM")) { // 输出最小值
                System.out.println(h[1]);
            } else if (str[0].equals("DM")) {	// 删除最小值
                heap_swap(1, size);
                size --;
                down(1);
            } else if (str[0].equals("D")) { // 删除第k个插入的数
                int k = Integer.parseInt(str[1]);
                k = ph[k];	// 第k个数 对应的 堆中的坐标
                heap_swap(k, size);
                size --;
                up(k);
                down(k);
            } else if (str[0].equals("C")) { // 修改第k个数
                int k = Integer.parseInt(str[1]);
                int x = Integer.parseInt(str[2]);
                k = ph[k];	// 第k个数 对应的 堆中的坐标
                h[k] = x;
                up(k);
                down(k);
            }
        }
    }
}

9. Hash表

在这里插入图片描述

// 拉链法
import java.util.*;
public class Main {
    
    static final int N = 100003;	// N一般取质数比较好（可取大于数据范围的第一个质数）
    static int[] h = new int[N];	// 存储头节点位置， -1为空节点 （每个哈希值对应一个链表）
    static int[] e = new int[N];	// 链表值
    static int[] ne = new int[N];	// 链表指针
    static int idx = 0;				// 当前可用链表节点
    
    public static void insert(int x) {
        int k = (x % N + N) % N;	// x % n可能为负数，+ N保证为正，最后再取模
        // 将新节点插入头部
        e[idx] = x;
        ne[idx] = h[k];
        h[k] = idx ++;
    }
    
    // 查找x是否在哈希表中
    public static boolean query (int x) {
        int k = (x % N + N) % N;
        for (int i = h[k]; i != -1; i = ne[i]) {
            if (e[i] == x) return true;
        }
        return false;
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        for (int i = 0; i < h.length; i++) h[i] = -1; // 初始化哈希表中所有指针为空
        while (n -- > 0) {
            String[] str = in.nextLine().split(" ");
            int x = Integer.parseInt(str[1]);;
            if (str[0].equals("I")) {
                insert(x);
            } else if (str[0].equals("Q")) {
                if (query(x)) {
                    System.out.println("Yes");
                } else System.out.println("No");
            }
        }
    }
}

// 开放寻址法
import java.util.*;
public class Main {
    
    // 一般取 2-3倍 的数据范围
    static final int N = 200003;	// N一般取质数比较好（可取大于数据范围的第一个质数）
    static final int Null = 0x3f3f3f3f;  // 0x3f3f3f3f > 10^9
    static int[] h = new int[N];		
    
    // 寻找x所在下标，若不存在，则返回应该存放的位置
    public static int find (int x) {
        int k = (x % N + N) % N;
        // 若h[k]已有数，则顺序向后寻找
        while (h[k] != Null && h[k] != x) {
            k++;
            if (k == N) k = 0;
        }
        return k;
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        for (int i = 0; i < h.length; i++) h[i] = Null; // 初始化哈希表中所有指针为空
        while (n -- > 0) {
            String[] str = in.nextLine().split(" ");
            int x = Integer.parseInt(str[1]);
            int k = find(x);
            if (str[0].equals("I")) {
                h[k] = x;
            } else if (str[0].equals("Q")) {
                if (h[k] != Null) {
                    System.out.println("Yes");
                } else System.out.println("No");
            }
        }
    }
}

在这里插入图片描述

在这里插入图片描述

// 字符串哈希
import java.util.*;
public class Main {
    
    static final long MOD = Long.MAX_VALUE;  // c++中用unsigned long long，可不用取模，溢出即自动取模
    static final int N = 100010, P = 131;	// 经验值P: 131 1331
    static long[] h = new long[N];			// hash值
    static long[] p = new long[N];			// p[i] = P ^ i
    
    // 字符串[l, r]的哈希值
    public static long get(int l, int r) {
        return h[r] - h[l - 1] * p[r - l + 1];
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] arr = in.nextLine().split(" ");
        int n = Integer.parseInt(arr[0]);
        int m = Integer.parseInt(arr[1]);
        char[] str = in.nextLine().toCharArray();
        
        p[0] = 1;
        for (int i = 1; i <= n; i++) {
            h[i] = (h[i - 1] * P + str[i - 1]) % MOD;	// h[i]为字符串前缀[1, i]的哈希值
            p[i] = p[i - 1] * P;
        }
        while (m -- > 0) {
            arr = in.nextLine().split(" ");
            int l1 = Integer.parseInt(arr[0]);
            int r1 = Integer.parseInt(arr[1]);
            int l2 = Integer.parseInt(arr[2]);
            int r2 = Integer.parseInt(arr[3]);
            if (get(l1, r1) == get(l2, r2)) {	// 若两个子串的hash值相同，则为相同子串
                System.out.println("Yes");
            } else System.out.println("No");
        }
    }
}
TheJayChou
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【算法】常见数据结构基本算法整理
I am what i am
03-17 7816
去年11月份听了牛客网的课，当时做了纸质的笔记整理。 现在为了以后方便查找，将问题目录整理如下。 每道题只提供解题思路，不贴源代码。 可能会稍微手写一下代码（没有在IDE上测，为了试下以后面试时手写代码），或者伪代码。 by 03/17/2018 其实本科学过数据结构、算法设计，而且后来也看过不止一次，但这次又听左神讲，真的是“每次都有新发现”，觉得很有趣，必须要记录一下。 该篇博...
数据结构：八种数据结构大全
緑水長流*z
07-29 20万+
数据结构 1.1 数据结构概述 数据结构是计算机存储、组织数据的方式；通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构的优良将直接影响着我们程序的性能；常用的数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等； 1.2 数据结构的分类 1.2.1 排列方式 1）集合 集合：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系； 2）线性结构 线性
数据结构：八大数据结构分类
热门推荐
09-05 69万+
数据结构分类 数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成 。 常用的数据结构有：数组，栈，链表，队列，树，图，堆，散列表等，如图所示： 每一种数据结构都有着独特的数据存储方式，下面为大家介绍它们的结构和优缺点。 1、数组 数组是可以再内存中连续存储多个元素的结构，在内存中的分配也是连续的，数组中的元素通过数组下标进行访问，数组下标从0开始...
数据结构与算法学习笔记
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构——学习笔记——入门必看【建议收藏】
刘鑫磊
02-09 41万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
【数据结构】八种常见数据结构介绍
非晚非晚的博客
02-05 5万+
数据结构是计算机存储、组织数据的方式。一种好的数据结构可以带来更高的运行或者存储效率。数据在内存中是呈线性排列的，但是我们可以使用指针等道具，构造出类似“树形”的复杂结构。下面介绍八个常见的数据结构。
数据结构——栈的详解
晴空๓
04-20 7万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
数据结构（严蔚敏版）与算法的实现（含全部代码）
关注网络安全、云原生安全
09-13 14万+
目录 基础 c/c++ 代码优化及常见错误 c语言位运算的妙用-程序优化 c/c++进制转换方法汇总（含全部代码） 二进制数-北邮2012研究生复试 质因子分解 除树和图外的数据结构可以使用STL: C++ STL的使用 数据结构 线性表 顺序表 循环左移（2010联考真题） 单链表 单链表相邻结点逆置(2019北邮考研真...
数据结构题库
刘鑫磊
03-05 2万+
目录： 一：文档 【文档】清华数据结构习题集答案(C语言版严蔚敏).【113页】 【文档】自考数据结构02331历年试题及答案(2009--2015个人整理版【98页】 【文档】数据结构各章题库及答案【56页】 【文档】数据结构考试题库含答案整理版【55页】 【文档】十套数据结构试题及答案1【41页】 【文档】数据结构试题及答案【35页】 【文档】十套数据结构试题及答案(1)【24...
数据结构和算法是人工智能的基石
最新发布
herosunly的博客
11-08 4万+
▊《算法秘籍》王一博 著算法是编程的基石，开发的核心。本书包含55个二维码，300多分钟视频，100多个知识点，50多个示例，适合程序员、计算机专业相关师生，以及对算法感兴趣的读者。这是一本关于数据结构和算法的书，以Java为描述语言，介绍了计算机编程中常用的数据结构和算法。全书共13章，讲述了常见的数据结构、排序算法、位运算、树、递归、回溯算法、贪心算法、双指针和滑动窗口、BFS和DFS、前缀和、动态规划、并查集、其他经典算法等知识。
数据结构教案
12-13
数据结构教案 数据结构是计算机科学中的一门重要课程，它研究的是计算机中数据的存储、组织和管理方式。数据结构的基本概念包括数据元素、数据结构、数据类型、抽象数据类型等。 数据元素是数据结构中讨论的基本...
数据结构视频
03-18
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术...
王道考研——数据结构PPT.zip
08-21
数据结构是计算机科学中的核心课程之一，主要研究如何在计算机中组织、存储和管理数据，以便高效地进行各种操作。王道考研的数据结构PPT涵盖了这门学科的关键概念和技术，对于准备考研的学生来说，是一份非常有价值...
数据结构真题
10-19
数据结构考试题啊
数据结构Python
04-04
《数据结构Python》是一本专为那些对数据结构有浓厚兴趣但不倾向于使用C或C++语言学习的读者量身定制的书籍。本书通过Python语言深入浅出地讲解了数据结构的基本概念、原理和实现方法，旨在帮助读者理解并掌握数据...
eclipse导入Maven项目，项目包显示为文件夹结构
buglesxu的博客
09-16 3676
eclipse导入Maven项目后，项目包显示为文件夹结构： 网上解决办法: 项目右键，然后点击Properties，在弹出的窗口中选择Java Build Path，然后选择Source tab， 展开找到Excluded。正常情况下应该是None，现在发现是 **，所以需要remove它即可。 （尝试后不可行，build path 灰色不可编辑（no actions available）或 找不到build path 选项 ：） 网上方法: 项目右键—>Properties—>Proje
Java 学习笔记 持续更新
buglesxu的博客
09-17 674
局部变量没有默认值，需要初始化
动态规划
buglesxu的博客
01-12 356
动态规划背包问题01背包 背包问题 01背包
基础算法
buglesxu的博客
01-02 263
基础算法 快速排序 import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scan = new Scanner(System.in); int n = scan.nextInt(); int[] q = new int[n]; for (int i = 0; i < n; i++) {
C++语言版数据结构教程
数据结构的基本概念包括数据、数据元素、数据结构、算法等，数组、链表、栈、队列、树、图等是常用的数据结构，查找和排序是数据结构中两个重要的操作，算法分析是指对算法的时间和空间复杂度的分析，C++语言提供了...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值