18814108286
18814108286

模版:数据结构

1、单链表

(1) “H x”，表示向链表头插入一个数x。

(2) “D k”，表示删除第k个输入的数后面的数（当k为0时，表示删除头结点）。

(3) “I k x”，表示在第k个输入的数后面插入一个数x（此操作中k均大于0）。

import java.util.*;
public class Main{
    // head 表示头结点的下标
    // e[i] 表示节点i的值
    // ne[i] 表示节点i的next指针是多少
    // idx 存储当前已经用到了哪个点
    static int N = 100010;
    static int head = - 1;
    static int[] e = new int[N];
    static int[] ne = new int[N];
    static int idx = 0;
    // 将x插到头结点
    public static void add_to_head(int x)
    {
        e[idx] = x;
        ne[idx] = head;
        head = idx ++;
    }
    // 将下标是k的点后面的点删掉
    public static void remove(int k)
    {
        ne[k] = ne[ne[k]]; 
    }
    // 将x插到下标是k的点后面
    public static void add(int k,int x)
    {
         e[idx] = x; 
         ne[idx] = ne[k];
         ne[k] = idx ++ ;
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int m = scan.nextInt();

        while(m -- > 0)
        {
            String op = scan.next();
            if(op.equals("H"))
            {
                int x = scan.nextInt();
                add_to_head(x);
            }
            else if(op.equals("D"))
            {
                int k = scan.nextInt();
                if(k == 0) head = ne[head];
                else remove(k - 1);
            }
            else 
            {
                int k = scan.nextInt();
                int x = scan.nextInt();
                add(k - 1, x);
            }
        }
        for(int i = head; i != -1; i = ne[i])
            System.out.print(e[i]+ " ");
    }

}

2、双链表

实现一个双链表，双链表初始为空，支持5种操作：

(1) 在最左侧插入一个数；

(2) 在最右侧插入一个数；

(3) 将第k个插入的数删除；

(4) 在第k个插入的数左侧插入一个数；

(5) 在第k个插入的数右侧插入一个数

现在要对该链表进行M次操作，进行完所有操作后，从左到右输出整个链表。
注意：由于是从第2的位置开始存结点，所以里面中第k个插入的数，意思是指第(k + 1)的位置的数

模版:数据结构_第1张图片
image.png 

import java.util.*;


public class Main{
    static int N = 100010;
    static int[] e = new int[N];
    static int[] l = new int[N];
    static int[] r = new int[N];
    static int idx;
    //在节点a的右边插入一个x
    public static void insert(int a,int x)
    {
        e[idx] = x;
        l[idx] = a;
        r[idx] = r[a];
        l[r[a]] = idx;
        r[a] = idx;
        idx ++;
        
    }
    //删除结点a
    public static void remove(int a)
    {
        r[l[a]] = r[a];
        l[r[a]] = l[a];
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int m = scan.nextInt();
        //0是左端点，1是右端点
        r[0] = 1;
        l[1] = 0;
        idx = 2;
        while(m -- > 0)
        {
            String op = scan.next();
            //“L x”，表示在链表的最左端插入数x。
            if(op.equals("L"))
            {
                int x = scan.nextInt();
                insert(0,x);
            }
            //“R x”，表示在链表的最右端插入数x。
            else if(op.equals("R"))
            {
                int x = scan.nextInt();
                insert(l[1],x);
            }
            // “D k”，表示将第k个插入的数删除,由于是从2开始存结点，所以意思是删除第(k + 1)位置的结点
            else if(op.equals("D"))
            {
                int k = scan.nextInt();
                remove(k + 1);
            }
            //“IL k x”，表示在第k个插入的数左侧插入一个数。
            else if(op.equals("IL"))
            {
                int k = scan.nextInt();
                int x = scan.nextInt();
                insert(l[k + 1],x);
            }
            else 
            {
                int k = scan.nextInt();
                int x = scan.nextInt();
                insert(k + 1,x);
            }
            
        }
        for(int i = r[0];i != -1;i = r[i])
            System.out.println(e[i]);
    }

}

优化输入


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main{
    static int N = 100010;
    static int[] e = new int[N];
    static int[] l = new int[N];
    static int[] r = new int[N];
    static int idx;
    //在节点a的右边插入一个x
    public static void insert(int a,int x)
    {
        e[idx] = x;
        l[idx] = a;
        r[idx] = r[a];
        l[r[a]] = idx;
        r[a] = idx;
        idx ++;
        
    }
    //删除结点a
    public static void remove(int a)
    {
        r[l[a]] = r[a];
        l[r[a]] = l[a];
    }
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int m = Integer.parseInt(reader.readLine());
        //0是左端点，1是右端点
        r[0] = 1;
        l[1] = 0;
        idx = 2;
        while(m -- > 0)
        {
            String[] str = reader.readLine().split(" ");
            //“L x”，表示在链表的最左端插入数x。
            if(str[0].equals("L"))
            {
                int x = Integer.parseInt(str[1]);
                insert(0,x);
            }
            //“R x”，表示在链表的最右端插入数x。
            else if(str[0].equals("R"))
            {
                int x = Integer.parseInt(str[1]);
                insert(l[1],x);
            }
            // “D k”，表示将第k个插入的数删除,由于是从2开始存结点，所以意思是删除第(k + 1)位置的结点
            else if(str[0].equals("D"))
            {
                int k = Integer.parseInt(str[1]);
                remove(k + 1);
            }
            //“IL k x”，表示在第k个插入的数左侧插入一个数。
            else if(str[0].equals("IL"))
            {
                int k = Integer.parseInt(str[1]);
                int x = Integer.parseInt(str[2]);
                insert(l[k + 1],x);
            }
            else 
            {
                int k = Integer.parseInt(str[1]);
                int x = Integer.parseInt(str[2]);
                insert(k + 1,x);
            }
            
        }
        for(int i = r[0];i != 1;i = r[i])
            System.out.print(e[i]+" ");
    }

}

3、栈

实现一个栈，栈初始为空，支持四种操作：

(1) “push x” – 向栈顶插入一个数x；

(2) “pop” – 从栈顶弹出一个数；

(3) “empty” – 判断栈是否为空；

(4) “query” – 查询栈顶元素。

现在要对栈进行M个操作，其中的每个操作3和操作4都要输出相应的结果。
注意：tt = 0，从第1个位置开始存

import java.util.*;


public class Main{
    static int N = 100010;
    //从1开始存放数值
    static int[] stk = new int[N];
    static int tt = 0;
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int m = scan.nextInt();
        while(m -- > 0)
        {
            String op = scan.next();
            if(op.equals("push"))
            {
                int x = scan.nextInt();
                stk[++ tt] = x;
            }
            else if(op.equals("pop")) tt--;
            else if(op.equals("empty")) 
            {
                if(tt == 0) System.out.println("Yes");
                else System.out.println("NO");
            }
            else System.out.println(stk[tt]);
        }
    }

}

4、队列

实现一个队列，队列初始为空，支持四种操作：

(1) “push x” – 向队尾插入一个数x；

(2) “pop” – 从队头弹出一个数；

(3) “empty” – 判断队列是否为空；

(4) “query” – 查询队头元素。

现在要对队列进行M个操作，其中的每个操作3和操作4都要输出相应的结果。
注意：tt = -1，从第0个位置开始存,hh 表示队头，tt表示队尾


import java.util.Scanner;

public class Main{
    static int N = 100010;
    static int[] q = new int[N];
    //hh 表示队头，tt表示队尾
    static int hh = 0;
    static int tt = -1;
    
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int m = scan.nextInt();
        while(m-- > 0)
        {
            String op = scan.next();
            if(op.equals("push"))
            {
                int x = scan.nextInt();
                q[++ tt] = x;
            }
            else if(op.equals("pop")) hh ++;
            else if(op.equals("empty"))
            {
                if(hh <= tt) System.out.println("NO");
                else System.out.println("YES");
            }
            else
            {
                System.out.println(q[hh]);
            }
        }
    }

}

5、单调栈

常见模型：找出每个数左边离它最近的比它大/小的数

暴力情况：


模版:数据结构_第2张图片
image.png

单调栈模拟：


模版:数据结构_第3张图片
image.png

模版:数据结构_第4张图片
image.png

模版

常见模型：找出每个数左边离它最近的比它大/小的数
int tt = 0;
for (int i = 1; i <= n; i ++ )
{
    while (tt && check(stk[tt], i)) tt -- ;
    stk[ ++ tt] = a[i];
}

题目

例如：给定一个长度为N的整数数列，输出每个数左边第一个比它小的数，如果不存在则输出-1。

实现代码

import java.util.*;


public class Main{
    static int N = 100010;
    //从1开始存放数值
    static int[] stk = new int[N];
    static int tt = 0;
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int[] a = new int[n];
        for(int i = 0;i < n;i++)
            a[i] = scan.nextInt();
        for(int i = 0;i < n;i++)
        {
            int x = a[i];
            while(stk[tt] >= x) tt --;
            if(tt == 0) System.out.print(-1 + " ");
            else System.out.print(stk[tt] + " ");
            stk[++ tt] = x;
        }
    }

}

6、单调队列

常见模型：找出滑动窗口中的最大值/最小值

给定一个大小为n≤10^6的数组。

有一个大小为k的滑动窗口，它从数组的最左边移动到最右边。

您只能在窗口中看到k个数字。

每次滑动窗口向右移动一个位置。

以下是一个例子：

该数组为[1 3 -1 -3 5 3 6 7]，k为3。

模版:数据结构_第5张图片
image.png

您的任务是确定滑动窗口位于每个位置时，窗口中的最大值和最小值。

以求最小值为例，求最大值完全与最小值对称

模版:数据结构_第6张图片
image.png

模版 

常见模型：找出滑动窗口中的最大值/最小值
int hh = 0, tt = -1;
for (int i = 0; i < n; i ++ )
{
    while (hh <= tt && check_out(q[hh])) hh ++ ;  // 判断队头是否滑出窗口
    while (hh <= tt && check(q[tt], i)) tt -- ;
    q[ ++ tt] = i;
}

求窗口最小值模版：

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) log.write(a[q[hh]] + " ");
        }

求窗口最大值模版：

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) log.write(a[q[hh]] + " ");
        }

总代码：

import java.io.*;
public class Main{
    static int N = 1000010;
    static int[] q = new int[N];
    static int[] a = new int[N];
    //hh记录出队列处
    static int hh = 0;
    //tt记录进队列处
    static int tt = -1;
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
        String[] s = reader.readLine().split(" ");
        int n = Integer.parseInt(s[0]);
        int k = Integer.parseInt(s[1]);
        String[] str = reader.readLine().split(" ");
        
        for(int i = 0;i < n;i++)
        {
           
            a[i] = Integer.parseInt(str[i]);
            
        }
        
        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) log.write(a[q[hh]] + " ");
        }
        log.write("\n");
        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) log.write(a[q[hh]] + " ");
        }
        // 关闭输入输出流
        log.flush();
        reader.close();
        log.close();
    }

}

7、KMP

两个字符窜的匹配问题

KMP是什么，做什么用的

KMP全称为Knuth Morris Pratt算法，三个单词分别是三个作者的名字。KMP是一种高效的字符串匹配算法，用来在主字符串中查找模式字符串的位置(比如在“hello,world”主串中查找“world”模式串的位置)。
题目：
给定一个模式串S，以及一个模板串P，所有字符串中只包含大小写英文字母以及阿拉伯数字。

模板串P在模式串S中多次作为子串出现。

求出模板串P在模式串S中所有出现的位置的起始下标。

暴力枚举

s[]是模式串，p[]是模板串, n是s的长度，m是p的长度
for (int i = 1; i <= n; i ++ )
{
    bool flag = true;
    for (int j = 1; j <= m; j ++ )
    {
        if (s[i + j - 1] != p[j])
        {
            flag=false;
            break;
        }
    }
}

next[i]记录的是p数组的最大后缀等于最大前缀时的最大前缀末尾的位置，即必须要小于i，所以next[1]必须等于0，i就只能从2开始循环了。
如图所示：

模版:数据结构_第7张图片
image.png

分析：比较的位置是s[]数组的第i个位置和p[]数组的第j+1个位置的元素
KMP的时间复杂度是O(n)
模版:数据结构_第8张图片
image.png

模版:数据结构_第9张图片
image.png

模版：

KMP —— 模板题 AcWing 831. KMP字符串
求Next数组：
// s[]是模式串，p[]是模板串, n是s的长度，m是p的长度
for (int i = 2, j = 0; i <= m; i ++ )
{
    while (j && p[i] != p[j + 1]) j = ne[j];
    if (p[i] == p[j + 1]) j ++ ;
    ne[i] = j;
}

// 匹配
for (int i = 1, j = 0; i <= n; i ++ )
{
    while (j && s[i] != p[j + 1]) j = ne[j];
    if (s[i] == p[j + 1]) j ++ ;
    if (j == m)
    {
        j = ne[j];
        // 匹配成功后的逻辑
    }
}


// 此处s[]是模式串，p[]是模板串, m是s的长度，n是p的长度
import java.util.Scanner;

public class Main{
    static int N = 10010, M = 100010;
    static int[] ne = new int[N];
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        String p = " " + scan.next();
        int m = scan.nextInt();
        String s = " " + scan.next();
        //求p模版的next数组
        for(int i = 2,j = 0;i <= n;i++)
        {
            while(j != 0 && p.charAt(j + 1) != p.charAt(i))
                j = ne[j];
            if(p.charAt(j + 1) == p.charAt(i)) j ++;
                ne[i] = j;
        }
        
        for(int i = 1,j = 0;i <= m;i++)
        {
            while(j != 0 && p.charAt(j + 1) != s.charAt(i))
                j = ne[j];
            if(p.charAt(j + 1) == s.charAt(i)) j ++;
            if(j == n)
            {
                System.out.print(i - n + " ");
                j = ne[j];
            }
        }
    }

}

8、Trie字典树

维护一个字符串集合，支持两种操作：

“I x”向集合中插入一个字符串x；
“Q x”询问一个字符串在集合中出现了多少次。
共有N个操作，输入的字符串总长度不超过 105，字符串仅包含小写英文字母。

输入格式
第一行包含整数N，表示操作数。

接下来N行，每行包含一个操作指令，指令为”I x”或”Q x”中的一种。

输出格式
对于每个询问指令”Q x”，都要输出一个整数作为结果，表示x在集合中出现的次数。

每个结果占一行。

分析：

son[N] 对应的是所有节点
son[N][26] 表示每个节点的所有儿子
cnt[N] 表示以当前这个点结尾的结点有多少个
idx 表示当前用到哪个下标（类似单链表的idx），下标是0的点，既是根节点，又是空节点

模版:数据结构_第10张图片
image.png 

import java.util.Scanner;

public class Main{
    static int N = 100010;
    //存每个点的所有儿子
    static int[][] son = new int[N][26];
    //以当前这个点结尾的结点有多少个
    static int[] cnt = new int[N];
    //当前用到哪个下标，下标是0的点，既是根节点，又是空节点
    static int idx = 0;
    // 插入一个字符串
    public static void insert(String x)
    {
        int p = 0;//从根结点开始
        for(int i = 0;i < x.length();i++)
        {
            int u = x.charAt(i) - 'a';//当前子节点的编号
            //如果p这个节点不存在这个儿子，则把它创建出来(有路就直接走，没有路搭个桥都要走过去)
            if(son[p][u] == 0) son[p][u] = ++ idx;
            p = son[p][u];
        }
        cnt[p] ++;
    }
    // 查询字符串出现的次数
    public static int query(String x)
    {
        int p = 0;
        for(int i = 0;i < x.length();i++)
        {
            int u = x.charAt(i) - 'a';
            if(son[p][u] == 0) return 0;
            p = son[p][u];
        }
        return cnt[p];
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        while(n -- > 0)
        {
            String op = scan.next();
            if(op.equals("I"))
            {
                String x = scan.next();
                insert(x);
            }
            else
            {
                String x = scan.next();
                System.out.println(query(x));
            }
        }
        
    }

}

9、并查集

1、将两个集合合并
2、询问两个元素是否在一个集合当中

时间复杂度近乎

基本原理：每个集合用一棵树来表示，树根的编号就是整个集合的编号，每个节点存储它的父节点，表示的父节点
问题1：如何判断树根 if(p[x] == x)
问题2：如何求x的集合编号 while(p[x] != x) x = p[x]
问题3：如何合并两个集合 px是x的集合编号，py是y的集合编号，p[px ] = py

模版:数据结构_第11张图片
image.png

模版

(1)朴素并查集：

    int p[N]; //存储每个点的祖宗节点

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ ) p[i] = i;

    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);


(2)维护size的并查集：

    int p[N], size[N];
    //p[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        size[i] = 1;
    }

    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);
    size[b] += size[a];


(3)维护到祖宗节点距离的并查集：

    int p[N], d[N];
    //p[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x)
        {
            int u = find(p[x]);
            d[x] += d[p[x]];
            p[x] = u;
        }
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        d[I] = 0;
    }

    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);
    d[find(a)] = distance; // 根据具体问题，初始化find(a)的偏移量

（1）朴素并查集
一共有n个数，编号是1~n，最开始每个数各自在一个集合中。

现在要进行m个操作，操作共有两种：

1、“M a b”，将编号为a和b的两个数所在的集合合并，如果两个数已经在同一个集合中，则忽略这个操作；
2、“Q a b”，询问编号为a和b的两个数是否在同一个集合中；
输入格式
第一行输入整数n和m。

接下来m行，每行包含一个操作指令，指令为“M a b”或“Q a b”中的一种。

输出格式
对于每个询问指令”Q a b”，都要输出一个结果，如果a和b在同一集合内，则输出“Yes”，否则输出“No”。

每个结果占一行。

import java.util.Scanner;


public class Main{
    static int N = 100010;
    static int[] p = new int[N];
    public static int find(int x)//返回x的祖宗节点 + 路径压缩
    {
        if(p[x] != x) p[x] = find(p[x]);
        return p[x];
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();
        for(int i = 0;i < n;i++) p[i] = i;
        while(m -- > 0)
        {
            String op = scan.next();
            if(op.equals("M"))
            {
                int a = scan.nextInt();
                int b = scan.nextInt();
                p[find(a)] = find(b);
                
            }
            else
            {
    
                int a = scan.nextInt();
                int b = scan.nextInt();
                if(find(a) == find(b)) System.out.println("Yes");
                else System.out.println("No");
            }
        }
        
    }

}

（2）维护size的并查集
给定一个包含n个点（编号为1~n）的无向图，初始时图中没有边。

现在要进行m个操作，操作共有三种：

1、“C a b”，在点a和点b之间连一条边，a和b可能相等；
2、“Q1 a b”，询问点a和点b是否在同一个连通块中，a和b可能相等；
3、“Q2 a”，询问点a所在连通块中点的数量；
输入格式
第一行输入整数n和m。

接下来m行，每行包含一个操作指令，指令为“C a b”，“Q1 a b”或“Q2 a”中的一种。

输出格式
对于每个询问指令”Q1 a b”，如果a和b在同一个连通块中，则输出“Yes”，否则输出“No”。

对于每个询问指令“Q2 a”，输出一个整数表示点a所在连通块中点的数量

每个结果占一行。


import java.io.*;
import java.util.Scanner;

public class Main{
    static int N = 100010;
    static int[] p = new int[N];
    static int[] size = new int[N];

    
    public static int find(int x)
    {
        if(p[x] != x) p[x] = find(p[x]);
        return p[x];
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
       
        int n = scan.nextInt();
        int m = scan.nextInt();
        //初始化
        for(int i = 1;i <= n;i++)
        {
            p[i] = i;
            size[i] = 1;
        }
        while(m -- > 0)
        {
            
            String op = scan.next();
            if(op.equals("C"))
            {
                int a = scan.nextInt();
                int b = scan.nextInt();
                a = find(a);
                b = find(b);
                //若在相同的集合则不需要合并，否则合并
                if(a != b)
                {
                    p[a] = b;
                    size[b] += size[a];
                }
                
            }
            else if(op.equals("Q1"))
            {
                int a = scan.nextInt();
                int b = scan.nextInt();
                if(find(a) == find(b)) 
                {
                    System.out.println("Yes");
                }
                else 
                {
                    System.out.println("No");
                }
            }
            else 
            {
                int a = scan.nextInt();
                System.out.println(size[find(a)]);
        
            }
        }
    }

}

10、堆

如何手写一个堆？
1、插入一个数 heap[++ size ] = x , up(size)
2、求集合当中的最小值 heap[1]
3、删除最小值 heap[1] = heap[size]; size--; down(1)
4、删除任意一个元素 heap[k] = heap[size];size --; up(k)，down(k)
5、修改任意一个元素 heap[k] = x; up(k)，down(k)
注意：4和5中，后两个操作只会执行一个，直接把两个写上，结果不变，不需判断

（1）O(n)的复杂度进行堆化
for(int i = n/2;i >= 1;i--) down(i);

（2）更改堆元素后重建堆时间：
推算过程：循环（n - 1）次，每次都是从根节点往下循环查找，所以每一次时间是,总时间：,因此，堆排序的时间复杂度为

模版:数据结构_第12张图片
image.png

（1）堆排序
import java.util.Scanner;


public class Main{
    static int N = 100010;
    static int[] h = new int[N];
    static int size ;
    public static void swap(int u,int t)
    {
        int x = h[u];
        h[u] = h[t];
        h[t] = x;
    }
    
    //哪个位置下沉操作
    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)
        {
            swap(u,t);//交换u和t位置的值
            down(t);
        }
    }
    //哪个位置上升
    public static void up(int u)
    {
        while(u/2 > 0 && h[u] < h[u/2])
        {
            swap(u,u/2);
            u /= 2;
        }
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();
        size = n;
        for(int i = 1;i <= n;i++) h[i] = scan.nextInt();
        
        //O(n)的复杂度进行堆化
        for(int i = n/2;i >= 1;i--) down(i);
        
        while(m -- > 0)
        {
            System.out.print(h[1]+" ");
            h[1] = h[size --];
            down(1);
        }
        
    }

}
（2）模拟堆

维护一个集合，初始时集合为空，支持如下几种操作：

“I x”，插入一个数x；
“PM”，输出当前集合中的最小值；
“DM”，删除当前集合中的最小值（数据保证此时的最小值唯一）；
“D k”，删除第k个插入的数；
“C k x”，修改第k个插入的数，将其变为x；
现在要进行N次操作，对于所有第2个操作，输出当前集合的最小值。

输入格式
第一行包含整数N。

接下来N行，每行包含一个操作指令，操作指令为”I x”，”PM”，”DM”，”D k”或”C k x”中的一种。

输出格式
对于每个输出指令“PM”，输出一个结果，表示当前集合中的最小值。

每个结果占一行。

模版:数据结构_第13张图片
image.png

// h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
// ph[k]存储第k个插入的点在堆中的位置
// hp[k]存储堆中下标是k的点是第几个插入的

注意：在”D”操作的时候，一定要先把插进去的元素对应的位置进行记录，否则heap_swap()时会造成提前置换，亲身踩坑
k = ph[k];//记录第k个插入元素的下标
heap_swap(k,size);

import java.util.Scanner;


public class Main{
    static int N = 100010;
    // h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
    // ph[k]存储第k个插入的点在堆中的位置
    // hp[k]存储堆中下标是k的点是第几个插入的
    static int[] h = new int[N];
    static int[] ph = new int[N];
    static int[] hp = new int[N];
    static int size = 0;//表示堆的大小

    public static void heap_swap(int u,int t)
    {
        //交换两个位置的值
        int x = h[u];
        h[u] = h[t];
        h[t] = x;

        //交换ph的指向位置
        ph[hp[u]] = t;
        ph[hp[t]] = u;

        //交换hp的指向位置
        int m = hp[u];
        hp[u] = hp[t];
        hp[t] = m;
    }


    //哪个位置下沉操作
    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)
        {
            heap_swap(u,t);//交换u和t位置的值
            down(t);
        }
    }
    //哪个位置上升
    public static void up(int u)
    {

        while(u/2 > 0 && h[u] < h[u/2])
        {
            heap_swap(u,u/2);
            u /= 2;
        }
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();

        int m = 0;//表示第几个数
        while(n -- > 0)
        {
            String op = scan.next();
            //“I x”，插入一个数x；
            if(op.equals("I"))
            {
                int x = scan.nextInt();
                size ++;
                m ++;
                h[size] = x;
                ph[m] = size; hp[size] = m; 
                up(size);
            }
            //“PM”，输出当前集合中的最小值；
            else if(op.equals("PM"))
            {
                System.out.println(h[1]);
            }
            //“DM”，删除当前集合中的最小值（数据保证此时的最小值唯一）；
            else if(op.equals("DM"))
            {

                heap_swap(1,size);
                size --;
                down(1);
            }
            //“D k”，删除第k个插入的数；
            else if(op.equals("D"))
            {
                int k = scan.nextInt();
                k = ph[k];//记录第k个插入元素的下标
                heap_swap(k,size);
                size --;

                up(k);
                down(k);

            }
            //“C k x”，修改第k个插入的数，将其变为x；
            else
            {
                int k = scan.nextInt();
                int x = scan.nextInt();

                k = ph[k];
                h[k] = x;

                up(k);
                down(k);
            }
        }

    }

}

11、哈希表

模版:数据结构_第14张图片
image.png

（1）开放寻址法（蹲坑位法）

1、取模找到该位置，若有人在坑里，则继续找，知道有空坑就跳去下一个坑
2、保证取模后的位置在指定的范围中，需要考虑到负数取模的情况
-17 % 10 的计算结果如下：r = (-17) - (-17 / 10) x 10 = (-17) - (-1 x 10) = -7
17 % -10 的计算结果如下：r = 17 - (17 / -10) x (-10) = (17) - (-1 x -10) = 7
-17 % -10 的计算结果如下：r = (-17) - (-17 / -10) x (-10) = (-17) - (1 x -10) = -7
因此，int k = (x % N + N) % N;
3、取N时，需要取比人数多的2~3倍的质数
4、0x3f3f3f3f比10^9次方大，不会被使用到，可以标识为没用过

模版:数据结构_第15张图片
image.png

开放寻址法代码

import java.io.*;
import java.util.Arrays;
import java.util.Scanner;

public class Main{
    static int N = 200003;
    static int[] h = new int[N];
    static int idx = 0;
   
    // 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
    public static int find(int x)
    {
        int k = (x % N + N) % N;
        while(h[k] != x && h[k] != 0x3f3f3f3f)
        {
            k ++;
            if(k == N) k = 0;
        }
        return k;
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        Arrays.fill(h, 0x3f3f3f3f);//初始化h[]数组的值为0x3f3f3f3f
        while(n -- > 0)
        {
            String op = scan.next();
            int x = scan.nextInt();
            if(op.equals("I"))
            {
                h[find(x)] = x;
            }
            else
            {
                if(h[find(x)] == x) System.out.println("Yes");
                else System.out.println("No");
            }
        }
    }
}

（2）拉链法：

红色圈圈要取的是比10^5方大的质数


模版:数据结构_第16张图片
image.png

拉链法代码

import java.io.*;
import java.util.Arrays;
import java.util.Scanner;

public class Main{
    static int N = 100003;
    static int[] h = new int[N];
    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;
        e[idx] = x;
        ne[idx] = h[k];
        h[k] = idx ++;
    }
    // 在哈希表中查询某个数是否存在
    public static boolean find(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 scan = new Scanner(System.in);
        int n = scan.nextInt();
        Arrays.fill(h, -1);//初始化h[]数组的值为-1
        while(n -- > 0)
        {
            String op = scan.next();
            int x = scan.nextInt();
            if(op.equals("I"))
            {
                insert(x);
            }
            else
            {
                if(find(x)) System.out.println("Yes");
                else System.out.println("No");
            }
        }   
    }

}

（3）字符窜哈希

思路：用一个k进制的角度，把一个字符串看成一个数字
核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
小技巧：取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果

模版:数据结构_第17张图片
image.png

模版:数据结构_第18张图片
image.png

给定一个长度为n的字符串，再给定m个询问，每个询问包含四个整数l1,r1,l2,r2，请你判断[l1,r1]和[l2,r2]这两个区间所包含的字符串子串是否完全相同。

字符串中只包含大小写英文字母和数字。

输入格式
第一行包含整数n和m，表示字符串长度和询问次数。

第二行包含一个长度为n的字符串，字符串中只包含大小写英文字母和数字。

接下来m行，每行包含四个整数l1,r1,l2,r2，表示一次询问所涉及的两个区间。

注意，字符串的位置从1开始编号。

输出格式
对于每个询问输出一个结果，如果两个字符串子串完全相同则输出“Yes”，否则输出“No”。

每个结果占一行。

数据范围
1≤n,m≤10^5

import java.io.*;
import java.util.Arrays;
import java.util.Scanner;

public class Main{
    static int N = 100010;
    static int P = 131;
    
    static long[] h = new long[N];
    static long[] p = new long[N];//p进制中每个位置对应的值
    static int idx = 0;
    public static long get(int L,int R)
    {
        return h[R] - h[L - 1] * p[R - L + 1];
    }
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String[] str1 = reader.readLine().split(" ");
        int n = Integer.parseInt(str1[0]);
        int m = Integer.parseInt(str1[1]);
        String s = reader.readLine();
        p[0] = 1;
        for(int i = 1;i <= n;i++)
        {
            h[i] = h[i - 1] * P + s.charAt(i - 1);
            p[i] = p[i - 1] * P;
        }
        
        while(m -- > 0)
        {
            String[] str2 = reader.readLine().split(" ");
            int L1 = Integer.parseInt(str2[0]);
            int R1 = Integer.parseInt(str2[1]);
            int L2 = Integer.parseInt(str2[2]);
            int R2 = Integer.parseInt(str2[3]);
            if(get(L1,R1) == get(L2,R2)) System.out.println("Yes");
            else System.out.println("No");
            
        }
    }
}

你可能感兴趣的:(模版:数据结构)

  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • 4.C_数据结构_队列 荣世蓥 数据结构数据结构
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • 【树一线性代数】005入门 Owlet_woodBird 算法
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
  • python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
    在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
  • 【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构leetcode算法
    给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 【高阶数据结构】并查集 椿融雪 数据结构与算法数据结构并查集
    文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
  • python中文版软件下载-Python中文版 编程大乐趣
    python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • 六、全局锁和表锁：给表加个字段怎么有这么多阻碍 nieniemin
    数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。6.1全局锁全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flushtableswithreadlock(FTWRL)。当你需要让整个库处于
  • Golang Channel PandaSkr golang
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
  • ⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表 英雄哪里出来 《LeetCode算法全集》算法数据结构链表c++归并排序
    饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述  将两个不降序链表合并为一个新的不降
  • 数据结构 1 五花肉村长 数据结构算法开发语言c语言visualstudio
    1.什么是数据结构数据结构（DataStructure）是计算机存储和组织数据的方式，是指相互之间存在的一种或多种特定关系的数据元的集合。2.什么是算法算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《
  • 【STM32系统】基于STM32设计的锂电池电量/电压检测报警器系统——文末完整资料下载（程序源码/电路原理图/电路PCB/设计文档/模块资料/元器件清单/实物图/答辩问题技巧/PPT模版等） 阿齐Archie 单片机嵌入式项目stm32嵌入式硬件单片机
    基于STM32设计的锂电池电量/电压检测报警器系统系统视频：摘要：本设计旨在研究一个基于STM32F103C8T6微控制器的锂电池电量/电压检测报警器系统，应用于便携式电子设备电池管理。系统通过STM32的ADC模块对锂电池电压进行采集，利用LCD1602显示模块实时显示电池电压，当检测到电池电量不足或电压异常时，蜂鸣器报警模块会发出警报提醒用户。系统采用简单的硬件结构和优化的软件架构，通过对实际
  • Axure移动端原型模板实例100+，APP原型设计模版，高保真高交互含大组件库 默林工作室 AxureRP原型模板axure原型模板
    作品概况页面数量：共100+页（长期更新中…）源文件格式：rp格式，兼容AxureRP9/10，非程序软件无源代码适用领域：APP、小程序、H5作品特色本品为「移动端原型模板实例100+」，属于APP+H5+小程序的页面实例原型模板，主要运用了中继器＋动态面板，栏目丰富样式多多，高保真高交互高复用（带仿真交互），可以快速组装成美观大方的原型图。该原型模板的页面尺寸为375×812像素，推荐演示设备
  • 【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】 NeVeRMoRE_2024 数据结构与算法实践数据结构算法leetcodeb树
    数据结构和算法实践-树-LeetCode113-路径总和Ⅱ题目MyThought代码示例JAVA-8题目给你二叉树的根节点root和一个整数目标和targetSum，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。叶子节点是指没有子节点的节点输入：root=[5,4,8,11,null,13,4,7,2,null,null,5,1],targetSum=22输出：[[5,4,11,2],[
  • 【Python】数据结构,链表,算法详解 AIAdvocate python数据结构链表排序算法广度优先深度优先
    今日内容大纲介绍自定义代码-模拟链表删除节点查找节点算法入门-排序类的冒泡排序选择排序插入排序快速排序算法入门-查找类的二分查找-递归版二分查找-非递归版分线性结构-树介绍基本概述特点和分类自定义代码-模拟二叉树1.自定义代码-模拟链表完整版"""案例:自定义代码,模拟链表.​背景: 顺序表在存储数据的时候,需要使用到连续的空间,如果空间不够,就会导致扩容失败,针对于这种情况,我们可以通过链表实现
  • AI教你学Python 第4天：函数和模块 凡人的AI工具箱 AI教你学Pythonpython开发语言人工智能AIGC
    第四天：数据结构一、什么是数据结构？数据结构是计算机科学中用于组织和存储数据的特定方式。良好的数据结构能够提高数据的访问效率、修改频率和管理能力。Python提供了多种内置数据结构，如列表、元组、字典和集合，便于开发者更有效地处理数据。二、Python中的基本数据结构1.列表（List）定义：列表是一个有序的可变集合，允许重复元素。使用方括号[]表示。#示例：定义一个列表fruits=['appl
  • 互联网 Java 工程师面试题（Java 面试题四） 苹果酱0567 面试题汇总与解析java中间件开发语言springboot后端
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
  • P4779 【模板】单源最短路径(堆优化dijkstra) summ1ts 一些模版算法图论最短路dijkstra堆
    堆优化dijkstra，时间复杂度，我个人写习惯的模版。#includeusingnamespacestd;#definePIIpair#definefifirst#definesesecondconstintN=2e5+10;intread(){intx=0,f=1;charch=getchar();while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar()
  • C# Tuple、ValueTuple 語衣 C#知识补充c#
    栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
  • Rust中的所有权和借用规则详解 代码云1 rust开发语言后端
    Rust是一种系统编程语言，其设计目标包括内存安全、并发安全以及性能。为了实现这些目标，Rust引入了一系列独特的编程概念，其中最为核心的就是所有权（Ownership）和借用（Borrowing）规则。本文将详细解释Rust中的所有权和借用规则，以及它们如何确保内存安全和并发安全。一、所有权规则在Rust中，每一个值都有一个与之关联的所有者。这个所有者可以是变量、数据结构或者是其他形式的存储。所
  • 二分查找排序算法 周凡杨 java二分查找排序算法折半
    一：概念 二分查找又称 折半查找（ 折半搜索/ 二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而 查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表 分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
  • java中的BigDecimal bijian1013 javaBigDecimal
            在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。         原文地址：http://blog.csdn.net/ugg/article/de
  • Shell echo命令详解 daizj echoshell
    Shell echo命令 Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： echo string 您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: echo "It is a test" 这里的双引号完全可以省略，以下命令与上面实例效果一致： echo Itis a test 2.显示转义
  • Oracle DBA 简单操作 周凡杨 oracle dba sql
    --执行次数多的SQL select sql_text,executions from (      select sql_text,executions from v$sqlarea order by executions desc      ) where rownum<81;  &nb
  • 画图重绘 朱辉辉33 游戏
      我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。   在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
  • 线程之初体验 西蜀石兰 线程
    一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。 之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。 线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。 你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
  • linux集群互相免登陆配置 林鹤霄 linux
    配置ssh免登陆 1、生成秘钥和公钥    ssh-keygen -t rsa 2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub    其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密    c
  • mysql : Lock wait timeout exceeded; try restarting transaction aigo mysql
    原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html   原因是你使用的InnoDB   表类型的时候, 默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 因为有的锁等待超过了这个时间,所以抱错.   你可以把这个时间加长,或者优化存储
  • Socket编程 基本的聊天实现。 alleni123 socket
    public class Server { //用来存储所有连接上来的客户 private List<ServerThread> clients; public static void main(String[] args) { Server s = new Server(); s.startServer(9988); } publi
  • 多线程监听器事件模式(一个简单的例子) 百合不是茶 线程监听模式
        多线程的事件监听器模式   监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到        创建多线程的事件监听器模式 思路:    1, 创建线程并启动,在创建线程的位置设置一个标记     2,创建队
  • spring InitializingBean接口 bijian1013 javaspring
    spring的事务的TransactionTemplate，其源码如下： public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{ ... } TransactionTemplate继承了DefaultT
  • Oracle中询表的权限被授予给了哪些用户 bijian1013 oracle数据库权限
            Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 select t.table_name as "表名", t.grantee as "被授权的属组", t.owner as "对象所在的属组"
  • 【Struts2五】Struts2 参数传值 bit1129 struts2
    Struts2中参数传值的3种情况 1.请求参数绑定到Action的实例字段上 2.Action将值传递到转发的视图上 3.Action将值传递到重定向的视图上   一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上 Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
  • 【Kafka十四】关于auto.offset.reset[Q/A] bit1129 kafka
    I got serveral questions about  auto.offset.reset. This configuration parameter governs how  consumer read the message from  Kafka when  there is no initial offset in ZooKeeper or
  • nginx gzip压缩配置 ronin47 nginx gzip 压缩范例
    nginx gzip压缩配置 更多 0 nginx gzip 配置   随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
  • java-13.输入一个单向链表，输出该链表中倒数第 k 个节点 bylijinnan java
    two cursors. Make the first cursor go K steps first. /* * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点 */ public void displayKthItemsBackWard(ListNode head,int k){ ListNode p1=head,p2=head;
  • Spring源码学习-JdbcTemplate queryForObject bylijinnan javaspring
    JdbcTemplate中有两个可能会混淆的queryForObject方法： 1. Object queryForObject(String sql, Object[] args, Class requiredType) 2. Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 第1个方法是只查
  • [冰川时代]在冰川时代,我们需要什么样的技术? comsci 技术
         看美国那边的气候情况....我有个感觉...是不是要进入小冰期了?      那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段...   &nb
  • js 获取浏览器型号 cuityang js浏览器
    根据浏览器获取iphone和apk的下载地址 <!DOCTYPE html> <html> <head>     <meta charset="utf-8" content="text/html"/>     <meta name=
  • C# socks5详解 转 dalan_123 socketC#
    http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html  这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
  • 运维 Centos问题汇总 dcj3sjt126com 云主机
    一、sh 脚本不执行的原因 sh脚本不执行的原因 只有2个 1.权限不够 2.sh脚本里路径没写完整。   二、解决You have new mail in /var/spool/mail/root 修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 MailTo = MailFrom   三、查询连接数
  • Yii防注入攻击笔记 dcj3sjt126com sqlWEB安全yii
    网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号 这里有个转义对照表： http://blog.csdn.net/xinzhu1990/articl
  • MongoDB简介[一] eksliang mongodbMongoDB简介
    MongoDB简介 转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用        MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。        另外，不
  • zookeeper windows 入门安装和测试 greemranqq zookeeper安装分布式
    一、序言       以下是我对zookeeper 的一些理解：      zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。       栗子1号：       假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
  • Spring之使用事务缘由(2-注解实现) ihuning spring
      Spring事务注解实现   1. 依赖包：     1.1 spring包：           spring-beans-4.0.0.RELEASE.jar           spring-context-4.0.0.
  • iOS App Launch Option 啸笑天 option
    iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。   launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节 。 1、若用户直接
  • jdk与jre的区别（_） macroli javajvmjdk
    简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。  JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。 如果安装了JDK，会发同你
  • Updates were rejected because the tip of your current branch is behind qiaolevip 学习永无止境每天进步一点点众观千象git
    $ git push joe prod-2295-1 To [email protected]:joe.le/dr-frontend.git ! [rejected] prod-2295-1 -> prod-2295-1 (non-fast-forward) error: failed to push some refs to '[email protected]
  • [一起学Hive]之十四-Hive的元数据表结构详解 superlxw1234 hivehive元数据结构
    关键字：Hive元数据、Hive元数据表结构   之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。 本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。   文章最后面，会以一个示例来全面了解一下，
  • Spring 3.2.14，4.1.7，4.2.RC2发布 wiselyman Spring 3
      Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。   其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。   其中Spring 4.1.7主要包含这些更新内容。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他