[模板]Treap

最新推荐文章于 2024-08-31 22:19:14 发布
最新推荐文章于 2024-08-31 22:19:14 发布
阅读量105 收藏
点赞数 1
文章标签： 模板 Treap 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C20201629/article/details/103310512
版权

友情链接：一篇写的很好的博客

旋转Treap

#include <cstdio>

int get() {
	int x = 0, f = 1; char s;
	while ((s = getchar()) < '0' || s > '9') if(s == '-') f = -1;
	while (s >= '0' && s <= '9') x = (x << 3) + (x << 1) + (s ^ 48), s = getchar();
	return x * f;
}

void put(int x) {
	if(x < 0) x = -x, putchar('-');
	if(x > 9) put(x / 10);
	putchar(x % 10 ^ 48);
}

int Max(const int x, const int y) {
	if(x > y) return x;
	return y;
}

int Min(const int x, const int y) {
	if(x < y) return x;
	return y;
}

const int MO = 2147483647;

int rand() {
	static int a = 52331314;
	a = a * 33457 % MO;
	return a;
}

const int M = 1e5 + 5, INF = 2e9;
int rt, siz[M], key[M], cnt[M], son[M][2], rd[M], tot;

void pushup(const int x) {
	siz[x] = siz[son[x][0]] + siz[son[x][1]] + cnt[x];
}

void rotate(int &x, const bool y) {
	int i = son[x][y ^ 1];
	son[x][y ^ 1] = son[i][y];
	son[i][y] = x;
	pushup(x);
	pushup(i);
	x = i;
}

void ins(int &x, const int val) {
	if(!x) {
		x = ++tot;
		siz[x] = cnt[x] = 1;
		key[x] = val;
		rd[x] = rand();
		return;
	}
	if(key[x] == val) {
		++cnt[x], ++siz[x];
		return;
	}
	bool d = val > key[x];
	ins(son[x][d], val);
	if(rd[x] < rd[son[x][d]]) rotate(x, d ^ 1);
	pushup(x);
}

void del(int &x, const int val) {
	if(!x) return;
	if(val != key[x]) del(son[x][val > key[x]], val);
	else {
		if(!son[x][0] && !son[x][1]) {
			--cnt[x], --siz[x];
			if(!cnt[x]) x = 0;
		} else if(son[x][0] && !son[x][1]) {
			rotate(x, 1);
			del(son[x][1], val);
		} else if(!son[x][0] && son[x][1]) {
			rotate(x, 0);
			del(son[x][0], val);
		} else {
			bool d = rd[son[x][0]] > rd[son[x][1]];
			rotate(x, d);
			del(son[x][d], val);
		}
	}
	pushup(x);
}

int getrank(const int x, const int val) {
	if(!x) return 0;
	if(key[x] == val)
		return siz[son[x][0]] + 1;
	if(key[x] < val)
		return siz[son[x][0]] + cnt[x] + getrank(son[x][1], val);
	return getrank(son[x][0], val);
}

int Find(const int x, const int val) {
	if(!x) return 0;
	if(siz[son[x][0]] >= val)
		return Find(son[x][0], val);
	if(siz[son[x][0]] + cnt[x] < val)
		return Find(son[x][1], val - cnt[x] - siz[son[x][0]]);
	return key[x];
}

int getpre(const int x, const int val) {
	if(!x) return -INF;
	if(key[x] >= val)
		return getpre(son[x][0], val);
	return Max(key[x], getpre(son[x][1], val));
}

int getsuc(const int x, const int val) {
	if(!x) return INF;
	if(key[x] <= val)
		return getsuc(son[x][1], val);
	return Min(key[x], getsuc(son[x][0], val));
}

int main() {
	
	return 0;
}

FHQ_Treap

#include <cstdio>

int get() {
	int x = 0, f = 1; char s;
	while ((s = getchar()) < '0' || s > '9') if(s == '-') f = -1;
	while (s >= '0' && s <= '9') x = (x << 3) + (x << 1) + (s ^ 48), s = getchar();
	return x * f;
}

void put(int x) {
	if(x < 0) x = -x, putchar('-');
	if(x > 9) put(x / 10);
	putchar(x % 10 ^ 48);
}

const int MO = 2147483647;

int rand() {
	static int a = 52331314;
	a = a * 33457 % MO;
	return a;
}

const int M = 1e5 + 5;;
int root, cnts, son[M][2], keyof[M], cnt[M], rd[M], siz[M];
struct Npair {
    int p[2];
};

void pushup(const int x) {
	siz[x] = cnt[x] + siz[son[x][0]] + siz[son[x][1]];
}

int newnode(const int nowk, const int val) {
	++cnts;
	son[cnts][0] = son[cnts][1] = 0;
	siz[cnts] = cnt[cnts] = val;
	keyof[cnts] = nowk;
	rd[cnts] = rand();
	return cnts;
}

Npair spli(const int x,int nowk) {
    Npair ans;
    ans.p[0] = ans.p[1] = 0;
    if(x) {
        int d = keyof[x] <= nowk;
        ans = spli(son[x][d], nowk);
        son[x][d] = ans.p[d ^ 1];
        pushup(x);
        ans.p[d ^ 1] = x;
    }
    return ans;
}

int merg(const int x1, const int x2) {
    if(!x1) return x2;
    if(!x2) return x1;
    if(rd[x1] < rd[x2]) {
        son[x1][1] = merg(son[x1][1], x2);
        pushup(x1);
        return x1;
    } else {
        son[x2][0] = merg(x1, son[x2][0]);
        pushup(x2);
        return x2;
    }
}

int ins(const int x, const int nowk) {
    Npair temp1 = spli(x, nowk);
    Npair temp0 = spli(temp1.p[0], nowk - 1);
    if(temp0.p[1]) {
        ++cnt[temp0.p[1]];
        pushup(temp0.p[1]);
        return merg(merg(temp0.p[0], temp0.p[1]), temp1.p[1]);
    }
    return merg(merg(temp0.p[0], newnode(nowk,1)), temp1.p[1]);
}

int del(const int x, const int nowk) {
    Npair temp1 = spli(x, nowk);
    Npair temp0 = spli(temp1.p[0], nowk - 1);
    if(temp0.p[1] && cnt[temp0.p[1]] > 1) {
        --cnt[temp0.p[1]];
        pushup(temp0.p[1]);
        return merg(merg(temp0.p[0], temp0.p[1]), temp1.p[1]);
    }
    return merg(temp0.p[0], temp1.p[1]);
}

int getrank(const int x, const int nowk) {
	if(!x) return 0;
	if(siz[son[x][0]] < nowk && siz[son[x][0]] + cnt[x] >= nowk)
		return x;
	if(siz[son[x][0]] >= nowk)
		return getrank(son[x][0], nowk);
	return getrank(son[x][1], nowk - siz[son[x][0]] - cnt[x]);
}

int getkey(const int x, const int nowk) {
	int now;
	if(!x) now = 1;
	else if(keyof[x] == nowk) now = siz[son[x][0]] + 1;
	else if(keyof[x] > nowk) now = getkey(son[x][0], nowk);
	else now = getkey(son[x][1], nowk) + siz[son[x][0]] + cnt[x];
	return now;
}

int getpre(const int nowk) {
	int temp = getkey(root, nowk);
	return getrank(root, temp - 1);
}

int getsuc(const int nowk) {
	int temp = getkey(root, nowk);
	int tempd = getrank(root, temp);
	if(keyof[tempd] == nowk)
		return getrank(root, temp + cnt[tempd]);
	else return getrank(root, temp);
}

int main() {
	
	return 0;
}

FHQ_Treap（注释版）

#include<bits/stdc++.h>
using namespace std;

int root;//根
int cnts;//总地址数
int son[100005][2];//son[x][0]左儿子，son[x][1]右儿子
int keyof[100005];//keyof[x]键值
int cnt[100005];//cnt[x]单节点大小
int rd[100005];//rd[x]修正值，根的修正值小
int siz[100005];//siz[x]子树大小

struct Npair
{
    int p[2];
};

void update(int x)
{
	siz[x]=cnt[x]+siz[son[x][0]]+siz[son[x][1]];
}
int newnode(int nowk,int val)
{
	cnts++;
	son[cnts][0]=son[cnts][1]=0;
	siz[cnts]=cnt[cnts]=val;
	keyof[cnts]=nowk;
	rd[cnts]=rand();
	return cnts;
}
Npair spli(int x,int nowk)//按键值分裂，返回两棵树的根
{
    Npair ans;
    ans.p[0]=ans.p[1]=0;
    if(x)
    {
        int d=(keyof[x]<=nowk);
        ans=spli(son[x][d],nowk);
        son[x][d]=ans.p[!d];
        update(x);
        ans.p[!d]=x;
    }
    return ans;
}
int merg(int x1,int x2)//合并，返回新树的根
{
    if(x1==0)
        return x2;
    if(x2==0)
        return x1;
    if(rd[x1]<rd[x2])
    {
        son[x1][1]=merg(son[x1][1],x2);
        update(x1);
        return x1;
    }
    else
    {
        son[x2][0]=merg(x1,son[x2][0]);
        update(x2);
        return x2;
    }
}
int ins(int x,int nowk)//插入
{
    Npair temp1=spli(x,nowk);
    Npair temp0=spli(temp1.p[0],nowk-1);
    if(temp0.p[1])
    {
        cnt[temp0.p[1]]++;
        update(temp0.p[1]);
        return merg(merg(temp0.p[0],temp0.p[1]),temp1.p[1]);
    }
    return merg(merg(temp0.p[0],newnode(nowk,1)),temp1.p[1]);
}
int del(int x,int nowk)//删除
{
    Npair temp1=spli(x,nowk);
    Npair temp0=spli(temp1.p[0],nowk-1);
    if(temp0.p[1] && cnt[temp0.p[1]]>1)
    {
        cnt[temp0.p[1]]--;
        update(temp0.p[1]);
        return merg(merg(temp0.p[0],temp0.p[1]),temp1.p[1]);
    }
    return merg(temp0.p[0],temp1.p[1]);
}
int fkth(int x,int nowk)//返回第k大的点的地址 0表示没找到
{
	if(x==0)
		return 0;
	if(siz[son[x][0]]<nowk && siz[son[x][0]]+cnt[x]>=nowk)
		return x;
	if(siz[son[x][0]]>=nowk)
		return fkth(son[x][0],nowk);
	return fkth(son[x][1],nowk-siz[son[x][0]]-cnt[x]);
}
int fkey(int x,int nowk)//返回同键值最小排名 没找到的话返回假设存在的排名
{
	int now;
	if(x==0)
		now= 1;
	else if(keyof[x]==nowk)
		now= siz[son[x][0]]+1;
	else if(keyof[x]>nowk)
		now= fkey(son[x][0],nowk);
	else
		now= fkey(son[x][1],nowk)+siz[son[x][0]]+cnt[x];
	return now;
}
int pre(int nowk)//返回前驱地址
{
	int temp=fkey(root,nowk);
	return fkth(root,temp-1);
}
int nex(int nowk)//返回后继地址
{
	int temp=fkey(root,nowk);
	int tempd=fkth(root,temp);
	if(keyof[tempd]==nowk)
		return fkth(root,temp+cnt[tempd]);
	else
		return fkth(root,temp);
}

int main()
{
	srand(52331314 + 'T' + 'o' + 'k' + 'i' + 's' + 'a' + 'k' + 'i' + 'K' + 'u' + 'r' + 'u' + 'm' + 'i');
	int n,t,x;
	scanf("%d",&n);
	while(n--)
	{
		scanf("%d%d",&t,&x);
		if(t==1)
			root=ins(root,x);
		if(t==2)
			root=del(root,x);
		if(t==3)
			printf("%d\n",fkey(root,x));
		if(t==4)
			printf("%d\n",keyof[fkth(root,x)]);
		if(t==5)
			printf("%d\n",keyof[pre(x)]);
		if(t==6)
			printf("%d\n",keyof[nex(x)]);
	for (int i = 1; i <= n; ++i)
	}
	return 0;
}

例题

1.普通平衡树

#include<bits/stdc++.h>
using namespace std;

int cnts;//总地址数
int son[100005][2];//son[x][0]左儿子，son[x][1]右儿子
int keyof[100005];//keyof[x]键值
int valof[100005];//valof[x]权值
int rd[100005];//rd[x]修正值，根的修正值小
int siz[100005];//siz[x]子树大小

struct Npair
{
    int p[2];
};

void pushdown(int x)
{
}
void update(int x)
{
	siz[x]=1+siz[son[x][0]]+siz[son[x][1]];
}
int randd()
{
	return (rand()*6666)&rand();
}
int newnode(int nowk,int val)
{
	cnts++;
	son[cnts][0]=son[cnts][1]=0;
	siz[cnts]=1;
	valof[cnts]=val;
	keyof[cnts]=nowk;
	rd[cnts]=randd();
	return cnts;
}
Npair spli(int x,int nowk,bool flag)//分裂，返回两棵树的根，flag表示分裂依据，0按键值1按排名
{
    Npair ans;
    ans.p[0]=ans.p[1]=0;
    if(x)
    {
    	int d;
    	if(flag)
        	d=(siz[son[x][0]]+1<=nowk);
        else
			d=(keyof[x]<=nowk);
		pushdown(x);
		if(flag && d)
        	ans=spli(son[x][d],nowk-siz[son[x][0]]-1,flag);
        else
			ans=spli(son[x][d],nowk,flag);
        son[x][d]=ans.p[!d];
        update(x);
        ans.p[!d]=x;
    }
    return ans;
}
int merg(int x1,int x2)//合并，返回新树的根
{
    if(x1==0)
        return x2;
    if(x2==0)
        return x1;
    if(rd[x1]<rd[x2])
    {
    	pushdown(x1);
        son[x1][1]=merg(son[x1][1],x2);
        update(x1);
        return x1;
    }
    else
    {
    	pushdown(x2);
        son[x2][0]=merg(x1,son[x2][0]);
        update(x2);
        return x2;
    }
}
int ins(int x,int nowk,int val=0)//插入
{
    Npair temp=spli(x,nowk,0);
    temp.p[0]=merg(temp.p[0],newnode(nowk,val));
    return merg(temp.p[0],temp.p[1]);
}
int del(int x,int nowk)//删除
{
    Npair temp1=spli(x,nowk,0);
    int temp=siz[temp1.p[0]]-1;
    Npair temp0=spli(temp1.p[0],temp,1);
    if(keyof[temp0.p[1]]!=nowk)
    	temp0.p[0]=merg(temp0.p[0],temp0.p[1]);
    return merg(temp0.p[0],temp1.p[1]);
}
int fkth(int x,int nowk)//返回第k大的点的地址 0表示没找到
{
	Npair temp1=spli(x,nowk,1);
    Npair temp0=spli(temp1.p[0],nowk-1,1);
    int now=temp0.p[1];
    temp1.p[0]=merg(temp0.p[0],temp0.p[1]);
    merg(temp1.p[0],temp1.p[1]);
    return now;
}
int fkey(int x,int nowk)//返回同键值最小排名 没找到的话返回假设存在的排名
{
	Npair temp=spli(x,nowk-1,0);
    int now=siz[temp.p[0]]+1;
    merg(temp.p[0],temp.p[1]);
    return now;
}
int pre(int x,int nowk)//返回前驱地址
{
	Npair temp1=spli(x,nowk-1,0);
	int temp=siz[temp1.p[0]]-1;
	Npair temp0=spli(temp1.p[0],temp,1);
	int now=temp0.p[1];
	temp1.p[0]=merg(temp0.p[0],temp0.p[1]);
    merg(temp1.p[0],temp1.p[1]);
	return now;
}
int nex(int x,int nowk)//返回后继地址
{
	Npair temp0=spli(x,nowk,0);
	Npair temp1=spli(temp0.p[1],1,1);
	int now=temp1.p[0];
	temp0.p[1]=merg(temp1.p[0],temp1.p[1]);
	merg(temp0.p[0],temp0.p[1]);
	return now;
}

int main()
{
	int n,t,x,root=0;
	scanf("%d",&n);
	while(n--)
	{
		scanf("%d%d",&t,&x);
		if(t==1)
			root=ins(root,x);
		if(t==2)
			root=del(root,x);
		if(t==3)
			printf("%d\n",fkey(root,x));
		if(t==4)
			printf("%d\n",keyof[fkth(root,x)]);
		if(t==5)
			printf("%d\n",keyof[pre(root,x)]);
		if(t==6)
			printf("%d\n",keyof[nex(root,x)]);
	}
	return 0;
}

2.文艺平衡树

#include<bits/stdc++.h>
using namespace std;

stack <int> q;

int son[100005][2];//son[x][0]左儿子，son[x][1]右儿子
int valof[100005];//valof[x]权值
int rd[100005];//rd[x]修正值，根的修正值小
int siz[100005];//siz[x]子树大小
bool flag[100005];//flag[x]翻转标记

struct Npair
{
    int p[2];
};

void change(int x)
{
    if(x)
    {
        int t;
        flag[x]=!flag[x];
        t=son[x][0];
        son[x][0]=son[x][1];
        son[x][1]=t;
    }
}
void pushdown(int x)
{
    if(flag[x])
    {
        change(son[x][0]);
        change(son[x][1]);
        flag[x]=0;
    }
}
void update(int x)
{
	siz[x]=1+siz[son[x][0]]+siz[son[x][1]];
}
int randd()
{
    int x=(rand()*6666)&rand();
	return x;
}
Npair spli(int x,int nowk)//按排名分裂，返回两棵树的根
{
    Npair ans;
    ans.p[0]=ans.p[1]=0;
    if(x)
    {
    	int d;
    	d=(siz[son[x][0]]+1<=nowk);
		pushdown(x);
		if(d)
        	ans=spli(son[x][d],nowk-siz[son[x][0]]-1);
        else
			ans=spli(son[x][d],nowk);
        son[x][d]=ans.p[!d];
        update(x);
        ans.p[!d]=x;
    }
    return ans;
}
int merg(int x1,int x2)//合并，返回新树的根
{
    if(x1==0)
        return x2;
    if(x2==0)
        return x1;
    if(rd[x1]<rd[x2])
    {
    	pushdown(x1);
        son[x1][1]=merg(son[x1][1],x2);
        update(x1);
        return x1;
    }
    else
    {
    	pushdown(x2);
        son[x2][0]=merg(x1,son[x2][0]);
        update(x2);
        return x2;
    }
}
void out(int x)
{
    pushdown(x);
    if(son[x][0])
        out(son[x][0]);
    printf("%d ",valof[x]);
    if(son[x][1])
        out(son[x][1]);
}
void ask(int x)
{
    if(!x)
        return;
    ask(son[x][0]);
    ask(son[x][1]);
    update(x);
}
int swaps(int x,int l,int r)
{
    Npair temp1=spli(x,r);
    Npair temp0=spli(temp1.p[0],l-1);
    change(temp0.p[1]);
    temp1.p[0]=merg(temp0.p[0],temp0.p[1]);
    return merg(temp1.p[0],temp1.p[1]);
}
int main()
{
	int root,temp,n,m,l,r;
	scanf("%d%d",&n,&m);
	q.push(0);
	rd[0]=-1;
	for(int i=1;i<=n;i++)
    {
        valof[i]=i;
        rd[i]=randd();
        temp=0;
        while(rd[i]<rd[q.top()])
        {
            temp=q.top();
            q.pop();
        }
        son[q.top()][1]=i;
        son[i][0]=temp;
        q.push(i);
    }
    root=son[0][1];
    son[0][1]=0;
    ask(root);
    while(m--)
    {
        scanf("%d%d",&l,&r);
        root=swaps(root,l,r);
    }
    out(root);
	return 0;
}

 

33457
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Treap模板
qq_42722211的博客
07-29 166
一个新的Treap板子 先放代码 #include<cstdio> #include<cctype> #include<algorithm> #include<functional> template<typename _Tp,typename _Cmp=std::less<_Tp> > class fhq_treap:_Cmp { public: typedef _Tp Value_type;
Treap模板（旋转）
Dream in the Night
08-28 366
目前见过作为名次树的实现，其他暂时没见过←_← #include #include #include #include #include #include #include #include #include #include #include using namespace std; #define ll long long #define ull unsigned long long #de
treap模板
SCUEC__zhazhahui的博客
09-12 161
treap模板 满足二叉排序树性质 功能：插入以及删除x，查找名次为x的数，查找x的排名，查找x的前驱和后继 #include <iostream> using namespace std; struct data { int l , r , v , rnd , size , w ;//左右孩子的编号，结点的值，随机值用于维护堆，结点的值的个数 }; data tr[100...
P3369 普通平衡树模板 treap
JZK-Keven 的博客
12-07 174
https://www.luogu.com.cn/problem/P3369 treap和bst（二叉查找树）的区别就在于 treap 给了每个节点一个随机的权值，在插入的时候，通过该权值使整棵树依然维持一个大根堆/小根堆的形式（使用左旋和右旋方式来完成），在删除的时候，通过将该点旋转到叶子结点后再删除。 代码参考 <算法竞赛进阶指南> //https://www.luogu....
FHQ Treap模板
蒟蒻Steven_Meng的博客
07-10 175
#include <bits/stdc++.h> #define MAXN 500005 using namespace std; inline int read() { int x=0,f=1; char ch=getchar(); while (ch<'0'||ch>'9') { if (ch=='-') f=-1; ...
Treap
wsyear的博客
03-02 370
Treap=Tree+Heap,介绍Treap思路及常用操作
无旋treap/fhq-treap 模板 （附良心讲解 + 例题：洛谷P3369 普通平衡树）
shadiao.的博客
09-09 705
博文更新： 20190917 更新了一下merge和split函数的递归理解 定义： 无旋treap，就是不通过旋转的维护堆性质的treap，根本的原理还是 tree + heap。 与普通treap的不同之处： 大概就是可以可持久化。 然后区间操作的话，不知道有旋的行不行，用无旋的反正是比较好搞，区间操作举个例子就是让你把一段区间的数反过来等等。 现在听着可能区间操作什么的可能莫名...
模板 - FHQ - treap 无旋平衡树
繁凡さん的博客
08-21 681
整理的算法模板合集： ACM模板 #include<bits/stdc++.h> using namespace std; const int N = 100007; int n, m, tot, root; struct node{ int l, r; int key;//权值 int val;//平衡因子 int size;//子树个数 }tr[N]; void pushup(int p){ tr[p].size = tr[tr[p].l]
Treap实现名次树+模板+模板题
Q755100802的博客
05-16 303
Treap的几大基本操作： Kth(k):寻找第k小的数 Rank(x):值x的“名次”，即比x小的节点个数+1 pre(x)，寻找比x小的数中最大的数 next(x)，寻找比x大的数中最小的数 Treap可以说是一个劣质版的set<int>，实质上是一个树堆，对于值来说是一颗排序二叉树，对于优先级来说是一个优先堆。 基本的作用就是寻找k小数，和k的，名次。 刘汝佳大神版的...
Python 数据结构：字典与集合的详细对比
08-31 511
在 Python 编程语言中，字典（dictionary）和集合（set）是两种非常核心且功能强大的数据结构。它们在处理数据时扮演着不同的角色，了解它们的区别对于编写高效、清晰的代码至关重要。本文将详细介绍字典和集合的特点、用法以及何时使用它们。
数据结构
2301_80184169的博客
08-28 563
4.执行代码,复现段错误,产生包含出错信息的core文件(检查core文件是否生成)3.ulimit -c unlimited 不限制core文件的生成的大小。使用这种方法能够很好的解决段错误，在纠正和优化代码时效率显著提升。1.首先按照如下的方法配置Ubuntu，允许生成core文件。5.gdb a.out core 查看段错误产生的位置。2.重新编译代码并加入-g选项(允许进行GDB调试)
数据结构（邓俊辉）学习笔记】串 10——BM_BC算法：坏字符
weixin_44399845的博客
08-28 863
BM_BC算法：坏字符
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 865
数组，双链表实现队列，附完整代码
【手撕数据结构】二叉树的性质
最新发布
apple_61439616的博客
08-31 248
目录叶子节点和边的性质概念小试牛刀 叶子节点和边的性质 概念 可以看到度为0的节点如F没有边，度为1的节点如C有一条边，而度为2的节点如B有两条边。 那么设度为2的节点为a个，度为1的节点为b个。二叉树边 = 2a+b 另⼀⽅⾯，由于共有 a+b+c 个节点，所以边数等于 a+b+c-1 这里-1是因为： 综合上面两个公式，我们2a+b = a + b + c - 1; 推出c = a+1(c为度为0节点，a为度为2节点) 所以叶子结点n0 = n2 + 1; 小试牛刀 这道题已经告诉了我们度
Java-数据结构-包装类和认识泛型 !!!∑(ﾟДﾟノ)ノ
2303_80388948的博客
08-27 1199
对于泛型就是：使用与许多许多类型。从代码上来说呢，就是对类型实现了参数化。对于引出泛型，我们来实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。在这里呢，我们用 Object类 来进行创建数组，Object是所有类的父类，但是呢，我们在这里呢就有一些问题，我们来看看：1、在这里呢，我们这个数组当中可以存放任何类型2、我们每次进行的到值时候呢，都要进行强转。
数据结构—链表
2301_79909332的博客
08-27 753
数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。数据量增长与程序所占用空间的比例关系称为空间复杂度。顺序表、链式表、顺序栈、链式栈、顺序队列、链式队列 、树 二叉树。使用该函数遍历顺序表内元素，符合条件的可对其进行计数和打印。使用该函数遍历顺序表内元素，符合条件的对其进行修改。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。1.空间可以不连续，访问元素不方便。3.程序 = 数据结构 + 算法。4.链表的插入和删除效率很高。
集合及数据结构第十三节（下）———— 枚举与Lambda表达式
2301_79418684的博客
08-27 1193
枚举与枚举的使用 1. 什么是C语言 2. 数据类型 3. 变量、常量 4. 字符串+转义字符+注释 5. 选择语句 6. 循环语句 7. 函数 8. 数组 9. 操作符 10. 常见关键字 11. define 定义常量和宏 12. 指针 13. 结构体
Java算法之插入排序（Insertion Sort）
weixin_38959316的博客
08-29 302
插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。这个过程像打牌时整理手中的牌一样，逐步将数据排列成有序。插入排序虽然在实际应用中的效率不如一些更高级的排序算法，但它的原理简单，易于实现，且对于部分有序的数据集表现良好。
数据结构（邓俊辉）学习笔记】串 06——KMP算法：构造next[]表
weixin_44399845的博客
08-27 762
KMP算法：构造next[]表
Treap数据结构详解：操作与应用
"Treap是一种平衡二叉查找树，结合了树和堆的特性，用于高效的数据操作，如插入和删除。它通过随机化的优先级保证平衡性，从而实现平均情况下的优秀性能。本文深入探讨了Treap的原理、构建方法、特点以及在信息学...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值