content stringlengths 263 5.24M | pred_label stringclasses 1
value | pred_score_pos float64 0.6 1 |
|---|---|---|
# vector 详解
- vector 维护的是一段连续线性空间，所以不论其元素类型为何，普通指针都可作为 vector 的迭代器而满足所有必要条件
- 增加新元素，如果超出当前容量，则容量会扩充至两倍
### vector 上常见的操作复杂度
- 随机访问、尾插、尾删 O(1)
- 插入或者移除元素 O(n)
### vector 的迭代器类型
- vector 的迭代器涵盖了原生指针的算术能力，同时 vector 支持随机存取，所以 vector 提供的是随机访问迭代器
- 迭代器函数
- begin()：获取首元素位置，起始位置
- end()：返回最后一个元素的下一个位置，vector 实现遵循区间左开右... | __label__POS | 0.900404 |
**[How To Exploit Spring Projections(DTO) And Join Unrelated Entities In Hibernate 5.1+](https://github.com/AnghelLeonard/Hibernate-SpringBoot/tree/master/HibernateSpringBootDtoUnrelatedEntities)**
**Description:** This application is a proof of concept for using Spring Projections (DTO) and join unrelated entities. H... | __label__POS | 0.652878 |
package com.spun.util.io;
import com.spun.util.ObjectUtils;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
/**
* A static class of convenience ... | __label__POS | 0.796554 |
# const 关键字
const 修饰一个变量为可读，意味着该变量里的数据只能被访问，而不能被修改，const 离谁近意味着谁就不能被修改
### const 作用
[const 详解](https://blog.csdn.net/Eric_Jo/article/details/4138548)
- const 可以用来定义常量，修饰函数参数、修饰函数返回值、且被 const 修饰的东西，都受到强制保护，可以预防其他代码无意识的进行修改，从而
提高了程序的健壮性
- 是编译器保护那些不希望被修改的参数，防止无意识的修改，减少 Bug
- 提高程序可读性，声明一个参数，是为了告诉用户这个参数的应用目的
- const 修饰的... | __label__POS | 0.832598 |
package cn.aprilviolet.highlightbracketpair.extend;
import cn.aprilviolet.highlightbracketpair.util.Pair;
import com.intellij.lang.Language;
import com.intellij.psi.tree.IElementType;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* Customer Vue support Bracket
*
* @author AprilViole... | __label__POS | 0.887129 |
package cn.aprilviolet.highlightbracketpair.extend;
import cn.aprilviolet.highlightbracketpair.brace.BraceTokenTypes;
import cn.aprilviolet.highlightbracketpair.util.Pair;
import com.intellij.lang.Language;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.editor.highlighter.HighlighterIterator;... | __label__POS | 0.93017 |
package com.spun.util.io;
import com.spun.util.StringUtils;
import com.spun.util.logger.SimpleLogger;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import ... | __label__POS | 0.983167 |
**[How To Customize Tomcat Settings Via Properties And `DataSourceBuilder`](https://github.com/AnghelLeonard/Hibernate-SpringBoot/tree/master/HibernateSpringBootDataSourceBuilderTomcatKickoff)**
**Note:** The best way to tune the connection pool parameters consist in using [Flexy Pool](https://github.com/vladmihalcea/... | __label__POS | 0.961762 |
package com.apress.springrecipes.course;
import java.util.GregorianCalendar;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.apress.springrecipes.cour... | __label__POS | 0.993832 |
# map 和 set
map 和 set 都是 STL 中提供的关联式容器，其底层实现都是红黑树，由于 map 和 set 所开放的各种操作接口，红黑树也都实现了，所以几乎
所有的 map 和 set 操作行为，都只是间接调用红黑树的操作
### map 和 set 的区别
- map 中的元素是 key-value，关键字起到索引的作用，值则表示与索引相关联的数据，对于 set 而言，其则
是关键字的集合，set 中每个元素只包含一个关键字
- set 的迭代器是 const 的，不允许修改元素的值，map 允许修改 value，但不允许修改 key，其原因是 map 和 set 是根据
关键字排序来保证有序性的，如果允许... | __label__POS | 1.00001 |
#include "doctest/doctest.h"
#include <vector>
#include "ApprovalTests/CombinationApprovals.h"
namespace
{
double functionThatReturnsSomethingOutputStreamable(const std::string& /*input1*/,
const int input2,
... | __label__POS | 0.63548 |
local arg = arg or {}
local use_cuda = (table.remove(arg,1)=="true")
if util.is_cuda_available() and use_cuda then
mathcore.set_use_cuda_default(true)
printf("USING CUDA\n\n")
end
--
local tests_list = table.invert(arg)
--
local clock = util.stopwatch()
local rnd = random(1234)
local T = function(id, func)
loc... | __label__POS | 0.97691 |
# struct 和 class 区别
### 默认的访问权限
- class 中默认的访问权限是 private 的，而 struct 中则是 public 的
### 默认的继承权限
- 默认继承权限。如果不明确指定，来自class的继承按照private继承处理，来自struct的继承按照public继承处理
### 大括号初始化问题
- 在 C 语言中，我们知道 struct 是一种数据类型，只能定义数据成员，不能定义函数，这是因为 C 是面向过程，面向过程认为
数据和操作是分开的，所以 C 语言中可以看到这样的情况
```cpp
struct test {
int a;
int b;
};
... | __label__POS | 0.957358 |
package com.spun.util.database.automaticsetter;
import com.spun.util.ObjectUtils;
import com.spun.util.database.AutomaticVariableSetter;
import com.spun.util.database.DatabaseObject;
import com.spun.util.logger.SimpleLogger;
import java.sql.Statement;
public class EndDateVariableSetter implements AutomaticVariableSe... | __label__POS | 0.879734 |
# 智能指针、原理、注意事项、大坑
### 使用智能指针应该注意的问题
- 不要把一个原生的指针给多个 shared_ptr 或者 unique_ptr 管理
```cpp
int* ptr = new int(2);
shared_ptr<int> p1(ptr);
shared_ptr<int> p2(ptr);
// p1 p2 析构的时候都会释放 ptr，同一内存被释放多次
```
我们知道，在使用原生指针对智能指针初始化的时候，智能指针对象都视原生指针为自己管理的资源。换句话意
思就说：初始化多个智能指针之后，这些智能指针都担负起释放内存的作用。那么就会导致该原生指针会被释放多次！！！
- 不要把 this 指针... | __label__POS | 0.999133 |
**[How Hibernate Session-Level Repeatable Reads Works](https://github.com/AnghelLeonard/Hibernate-SpringBoot/tree/master/HibernateSpringBootSessionRepeatableReads)**
**Description:** This Spring Boot application is a sample that reveals how Hibernate session-level repeatable reads works. Persistence Context guarantee... | __label__POS | 0.906806 |
package com.spun.util.database.automaticsetter;
import com.spun.util.database.AutomaticVariableSetter;
import com.spun.util.database.DatabaseObject;
import java.sql.Statement;
import java.sql.Timestamp;
public class ChangeDateVariableSetter implements AutomaticVariableSetter
{
public static final ChangeDateVariabl... | __label__POS | 0.984694 |
#include "mhook/mhook.h"
#include "term-index/term-index.h"
#include "proximity.h"
#define INIT_ARR(_name) \
{sizeof(_name) / sizeof(position_t), _name, 0}
position_t test1()
{
position_t arr1[] = {5, 8, 10, 19};
position_t arr2[] = {1, 4, 9};
position_t arr3[] = {2, 3, 6, 7, 11, 15};
prox_input_t input[3] = {
... | __label__POS | 0.693227 |
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
/*
* 从尾到头打印链表
*
* 方案一：修改链表
* 方案二：不修改链表
* */
struct ListNode {
int val_;
ListNode* next_;
ListNode(int x)
:val_(x),
next_(nullptr)
{}
};
class Solution {
public:
ListNode* reverseList(ListNode* pNode)... | __label__POS | 1.00001 |
package com.apress.springrecipes.course;
import java.util.GregorianCalendar;
import com.apress.springrecipes.course.jpa.JpaCourseDao;
public class Main {
public static void main(String[] args) {
CourseDao courseDao = new JpaCourseDao();
Course course = new Course();
course.setTitle("Co... | __label__POS | 0.999797 |
#include <bits/stdc++.h>
using namespace std;
/*
* 方案一：将整数转换为字符串，判断其是否为一个回文串
* 方案二：
* 回文数，判断一个整数是不是回文
* 1221
* 1 == 1
* 2 == 2
* 1221 / 1000 -> 1 && 1221 % 10 -> 1 true
* 方案三：取出整数后半段数字进行翻转
* */
bool isPalindromeOne(int x) {
if (x < 0) {
return false;
}
// 相当于统计 x 有几位数
int div = 1;
... | __label__POS | 0.999953 |
// <copyright file="MetricsOptionsExtensions.cs" company="App Metrics Contributors">
// Copyright (c) App Metrics Contributors. All rights reserved.
// </copyright>
using System.Collections.Generic;
namespace App.Metrics.Internal.Extensions
{
public static class MetricsOptionsExtensions
{
public stat... | __label__POS | 0.85926 |
#include <bits/stdc++.h>
using namespace std;
/*
* 物品种类 N
* 背包容量 C
* 对应第 i 种物品的体积或者重量或者花费是 W[i]
* 对应第 i 种物品的价值为 V[i]
* 【完全背包】每种物品对应的数量是无限的，即每种物品可以无限件取
* 求解将哪些物品放入背包可使得这些物品的总体积不超过背包容量且总价值最大
* */
int main()
{
// 物品种类数目 N
// 背包容量 C
int N, C;
while (cin >> N >> C) {
// W 对应第 i 件物品的重量或者体积
... | __label__POS | 0.999857 |
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="chrome=1">
<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
<script type="text/javascript" src="//use.typekit.net/jbn8qxr.js"></script>
<scri... | __label__POS | 0.977552 |
package worker
import (
"encoding/binary"
rt "github.com/appscode/g2/pkg/runtime"
)
// Worker side job
type outPack struct {
dataType rt.PT
data []byte
handle string
}
func getOutPack() (outpack *outPack) {
// TODO pool
return &outPack{}
}
// Encode a job to byte slice
func (outpack *outPack) Encode()... | __label__POS | 0.747084 |
package com.spun.util.markdown.table;
import com.spun.util.StringUtils;
public class MarkdownTableHeader implements MarkdownTableElement, Resizable
{
private int padUntil = 1;
private MarkdownColumn columnProperties;
public MarkdownTableHeader()
{
}
@Override
public String toString()
{
... | __label__POS | 0.966494 |
#include <bits/stdc++.h>
using namespace std;
/*
* 【最长公共子序列】给出两个字符户，找出最长公共子序列，返回 dp 长度
*
* 最长公共子序列问题是在一组序列中找出最长公共子序列(可以不连续)
*
* ABCD
* EDCA
*
* 给定 A[] B[]
*
* 1
*
* dp A 或者 D 或者 C
*
* dp[i][j] 表示以字符串 A[i] 结尾，以 B[j] 结尾产生的最长子序列
*
* */
int main()
{
string A, B;
while (cin >> A >> B) {
i... | __label__POS | 0.999125 |
package com.spun.util.markdown.table;
import com.spun.util.markdown.MarkdownCompatible;
import org.lambda.functions.Function1;
import org.lambda.query.Queryable;
public class MarkdownTable implements MarkdownCompatible
{
public Queryable<MarkdownTableElement> markdown = new Queryable<MarkdownTableElement>(
... | __label__POS | 0.917747 |
#include <bits/stdc++.h>
using namespace std;
/*
* 物品种类 N
* 背包容量 C
* nums 对应第 i 种物品的最大数量
* W 对应第 i 种物品的体积或者重量
* V 对应第 i 种物品的价值
* 【多重背包问题】
* */
int main()
{
int N, C;
while (cin >> N >> C) {
vector<int> W(N + 1, 0);
vector<int> V(N + 1, 0);
vector<int> nums(N + 1, 0);
fo... | __label__POS | 0.999973 |
package com.spun.util.markdown.table;
import com.spun.util.StringUtils;
public class MarkdownTableContents implements MarkdownTableElement, Resizable
{
private String contents;
private int padUntil;
private MarkdownColumn columnProperties = MarkdownColumn.DEFAULT;
public MarkdownTableConten... | __label__POS | 0.984534 |
#include <bits/stdc++.h>
using namespace std;
/*
*
* 【最长公共子串】给出两个字符串，找到最长公共子串，并返回长度
* dp[i][j] 表示以 A[i-1] B[j-1] 为结尾的最长公共子串的长度
*
* count 表示全局最长长度，至于为什么，我不清楚
* */
int main()
{
string A, B;
while (cin >> A >> B) {
int M = A.size();
int N = B.size();
vector<vector<int> > dp(M + 1, ... | __label__POS | 0.999974 |
**[How To Fetch `Slice<entity>`/`Slice<dto>` Via `fetchAll`/`fetchAllDto`](https://github.com/AnghelLeonard/Hibernate-SpringBoot/tree/master/HibernateSpringBootSliceAllViaFetchAll)**
**Story**: Spring Boot provides an *offset* based built-in paging mechanism that returns a `Page` or `Slice`. Each of these APIs represe... | __label__POS | 0.643427 |
package com.spun.util.io.xml;
import com.spun.util.ClassUtils;
import com.spun.util.ObjectUtils;
import com.spun.util.database.DatabaseObject;
import com.spun.util.database.Syncable;
import com.spun.util.database.TemporaryCache;
import com.spun.util.database.XmlDatabaseMapExtractor;
import com.spun.util.io.XMLUtils;
i... | __label__POS | 0.675173 |
package com.spun.util.io.xml;
import com.spun.util.ObjectUtils;
import org.w3c.dom.Node;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map.Entry;
public class XmlTranslator
{
private HashMap<String, XmlExtractor> extractors = new HashMap<String, XmlExtractor>();
private HashMap<Stri... | __label__POS | 0.788481 |
#include <bits/stdc++.h>
using namespace std;
/*
* 给定 N 种物品
* 一个容量为 C 的背包
* 物品 i 的重量或者体积是 W[i]
* 价值是 V[i]
*
* 【无价值问题】问：从给定的 N 件物品中，如何选择若干件物品恰好能装入背包
* 找出满足条件的所有解
* 示例：
* N = 6
* C = 10
* W[] = {1, 8, 4, 3, 5, 2};
*
* [1, 4, 3, 2]
* [1, 4, 5]
* [8, 2]
* [3, 5, 2]
*
* vector<vector<int> >;
*
* */
... | __label__POS | 0.999559 |
#include <bits/stdc++.h>
using namespace std;
/*
* 【DFS、BFS 问题】
* 给定一个数组，找出所有该数组的递增子序列
*
* [4, 6, 7, 7]
*
* [4, 6]
* [4, 7]
* [4, 6, 7]
* [4, 6, 7, 7]
* [6, 7]
* [6, 7, 7]
* [7, 7]
* [4, 7, 7]
*
*
* 因为要查找所有有可能的序列，所以需要深度搜索或者广度搜索算法
* 有一个注意的点就是如何处理重复问题
* 我们可以使用 set 容器对元素进行唯一性处理
* */
void DFS(set<vec... | __label__POS | 0.998884 |
#include <bits/stdc++.h>
using namespace std;
/*
* 迷宫可以看成是有向图，向上的边权值为 3，向下的边权值为 0，等等
* 不相邻的边或者一端有障碍物的边，权值是无穷大，本质上就是求这个有向
* 图从 (0,0) 到 (0,m-1) 的最短路径
* 可利用 Dijkstra 算法
* */
int main()
{
// N 行
// M 列
// P 体力值
int N, M, P;
while (cin >> N >> M >> P) {
// board 迷宫矩阵
vector<vector... | __label__POS | 0.950028 |
package com.spun.util.io.xml;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import java.util.ArrayList;
public class XmlExtractorUtil
{
private XmlExtractorUtil()
{
} // Static class should not be instantiated
public static Object[] extract(Node node, String xmlName, Class<? extends XmlExtractable> c... | __label__POS | 0.996014 |
#include <bits/stdc++.h>
using namespace std;
/*
* 某餐馆有n张桌子，每张桌子有一个参数：a 可容纳的最大人数； 有 m 批
* 客人，每批客人有两个参数:b人数，c预计消费金额。 在不允许拼桌的
* 情况下，请实现一个算法选择其中一部分客人，使得总预计消费金额最大
* */
int main()
{
// N 张桌子
// M 批客人
int N, M;
while (cin >> N >> M) {
// table 对应每张左子的容量
vector<int> table(N, 0);
... | __label__POS | 0.997097 |
**[How To Provide a Fluent API Via Additional Methods For Building Entities](https://github.com/AnghelLeonard/Hibernate-SpringBoot/tree/master/HibernateSpringBootFluentApiAdditionalMethods)**
**Note**: If you want yo provide a Fluent API by altering setters then consider [this item](https://github.com/AnghelLeonard/Hi... | __label__POS | 0.898831 |
package com.spun.util.io.xml;
import com.spun.util.io.XMLUtils;
import org.w3c.dom.Node;
import java.sql.Timestamp;
public class BasicExtractor
{
public static XmlExtractor get(Class<?> clazz)
{
XmlExtractor extractor = null;
if (String.class.isAssignableFrom(clazz))
{
extractor = StringExtract... | __label__POS | 0.996348 |
**[Prefer `Set` Instead of `List` in `@ManyToMany` Associations](https://github.com/AnghelLeonard/Hibernate-SpringBoot/tree/master/HibernateSpringBootManyToManyBidirectionalListVsSet)**
**Description:** This is a Spring Boot example of removing rows in case of a bidirectional `@ManyToMany` using `List`, respectively `... | __label__POS | 0.823649 |
package org.approvaltests.hadoop.version1.tests;
import java.io.IOException;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.approvaltests.hadoop.version1.HadoopApprovals;
import org.approvalt... | __label__POS | 0.724642 |
### nullptr
nullptr 出现的目的是为了替代 NULL。在某种意义上来说，传统 C++ 会把 NULL、0 视为同一种东西，这取决于编译器如
何定义 NULL，有些编译器会将 NULL 定义为 `((void*)0)`，有些则会直接将其定义为 0。
C++ 不允许直接将 void * 隐式转换到其他类型，但如果 NULL 被定义为 `((void*)0)`，那么当编译
```cpp
char* ch = NULL;
```
时，NULL 只好被定义为 0。而这依然会产生问题，将导致了 C++ 中重载特性会发生混乱，考虑：
```cpp
void foo(char*);
void foo(int);
```
... | __label__POS | 0.969658 |
* [static 关键字](#static-关键字)
* [头文件中的 #ifndef/#define/#endif 作用](#头文件中的-ifndefdefineendif-作用)
* [#include <file.h> 和 #include "file.h" 的区别](#include-fileh-和-include-fileh-的区别)
* [extern 关键字和 extern "C" 的作用](#extern-关键字和-extern-c-的作用)
* [struct 和 class 的区别](#struct-和-class-的区别)
* [结构体内存对齐，为什么要内存对齐，结构体大小](#结构体内存对齐为什么要内存对齐... | __label__POS | 0.976874 |
**[How To Manually Assign UUID Identifiers](https://github.com/AnghelLeonard/Hibernate-SpringBoot/tree/master/HibernateSpringBootAssignedUUID)**
<b><a href="https://persistencelayer.wixsite.com/springboot-hibernate/post/the-best-way-to-manually-assign-uuid-identifiers">If you prefer to read it as a blog-post containi... | __label__POS | 0.873085 |
package runtime
import (
"errors"
"fmt"
"gopkg.in/robfig/cron.v2"
)
const starBit = 1 << 63
type CronSpecInterface interface {
Bytes() []byte
Expr() string
Schedule() cron.Schedule
}
type cronSpec struct {
specByte []byte
expression string
schedule *cron.SpecSchedule
}
func NewCronSchedule(expr strin... | __label__POS | 0.738824 |
package com.apress.springrecipes.vehicle.config;
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import com.apress.springrecipes.vehicle.JdbcVehicleDao;
import com.apress.s... | __label__POS | 0.903516 |
* [什么是多态](#什么是多态)
* [虚函数是如何实现多态的](#虚函数是如何实现多态的)
* [在 virtual 背后究竟发生了什么](#在-virtual-背后究竟发生了什么)
* [类的多态性和函数的多态性](#类的多态性和函数的多态性)
* [析构函数声明为虚函数的好处](#析构函数声明为虚函数的好处)
* [构造函数为什么不能声明为虚函数](#构造函数为什么不能声明为虚函数)
### 什么是多态
多态是 C++ 编程时的一种特性，多态性即是对一个接口的多种实现，多态可以分为
静态多态和动态多态，所谓静态多态就是通过函数重载、模板、强制类型转换实现的，
静态多态是在函数编译阶段就决定调用的机制，即在编译链接截断将函... | __label__POS | 0.748899 |
#import "AMACore.h"
#import "AMAUserProfileUpdatesProcessor.h"
#import "AMAUserProfileModel.h"
#import "AMAUserProfileUpdate.h"
#import "AMAAttributeUpdateValidating.h"
#import "AMAAttributeUpdate.h"
#import "AMAUserProfileModelSerializer.h"
#import "AMAErrorsFactory.h"
@interface AMAUserProfileUpdatesProcessor ()
@... | __label__POS | 0.881115 |
package org.approvaltests.hadoop;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class WritableUtils
{
public static <T> T createWritable(Object value, Class<T> writableType)
throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMe... | __label__POS | 0.784087 |
package com.apress.springrecipes.vehicle.config;
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import com.apress.springrecipes.vehicle.NamedJdbcVehicleDao;
import com.apr... | __label__POS | 0.805165 |
package org.approvaltests.hadoop.version1;
import java.io.IOException;
import org.apache.hadoop.mapreduce.Mapper;
public class MapperWrapper<KeyIn, ValueIn, KeyOut, ValueOut> extends SmartMapper<KeyIn, ValueIn, KeyOut, ValueOut>
{
private final Class<KeyIn> keyIn;
private final Class<... | __label__POS | 0.978376 |
# 操作系统基础概念
### 进程
每个正在系统上运行的程序都可以看作是一个进程，每个进程包含一个到多个线程，进程也可能是程序或者部分程序的动态执行
进程是对运行程序的封装，是系统进行资源调度和分配的基本单位
### 线程
线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行，也可以把它理解为代码运行的上下文，所以线程基本上是轻量级的进程，它负责在单个程序里
执行多个任务，通常由操作系统负责多个线程的调度和执行
线程是进程的子任务，是 CPU 调度的基本单位，用于保证程序的实时性，实现进程内部的并发，线程是操作系统可识别的最小执行和调度单位，每个线程都独自占用一个虚拟处理器：
独自的寄存器组，指令计数器和处理... | __label__POS | 0.995901 |
package org.approvaltests.hadoop.version1;
import java.io.IOException;
import org.apache.hadoop.mapreduce.Reducer;
public class ReducerWrapper<KeyIn, ValueIn, KeyOut, ValueOut>
extends
SmartReducer<KeyIn, ValueIn, KeyOut, ValueOut>
{
private final Class<KeyIn> keyIn;
privat... | __label__POS | 0.981758 |
# 数据结构
## 基本概念
* [堆](#堆)
* [栈](#栈)
* [队列](#队列)
* [散列表](#散列表)
* [二叉树](#二叉树)
* [二叉查找树](#二叉查找树)
* [完全二叉树](#完全二叉树)
* [平衡二叉树](#平衡二叉树)
* [b 树、b+ 树](#b-树b-树)
* [红黑树](#红黑树)
#### 堆
堆也被称为优先队列，队列中允许的操作是先进先出(FIFO)，在队尾插入元素，在队头删除元素，而堆也是一样，在堆低插入元素，在堆顶删除元
素，二叉树的衍生，有着最小堆最大堆两个概念之分，将根节点大的称为大... | __label__POS | 0.950051 |
package org.approvaltests.hadoop.version2;
import java.io.IOException;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reporter;
public class MapperWrapper<KeyIn, ValueIn, KeyOut, ValueOut>
implement... | __label__POS | 0.891645 |
package org.approvaltests.hadoop.version2;
import java.io.IOException;
import java.util.Iterator;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reducer;
import org.apache.hadoop.mapred.Reporter;
public class ReducerWrapper<KeyIn, ValueIn, Ke... | __label__POS | 0.868557 |
# 算法
* [排序算法](#排序算法)
* [查找算法](#查找算法)
* [背包问题](#背包问题)
* [无锁队列](#无锁队列)
#### 排序算法
- 堆排序【nlogn、nlogn、1、不稳定】
简单来说，堆排序是一种基于二叉堆结构的排序算法，所谓二叉堆，我们通过完全二叉树来对比
，只不过相比较完全二叉树而言，二叉堆的所有父节点值都大于或小于它的孩子节点
堆排序方法，把大顶堆堆顶的最大数取出，将剩余的堆继续使用向下调整为大顶堆，再次取出堆顶元素，这个过程持
续到堆里面只有一个元素为止
- 快速排序【nlogn、n^2、logn、不稳定】
在区间中随机挑选一个元素作为基准，将小于基准的元素放到基准之前，大于基... | __label__POS | 0.923223 |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.AddIn.Pipeline;
namespace HostSideAdapter
{
[HostAdapter]
public class ImageProcessorContractToViewHostAdapter : HostView.ImageProcessorHostView
{
private Contract.IImageProcessorContract contract;
... | __label__POS | 0.914568 |
package com.apress.springrecipes.vehicle.config;
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import com.apress.springrecipes.vehicle.NamedJdbcVehicleDao;
import com.apr... | __label__POS | 0.805165 |
# MySQL
* [三范式](#三范式)
* [Sql 优化](#sql-优化)
* [索引及索引优化](#索引及索引优化)
* [事务](#事务)
* [存储引擎](#存储引擎)
### 三范式
- 第一范式：列的原子性，列不可分割
- 满足第一范式。除此之外，必须有主键，没有包含主键的列必须完全依赖于主键
- 满足第二范式。非主键列必须直接依赖于主键，不能传递依赖
### Sql 优化
- 只返回所需要的数据
- 尽量不写 `select*` 的语句
- 合理写 where 子句，不要写没有 where 的语句
- 适当建立索引，但一下几点会进行全表扫描
- 左模糊查询`%···`
- 使用了不... | __label__POS | 0.874541 |
#include <bits/stdc++.h>
using namespace std;
/*
* 给定一个整数数组 nums 和一个目标值 target，请你在该数组
* 中找出和为目标值的那 两个 整数，并返回他们的数组下标
* */
/*
* 题解
*
* 最简单的想法就是把每两个数都拿出来相加，看看结果是不是我们想要的值
* 但是这样的时间复杂度为 n^2
* */
class Solution {
public:
vector<int> twoSumOne(vector<int>& nums, int target) {
for (size_t i = 0; i < num... | __label__POS | 0.999995 |
#include <bits/stdc++.h>
using namespace std;
/*
* 三数之和
*
* 给定一个包含 N 个整数的 nums，判断 nums 中是否存在
* 三个元素 a, b, c 使得 a + b + c = 0，找出所有序列
*
* 给定 nums = {-1, 0, 1, 2, -1, -4}
*
* [
* [-1, 0, 1]
* [-1, -1, 2]
* ]
* */
/*
* 题解
*
* 一个新的周末，你再次去现在参加了一个，额，这次不是相亲会，是参加一个街篮比赛
* ，赛前当然要组队啦，现在要想一个方法找到队友。组队还有一... | __label__POS | 0.999894 |
package com.apress.springrecipes.vehicle;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import javax.sql.DataSource;
import org.springframework.jdbc.core.BeanPro... | __label__POS | 0.61532 |
// <copyright file="AtomicLongArrayTests.cs" company="App Metrics Contributors">
// Copyright (c) App Metrics Contributors. All rights reserved.
// </copyright>
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using FluentAssertions;
using Xunit;
namespace App.Metrics.Concurrency... | __label__POS | 0.951338 |
package org.approvaltests;
import org.approvaltests.namer.NamedEnvironment;
import org.approvaltests.namer.NamerFactory;
import org.approvaltests.reporters.ClipboardReporter;
import org.approvaltests.reporters.DiffReporter;
import org.approvaltests.reporters.UseReporter;
import org.junit.jupiter.api.Test;
import org.j... | __label__POS | 0.970993 |
package org.approvaltests;
import org.lambda.utils.Range;
import org.approvaltests.utils.VerifiableMarkdownTable;
import org.junit.jupiter.api.Test;
public class TableTest
{
@Test
void abilityModifier()
{
Integer[] inputs = Range.get(1, 20);
VerifiableMarkdownTable table = VerifiableMarkdownTable.create... | __label__POS | 0.962644 |
package org.approvaltests;
import com.github.javaparser.ParseProblemException;
import com.github.javaparser.Range;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.NodeList;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.body.Parameter;
impor... | __label__POS | 0.837653 |
package org.approvaltests;
import com.google.gson.GsonBuilder;
import com.spun.util.JsonUtils;
import org.junit.jupiter.api.Test;
import java.time.Instant;
public class JsonFormattingTest
{
@Test
public void testGsonCircular()
{
Approvals.verifyException(() -> {
JsonApprovals.verifyAsJson(Circular.ge... | __label__POS | 0.931348 |
package com.apress.springrecipes.course;
import java.util.GregorianCalendar;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.apress.springrecipes.cour... | __label__POS | 0.993832 |
using System.Linq;
using SportsStore.Models;
using Xunit;
namespace SportsStore.Tests {
public class CartTests {
[Fact]
public void Can_Add_New_Lines() {
// Arrange - create some test products
Product p1 = new Product { ProductID = 1, Name = "P1" };
Product p... | __label__POS | 0.638653 |
**[How To Provide a Fluent API Via Setters For Building Entities](https://github.com/AnghelLeonard/Hibernate-SpringBoot/tree/master/HibernateSpringBootFluentApiOnSetters)**
**Note**: If you want yo provide a Fluent API without altering setters then consider [this item](https://github.com/AnghelLeonard/Hibernate-Sprin... | __label__POS | 0.781962 |
package org.approvaltests;
import com.spun.util.io.FileUtils;
import org.approvaltests.internal.logs.ApprovedFileLog;
import org.approvaltests.internal.logs.LoggingUtils;
import org.approvaltests.namer.ApprovalNamer;
import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.IOException;
import static or... | __label__POS | 0.752435 |
package org.approvaltests;
import com.spun.util.ThreadUtils;
import org.approvaltests.core.ApprovalFailureReporter;
import org.approvaltests.reporters.ClipboardReporter;
import org.approvaltests.reporters.DiffReporter;
import org.approvaltests.reporters.FirstWorkingReporter;
import org.approvaltests.reporters.UseRepor... | __label__POS | 0.898144 |
package com.apress.springrecipes.course;
import java.util.GregorianCalendar;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.apress.springrecipes.course.config.CourseConfiguration;
public class Main {
public sta... | __label__POS | 0.998379 |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.AddIn;
using System.Threading;
namespace NegativeImageAddIn
{
[AddIn("Negative Image Processor", Version = "1.0.0.0", Publisher = "Imaginomics",
Description = "Inverts colors to look like a photo negative")]... | __label__POS | 0.758732 |
import re
def replace_dollar_tex(s):
l = len(s)
i, j, stack = 0, 0, 0
new_txt = ''
while i < l:
if s[i] == "\\" and (i + 1) < l:
if s[i + 1] == '$':
# skip if it is escaped dollar
new_txt += '$'
i += 1
elif stack == 0:
# otherwise just copy it
new_txt += s[i]
elif s[i] == '$':
if s... | __label__POS | 0.987645 |
**[How To Take Control Before/After Transaction Commits/Completes Via Callbacks](https://github.com/AnghelLeonard/Hibernate-SpringBoot/tree/master/HibernateSpringBootTransactionCallback)**
**Description:** This application is an example of using the `TransactionSynchronizationAdapter` for overriding `beforeCommit()`,... | __label__POS | 0.760811 |
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Routing;
using Microsoft.AspNetCore.Razor.TagHelpers;
using Moq;
using SportsStore.Infrastructure;
using SportsStore.Models.ViewModels;
using Xunit;
namespace SportsStore.Tests {
public ... | __label__POS | 0.898823 |
// <copyright file="AtomicIntegerArrayTests.cs" company="App Metrics Contributors">
// Copyright (c) App Metrics Contributors. All rights reserved.
// </copyright>
using System;
using FluentAssertions;
using Xunit;
namespace App.Metrics.Concurrency.Facts
{
public class AtomicIntegerArrayTests
{
[Fact]... | __label__POS | 0.985743 |
var quiz_list = [
{ /* 0 */
"Q": "Find all solutions for [imath]1 = (1+x+\\frac 1 2 x^2)e^{-x}[/imath].",
"hints": [
"Okay, find all solutions for ...",
"Wait, what is this? It looks terrible!",
"Honestly, I hate my math homework.",
"Hmmm... Can I <a href=\"#\">find the answer</a> on the Internet?"
]... | __label__POS | 0.967016 |
**[How To View Query Details Via `log4jdbc`](https://github.com/AnghelLeonard/Hibernate-SpringBoot/tree/master/HibernateSpringBootLog4JdbcViewBindingParameters)**
**Description:** View the query details via [log4jdbc](https://github.com/candrews/log4jdbc-spring-boot-starter).
**Key points:**
- for Maven, in `pom.xml`... | __label__POS | 0.857865 |
using Microsoft.AspNetCore.Mvc;
using Moq;
using SportsStore.Controllers;
using SportsStore.Models;
using Xunit;
namespace SportsStore.Tests {
public class OrderControllerTests {
[Fact]
public void Cannot_Checkout_Empty_Cart() {
// Arrange - create a mock repository
Mock<... | __label__POS | 0.610877 |
package org.approvaltests;
import com.spun.util.ObjectUtils;
import com.spun.util.io.FileUtils;
import com.spun.util.logger.SimpleLogger;
import org.approvaltests.core.Options;
import org.lambda.functions.Function1;
import org.lambda.functions.Functions;
import org.lambda.query.Query;
import org.lambda.query.Queryable... | __label__POS | 0.872152 |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.AddIn.Pipeline;
namespace AddInSideAdapter
{
[AddInAdapter]
public class ImageProcessorViewToContractAdapter : ContractBase, Contract.IImageProcessorContract
{
private AddInView.ImageProcessorAddInVi... | __label__POS | 0.931739 |
**[Offset Pagination - Trigger `SELECT COUNT` Subquery And Return `Page<entity>` Via Extra Column](https://github.com/AnghelLeonard/Hibernate-SpringBoot/tree/master/HibernateSpringBootPageEntityOffsetPaginationExtraColumn)**
**Description:** This application fetches data as `Page<entity>` via Spring Boot offset pagina... | __label__POS | 0.660276 |
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.AspNetCore.Mvc.Routing;
using Microsoft.AspNetCore.Mvc.ViewFeatures;
using Microsoft.AspNetCore.Razor.TagHelpers;
using SportsStore.Models.ViewModels;
using System.Collections.Generic;
namespace SportsStore.Infrastructure {
... | __label__POS | 0.670637 |
package org.approvaltests;
import com.github.javaparser.Range;
import com.spun.util.StringUtils;
import org.approvaltests.core.Options;
import org.junit.jupiter.api.Test;
import org.lambda.query.Query;
import org.lambda.query.Queryable;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.l... | __label__POS | 0.722693 |
package com.apress.springrecipes.vehicle.config;
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import com.apress.springrecipes.vehicle.JdbcVehicleDao;
import com.apress.s... | __label__POS | 0.903516 |
**[How To Use Hibernate Query Plan Cache](https://github.com/AnghelLeonard/Hibernate-SpringBoot/tree/master/HibernateSpringBootQueryPlanCache)**
**Description:** This application is an example of testing the Hibernate Query Plan Cache (QPC). Hibernate QPC is enabled by default and, for entity queries (JPQL and Criter... | __label__POS | 0.826138 |
module Amy
class AbstractApplicationController < ActionController::Base
act_as_fry
act_as_amy
before_filter :authorize
protected
# private helpers
def strip_filename(name)
name.gsub('..', '').gsub('/', '')
end
public
def get_framework_files
... | __label__POS | 0.611731 |
package org.approvaltests;
import com.spun.util.markdown.MarkdownCompatible;
import org.junit.jupiter.api.Test;
import org.lambda.functions.Function2;
import org.lambda.query.Queryable;
import org.lambda.utils.Grid;
public class StoryBoardTest
{
@Test
void gameOfLife()
{
Approvals.settings().allowMultipleVe... | __label__POS | 0.958386 |
using System.Collections.Generic;
using System.Linq;
namespace SportsStore.Models {
public class EFProductRepository : IProductRepository {
private ApplicationDbContext context;
public EFProductRepository(ApplicationDbContext ctx) {
context = ctx;
}
public IQueryable... | __label__POS | 0.857337 |
<?php
function adpIncludeDynamicCss($location='header'){
$dirPath = get_stylesheet_directory().'/'.APP_DIRECTORY.'/css/';
$dirUri = get_stylesheet_directory_uri().'/'.APP_DIRECTORY.'/css/';
if(file_exists($dirPath)){
chdir($dirPath);
$cssFiles = glob('*.css');
if($cssFiles){
foreach($cssFiles as $cssFi... | __label__POS | 0.975664 |
package org.approvaltests.demos;
import com.spun.util.persistence.Loader;
import com.spun.util.persistence.Saver;
import com.spun.util.persistence.test.MockSaver;
import org.approvaltests.reporters.DiffMergeReporter;
import org.approvaltests.reporters.UseReporter;
import org.junit.Assert;
import org.junit.jupiter.api.... | __label__POS | 0.900974 |
using Microsoft.AspNetCore.Mvc;
using SportsStore.Models;
using System.Linq;
namespace SportsStore.Controllers {
public class OrderController : Controller {
private IOrderRepository repository;
private Cart cart;
public OrderController(IOrderRepository repoService, Cart cartService) {
... | __label__POS | 0.887665 |
package com.apress.springrecipes.course;
import java.util.GregorianCalendar;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.apress.springrecipes.cour... | __label__POS | 0.993832 |
using System.Linq;
using Microsoft.AspNetCore.Mvc;
using SportsStore.Models;
using SportsStore.Models.ViewModels;
namespace SportsStore.Controllers {
public class CartController : Controller {
private IProductRepository repository;
private Cart cart;
public CartController(IProductReposit... | __label__POS | 0.7421 |
package org.approvaltests.combinations;
import org.approvaltests.Approvals;
import org.approvaltests.strings.Printable;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class PrintableTest
{
@Test
void testSingles()
{
// begin-snippet: printable_single_... | __label__POS | 0.879648 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.