kkzzjx

数据结构基础应试手册1.0

《数据结构期末基础应试手册》

本手册（一座屎山）仅限用于个人应试

author：kkzzjx

date：2020/7/3

文章目录

《数据结构期末基础应试手册》
链表

链表
顺序表

栈和队列
串

KMP算法

理论考试总结
二叉树建立，遍历
二叉搜索树
哈夫曼树编码译码
习题

求哈夫曼树带权路径长度（利用了堆
统计二叉树中的叶子结点数（树的顺序存储
求二叉树高度

图论

理论考试总结
建图：邻接矩阵&邻接表&DFS&BFS
最小生成树

Prim
Kruskal

最短路径

单源最短路：Djikstra
多源最短路：Floyd

AOE 网络

拓扑排序 Topsort

AOE 网络

拓扑排序Topsort

习题1

哈希表

理论考试总结

排序算法

归并排序
快速排序
排序算法的总结（考点）
习题
动态规划和贪心算法（具体略）
0-1背包问题（略）
排序算法的总结（考点）
习题
动态规划和贪心算法（具体略）
0-1背包问题（略）

网盘自取链接：链接：https://pan.baidu.com/s/13F-kjbI_miJwdaXrD2z15A
提取码：flyq

链表

#include
#include
typedef struct node *List;
struct node
{
	int data;
	List next;
};

List creat1()
{
	int k;
	List s,head;
	List L=(List)malloc(sizeof(struct node));
	L->next=NULL;
	head=L; 
	printf("please enter list until -1");
	while(1)
	{
		scanf("%d",&k);
		if(k==-1) break;
		else
		{
			s=(List)malloc(sizeof(struct node));
			s->data=k;
			s->next=L->next;
			L->next=s;
		}
	}
	return head;
}

List creat2()
{
	int k;
	List s,r,head;
	List L=(List)malloc(sizeof(struct node));
	L->next=NULL;
	head=L;
	r=L;
	printf("please enter list until -1\n");
	while(1)
	{
		scanf("%d",&k);
		if(k==-1) break;
		else
		{
			s=(List)malloc(sizeof(struct node));
			s->data=k;
			r->next=s;
			r=s;
		}
	}
	r->next=NULL;
	return head;
}
int length(List L)
{
	List p=L;
	int num=0;
	while(p->next!=NULL)
	{
		num++;
		p=p->next;
	}
	
	return num;
}
List findKth(List L,int k)//查找位序为i 
{
	List p=L->next;
	int cnt=1;
	while(p!=NULL&&cnt!=k)
	{
		p=p->next;
		cnt++;
	}
	if(p) return p;//此处返回的是指针，，也可以返回值p->data 
	else return NULL;
}

List find(List L,int x)//查找值为x 
{
	List p=L->next;
	while(p!=NULL&&p->data!=x)
	{
		p=p->next;
	}
	if(p->data==x) return p;
	else return NULL;
}

List insert(List L,int x,int i) //位置i处插入x 
{
	List p,s;
	if(i<=0||i>length(L)+1)
	{
		printf("error\n");
		return NULL;
	}
	else
	{
		s=(List)malloc(sizeof(struct node));
		p=findKth(L,i-1); //找到前驱结点
		s->data=x;
		s->next=p->next;
		p->next=s;
		printf("success"); 
		return L;
	}

}

List delete0(List L,int i) //删除位序i的元素  或者根据元素删...种类好多啊 
{
	List tmp=L;
	if(i<=0||i>length(L))
	{
		printf("error\n");
		return NULL;
	}
	else  //关键容易bug的地方 当i取1时要分开考虑，让2号位接到head后面 
	{	
		List s=findKth(L,i);
		if(i!=1)
		{
		List p=findKth(L,i-1);
		p->next=s->next;
		free(s);
		}
		else if(i==1)
		{
			tmp->next=s->next;
			free(s);
		}
	}
	return L;
}

void output(List L)
{
	List p=L->next;
	while(p)
	{
		printf("%d ",p->data);
		p=p->next;
	}
	printf("\n");
}

int main()
{
	int k,i;
	List L=creat2();
	output(L);
	printf("插入元素k=");
	scanf("%d",&k);
	printf("插入位置i=");
	scanf("%d",&i);
	L=insert(L,k,i);
	output(L);
	printf("删除位置i=");
	scanf("%d",&i);
	L=delete0(L,i);
	output(L);
}

顺序表

#include
#include
#define MAXSIZE 100
struct SqListNode{
	char data[MAXSIZE];//此处的datatype为char 
	int last;/*last为数组下标，而length为线性表长度 length=last+1
			  注意在查找的时候用的是位序 ，不是数组下标 */ 
};
typedef  struct SqListNode *List;

List creat()
{
	int i=0;
	char ch;
	List L=(List)malloc(sizeof(struct SqListNode));
	L->last=-1;
	printf("请输入顺序表L中元素，以#结束\n" );
	while((ch=getchar())!='#')
	{
		L->data[i++]=ch;
		L->last++;
	}
	return L;
}

void insert(List L,char x,int i)
{
	//注意插入时的溢出情况和位置不合法情况
	int j;
	if((L->last)>=MAXSIZE-1)
	{
		printf("overflow\n");
	 }
	 else if(i<1||i>(L->last)+2)
	 {
	 	printf("error\n");
	  }
	  else
	  {
	  	for(j=L->last;j>=i-1;j--) //数组元素向后退 
	  	{
	  		L->data[j+1]=L->data[j]; 
		}
		L->last++;
		L->data[i-1]=x;
		printf("success\n");
	   } 
}
void output(List L)
{
	int i;
	for(i=0;i<=L->last;i++)
		printf("%c",L->data[i]);
	printf("\n");
}

int main()
 {
 	char ch;
 	int i=0;
 	List L=creat();
 	output(L);
	printf("INPUT ch:\n");
	ch=getche();
	printf("\nINPUT position:\n");
	scanf("%d",&i);
	insert(L,ch,i);
	output(L);
 }

栈和队列

这个直接利用C++的stl库即可

#include

using namespace std;

stack s;

queue q;

串

KMP算法

#include
#include
#include
using namespace std;
int kmp(char S[],char T[],int next[])
{
	int i=1,j=1;
	while(i<=strlen(S)&&j<=strlen(T))
	{
		if(j==0||S[i]==T[j])  
		{
			++i;++j;
		}
		else
			j=next[j];
	}
	int tmp;
	if(j>strlen(T))
	{
		tmp=i-strlen(T);
		return tmp;
	}
	else return 0;
}

void getnext(char T[],int next[])
{
	int i=1,j=0;
	next[1]=0;
	while(i<strlen(T))
	{
		if(j==0||T[i]==T[j])
		{
			i++;j++;
			next[i]=j;
		}
		else
		{
			j=next[j];
		}
	}
}

int main()
{
	//char s[100]="abcabcad";
	char s[100];
	int i=0;
	gets(s);
    
	char t[100]="cad";
	int next[1000]={0};
	getnext(t,next);
	int k=kmp(s,t,next);
	printf("%d",k);
}

树

理论考试总结

一、树的概念

结点的度

树的度

树的深度

兄弟

堂兄弟

森林

满二叉树深度k 有2^k-1个结点

完全二叉树

二、二叉树性质
$1.第i层至多有2^i/2个结点\\ 2.深度为k的二叉树至多有2^k-1个结点\\ 3.对任何一棵二叉树，如果终端结点数n_0,度为2的结点数n_2 则n_0=n_2+1\\ 证明\\ 4.n个结点的完全二叉树深度log_2n+1 或 log（n+1）$

三、二叉树遍历

递归&&非递归（栈

层序遍历（队列

四、应用之表达式

中缀表达式：普通~~

前缀表达式；后~

五、利用两种遍历序列确定二叉树：必须要有中序遍历

六、哈夫曼树WPL的计算

七、哈夫曼树的构造，哈夫曼编码

八、树、森林和二叉树之间的转换

1.一棵树转换为二叉树

2.一棵二叉树转换为树

左孩子的所有右孩子都与根连起来

3.森林转二叉树

森林中每一棵树转为二叉树

习题：

一棵度为2的树与一棵二叉树有何区别?

1.度为2的树是不区分左子树和右子树.而二叉树是要分左子树和右子树的.

2.度为2的数不包含空树,而二叉树是可以有空树的. 总之,二叉树的定义要比度为2的树定义更为严格,更为详细.

二叉树建立，遍历

#include 
#include 
using namespace std;
typedef struct TNode *bintree;
struct TNode
{
	int data;
	bintree left, right;
};

void preorder(bintree t)
{
	if (t)
	{
		visit(t);
		preorder(t->left);
		preorder(t->right);
	}
}

void inorder(bintree t)
{
	if (t)
	{
		inorder(t->left);
		visit(t);
		inorder(t->right);
	}
}

void postorder(bintree t)
{
	if (t)
	{
		postorder(t->left);
		postorder(t->right);
		visit(t); //printf("%d",t->data);
	}
}
/*------------以上为递归遍历*/
//非递归
void inorder2(bintree t)
{
	stack<int> s;
	bintree p = t;
	while (p || !s.empty())
	{
		if (p)
		{
			s.push(p);
			p = p->left;
		}
		else
		{
			printf("%d", s.top());
			s.pop();
			p = p->right;
		}
	}
}

//LevelOrder
void levelorder(bintree BT)
{
	bintree T;
	queue<bintree> q;
	if (!BT)
		return;
	q.push(BT);
	while (!q.empty())
	{
		T = q.front();
		q.pop();
		printf("%d", T->data);
		if (T->left)
			q.push(T->left);
		if (T->right)
			q.push(T->right);
	}
}
void levelorderprint(bintree BT)
{
	bintree T;
	queue<bintree> q;
	q.push(BT);
	while (!q.empty())
	{
		T = q.front();
		q.pop();
		printf("%d ", T->data);
		if (T->left)
			q.push(T->left);
		if (T->right)
			q.push(T->right);
	}
}
#define NoInfo -1;
bintree creat() //enter data until -1
{
	int data;
	bintree BT, T;
	queue<bintree> q;

	scanf("%d", &data);
	if (data != NoInfo)
	{
		BT = (bintree)malloc(sizeof(struct TNode));
		BT->data = data;
		BT->left = NULL;
		BT->right = NULL;
		q.push(BT);
	}
	else
		return NULL;

	while (!q.empty())
	{
		T = q.front();
		q.pop();
		scanf("%d", &data);
		if (data == NoInfo)
			T->left = NULL;
		else
		{
			T->left = (bintree)malloc(sizeof(struct TNode));
			T->left->data = data;
			T->left->left = NULL;
			T->left->right = NULL;
			q.push(T->left);
		}
		scanf("%d", &data);
		if (data == NoInfo)
			T->right = NULL;
		else
		{
			T->right = (bintree)malloc(sizeof(struct TNode));
			T->right->data = data;
			T->right->left = NULL;
			T->right->right = NULL;
			q.push(T->right);
		}
	}
	return BT;
}

二叉搜索树

#include 
#include
#include
using namespace std;
/*二叉搜索树*/
typedef struct TNode *Bintree;
struct TNode{
	int data;
	Bintree left,right;
}; 

Bintree insert(Bintree BST,int x)
{
	if(!BST)
	{
		BST=(Bintree)malloc(sizeof(struct TNode));
		BST->data=x;
		BST->left=BST->right=NULL;
	}
	else
	{
		if(x<BST->data) insert(BST->left,x);
		else if(x>BST->data) insert(BST->right,x);
	}
	return BST;
}

Bintree Findmin(Bintree BST)
{
	if(BST)
	{
		while(BST->left)
		{
			BST=BST->left;
		}
	}
	return BST;
}

Bintree deletex(Bintree BST,int x)
{
	Bintree tmp;
	if(!BST)
	{
		printf("要删除的元素未找到");
	}
	else
	{
		if(x<BST->data) deletex(BST->left,x);
		else if(x>BST->data) deletex(BST->right,x);
		else
		{
			if(BST->left!=NULL||BST->right!=NULL)
			{
				tmp=Findmin(BST);
				BST->data=tmp->data;
				BST->right=deletex(BST->right,BST->data);
			}
			else
			{
				tmp=BST;
				if(!BST->left) BST=BST->right;
				else BST=BST->left;
				free(tmp);
			}
		}
	 }
	 return tmp;
}

void LevelOrderTraversal(Bintree BT){
	queue<Bintree> q;
	Bintree T;
	if(!BT)
		return;
	q.push(BT);  // BT 入队 
	while(!q.empty()){
		T = q.front();  // 访问队首元素 
		q.pop();  // 出队
		printf("%d",T->data);
		if(T->left)
			q.push(T->left);
	 	if(T->right)
	 		q.push(T->right);
	}
}
int main()
{
	Bintree BST;
	BST=insert(BST,21);
	BST=insert(BST,18);
	BST=insert(BST,37);
	BST=insert(BST,42);
	BST=insert(BST,65);
	BST=insert(BST,24);
	BST=insert(BST,19);
	BST=insert(BST,26);
	BST=insert(BST,45);
	BST=insert(BST,25);
	BST=deletex(BST,37);
	LevelOrderTraversal(BST);
}

哈夫曼树编码译码

（xdu版本）

typedef struct{
	char bits[N];
	int start;
	datatype data;
}codetype;
codetype code[N];

typedef struct{
	float weight;
	datatype data;
	int left,right,parent;
} huffman;

void enc(codetypde code[],huffman tree[])
{
	int i,c,p;
	codetype cd;
	for(i=0;i<N;i++)
	{
		cd.start=N;
		c=i;//c存走过的孩子 
		p=tree[c].parent;
		while(p!=-1)
		{
			cd.start--;
			if(tree[p].left==c)
				cd.bits[cd.start]='0';
			else
				cd.bits[cd.start]='1';
				
			c=p;//往上移动 
			p=tree[c].parent;//往上移动 
		}
		code[i]=cd; 
	}
}

void dec(codetype code[],huffman tree[])
{
	int i,c,m,b;
	int endflag=-1;
	i=m-1;  //此时i是根节点 
	scanf("%d",&b);//读入一个代码 
	while(b!=endflag)
	{
		if(b==0)
			i=tree[i].left;
		else
			i=tree[i].right; 
		if(tree[i].left==-1)
		{
			putchar(code[i].data);
			i=m-1;
		}
		scanf("%d",&b);
	}
	if(tree[i].left!=0&&i!=m-1) printf("ERROR");
}

习题

https://blog.csdn.net/qq_39679772/article/details/106853322

求哈夫曼树带权路径长度（利用了堆

时间限制: 1 秒
内存限制: 256KB

问题描述
假设用于通信的电文由ｎ个字符组成，字符在电文中出现的频度（权值）为w1,w2,…,wn，试根据该权值序列构造哈夫曼树，并计算该树的带权路径长度。

输入说明
第１行为ｎ的值，第２行为ｎ个整数，表示字符的出现频度。

输出说明
输出所构造哈夫曼树的带权路径长度。

输入样例
8
7 19 2 6 32 3 21 10

输出样例
261

思路：
选2个最小的跳出容器，然后和进容器，把和加载wpl值上。
然后啊这，C++最小堆竟然过不了= =
error C2065: “greater”: 未声明的标识符
解决方案：在头文件中加入#include即可解决

#include
#include
#include
using namespace std;
priority_queue<int ,vector<int> ,greater<int> > q;//最小堆 第三个参数 less 最大堆

int main()
{
	int n,wpl=0,i,t[1000];
	int a,b;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		scanf("%d",&t[i]);
		q.push(t[i]);
	}
	while(q.size()>=2)
	{
		a=q.top();q.pop();
		b=q.top();q.pop();
		q.push(a+b);
		wpl=wpl+a+b;	
	}
	//author:kkzzjx
	printf("%d",wpl);
}

统计二叉树中的叶子结点数（树的顺序存储

时间限制: 1 秒
内存限制: 256KB

问题描述
建立二叉链表，统计二叉树中的叶子结点数并输出。

输入说明
按照完全二叉树的形式输入二叉树的各结点数据(字符)，其中虚结点用’@‘表示。输入以’#'结束。

输出说明
输出叶子结点的个数及具体值。第一行为叶子结点的数据值，各数据用空格分隔，第二行为叶子结点的个数。

输入样例
abc@@de#

输出样例
b d e
3

#include

int main()
{
	char tree[1000];
	char ch;
	scanf("%c",&ch);
	int i=1,j,s,cnt=0;
	
	for(j=1;j<1000;j++) //全赋值为@ 
	{
		tree[j]='@';
	}
	
	while(ch!='#')
	{//author:kkzzjx
		tree[i]=ch;
		scanf("%c",&ch);
		i++;
	}
	s=i;
	for(i=1;i<s;i++)
	{
		if(tree[i]!='@'&&tree[i*2]=='@'&&tree[i*2+1]=='@')
		{
			printf("%c ",tree[i]);
			cnt++;
		}
	}
	//author:kkzzjx
	printf("\n%d",cnt);
}

求二叉树高度

int GetHeight(Bintree BT)
{
    int HL,HR,MaxH;
    if(BT)
    {
        HL=GetHeight(BT->left);
        HR=GetHeight(BT->right);
        MaxH=HL>HR?HL:HR;
        return(MaxH+1)
    }
    else return 0;//空树高度0
}

图论

理论考试总结

一、写出n与e关系

1.完全无向图

2.完全有向图

3.稀疏图

4.稠密图

二、概念解释

1.度=出度+入度 e=∑D(Vi)/2

2.网络

3.路径简单路径

4.简单回路/简单环

5.有根图

6.连通图

7.连通分量

8.强连通，强连通图，强连通分量------都是指有向图

三、图的存储方法

1.邻接矩阵，邻接表

考点：画出xx的邻接矩阵，画出xx邻接表

有向图：边表

无向图：邻接表/出边表，逆邻接表/入边表

2.特点

判定是否为边，求边的数目

3.遍历

考点：写出某个图DFS/BFS的结果

BFS要用到队列：对于连通图，队列为空即遍历结束；对于非连通图，队列为空且图的所有节点都被遍历才结束

四、图的应用

（一）概念解释

1.生成树

2.最小生成树Minimum Spanning Tree MST

3.MST性质

*4.Prim算法

O（n^2) 与边数无关，是和边稠密网络

通俗地说：找一条边，离已经生成的树最近的那条边

*5.Kruskal算法

O（eloge）与边数有关，适合稀疏网络

通俗地说：初始把每个点都看作不同的连通分量，随着边的加入，有些成为了同一连通分量。

每次找顶点在不同连通分量上的最小边即可。构造出的树不唯一。

6.考查方式：写出prim，kruskal的过程

（三）概念解释2

1.源点source，终点destination

2.最短路径

一是从某个源点到其余各顶点的最短路径

二是每一对顶点之间的最短路径

Dijkstra算法–单源最短路O(n^2)

考法：

①dist[]数组的变化过程，最短距离数组；path[i]存放的是顶点i的前趋结点；sign[n]记录最短路径生成情况，0表示最短路径还未产生

d，p，s数组变化过程

②求某点到其他各点的最短路径

③如果最后的路径长度还有无穷，说明非连通图

Floyd算法–多源最短路O(n^3)

dist[i][j]

（Vi,Vj)

(Vi,Vk,Vj)

path[i][j]保存的是Vi到Vj时，Vj的前趋结点

(四)概念解释3

1.AOV网 activity on vertex network

顶点表示活动，有向边表示活动间的先后关系的有向图

AOV网不可能存在有向环

2.拓扑序列

3.拓扑排序：入度为0的顶点输出 O(n+e)

4.可以判断图中有无环：网中顶点未被全部输出，剩余的顶点入度均不为0，说明存在有向环

5.AOE网络结点表示状态，边表示活动的带权有向网络；

特点：只有一个入度为0的顶点（源点），一个出度为0的顶点（汇点）

应用：解决最短工期问题等

6.关键路径 O(n+e)

7.最早发生时间e（i）

8.最迟发生时间

9.最迟开始时间l（i）

10.关键活动 l(i)=e(i),关键路径

习题：

判定一个有向图是否存在回路：拓扑排序或DFS

1.最终一定会有度不为0的点

2.用dfs，沿着路径搜索，如果重复回到了已经搜索过的路径，就说明出现了环

求强连通分量

建图：邻接矩阵&邻接表&DFS&BFS

最简单的邻接矩阵建图法及其DFS，BFS

#include
#include
#define MAXN 100
int G[MAXN][MAXN],Nv,Ne;

void BuildGraph(){
	int i,j,v1,v2,w;
	
	scanf("%d",&Nv);
	// 初始化图 
	for(i=0;i<Nv;i++) 
		for(j=0;j<Nv;j++)
			G[i][j] = 0;
	scanf("%d",&Ne);
	// 插入边 
	for(i=0;i<Ne;i++){
		scanf("%d %d %d",&v1,&v2,&w);
		G[v1][v2] = w;
		G[v2][v1] = w;
	}
}


// 遍历图
void print(){
	int i,j;
	for(i=0;i<Nv;i++){
		for(j=0;j<Nv;j++)
			printf("%d ",G[i][j]);
		printf("\n");
	}
} 

int main(){
	BuildGraph();
	print();
	return 0;
}

邻接表

#include
#include
#include
using namespace std;
#define MaxVertexNum 100
typedef struct AdjVNode *AdjList;
struct AdjVNode{
	int weight;  // 权值 
  	int adjv;   // 下标 
	AdjList next;  // 其后一个 
};
AdjList Graph[MaxVertexNum];//全局变量了
int Ne,Nv;

// 建图
void BuildGraph(){
	int i;
	int v1,v2,w;
	AdjList NewNode;
	scanf("%d",&Nv);
	for(i=0;i<Nv;i++){//初始化
		Graph[i] = (AdjList)malloc(sizeof(struct AdjVNode));
		Graph[i]->adjv = i;
		Graph[i]->next = NULL;
	}
	scanf("%d",&Ne);
	for(i=0;i<Ne;i++){//加入边
		scanf("%d %d %d",&v1,&v2,&w);
		NewNode = (AdjList)malloc(sizeof(struct AdjVNode));
		NewNode->adjv = v1;
		NewNode->weight = w;
		
		NewNode->next = Graph[v2]->next;//链表的头插
		Graph[v2]->next = NewNode;
		//这里是个无向图，有向图的话把上面5行删除即可
		NewNode = (AdjList)malloc(sizeof(struct AdjVNode));
		NewNode->adjv = v2;
		NewNode->weight = w;
		
		NewNode->next = Graph[v1]->next;
		Graph[v1]->next = NewNode;
	}
} 

void print(){
	AdjList tmp;
	int i;
	for(i=0;i<Nv;i++){
		tmp = Graph[i];
		while(tmp){
			printf("%d ",tmp->adjv);
			tmp = tmp->next;
		}
		printf("\n");
	}
}


void DFS(int i)
{
	bool visited[MaxVertexNum];
	AdjList p;
	visited[i]=true;
	p=Graph[i];
	printf("%d ",Graph[i]->adjv);
	while(p)
	{
		if(!visited[p->adjv])
			DFS(p->adjv);
		p=p->next;
	}
}


void BFS(int i)
{
	queue<int> q;
	int temp;
	bool visited[MaxVertexNum];
	AdjList p;
	printf("%d",i);
	q.push(i);
	while(!q.empty())
	{
		temp=q.front();
		q.pop();
		for(p=Graph[temp];p!=NULL;p=p->next)
		{
			if(!visited[p->adjv])
			{
				visited[p->adjv]=true;
				printf("%d ",p->adjv);
				q.push(p->adjv);
			}
		}
	}
}


int main(){
	
	BuildGraph();
	print();
	DFS(0);
	BFS(0);
	return 0;
}

最小生成树

Prim

方法1：

//最小生成树Prim算法
//Prim算法适合稠密图，因此用邻接矩阵存储
#include 
#include 
#define N 4
#define E 4
using namespace std;
struct graph
{
    char vex[N];
    int arc[N][N];
};
typedef struct graph *Graph;

Graph creatGraph() //也可以提前输入N,E
{
    Graph G = (Graph)malloc(sizeof(struct graph));
    int i, j, k;
    float weight;
    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
            G->arc[i][j] = 100000;
        }
    }
    printf("请输入结点的内容：\n");
    for (i = 0; i < N; i++)
    {
        scanf("%c", &G->vex[i]);
    }
    printf("请依次输入起点，终点和权值：\n");
    for (k = 0; k < E; k++)
    {
        scanf("%d %d %d", &i, &j, &weight);
        G->arc[i][j] = weight;
        G->arc[j][i] = weight;
    }
    return G;
}

typedef struct
{
    int start, end;
    float weight;
} edge;

edge T[N - 1]; //T存放的是边信息

void Prim(int i, Graph G) //i为选取的第一个顶点的下标，最终结果存在T[N-1]中
{
    int j, k, m, v, min, max = 100000;
    int path[N]; //存放路径信息
    path[i] = -1;
    edge e;
    v = i;
    for (j = 0; j < N - 1; j++) /*循环就是建立好第1个结点和其他各点的边
                                （注意：此图中，两边无联系需要设置为无穷*/
    {
        T[j].start = v;
        if (j >= v)
        {
            T[j].end = j + 1;
            T[j].weight = G->arc[v][j + 1];
        }
        else
        {
            T[j].end = j;
            T[j].weight = G->arc[v][j];
        }
    }
    for (k = 0; k < N - 1; k++) //第k条边,前面k-1都处理好了，so T[k-1]以前的已经存放最小了。
    {
        min = max;
        for (j = k; j < N - 1; j++)
        {
            if (T[j].weight < min&& T[j].weight!=0)
            {
                min = T[j].weight;
                m = j; //最小边的下标存在m里面
            }
        
        e = T[m]; //e是交换的中间变量,交换两条边
        T[m] = T[k];
        T[k] = e; //将最短的边存放到T[k]单元

        v = T[k].end; //v中存放找到的最短边在V-U中的顶点
        float d;
        for (j = k + 1; j < N - 1; j++)
        {
            d = G->arc[v][T[j].end]; //其实这个写法真的很妙啊，T[x].end里面都是没有访问过的点
            if (d < T[j].weight)
            {
                T[j].weight = d;
                T[j].start = v;
            }
        }
    }
    }
}
int main()
{
    int i;
    Graph G = creatGraph();
    Prim(0, G);
    for (i = 0; i < N; i++)
    {
        printf("%d %d %d %.1f\n", i, T[i].start, T[i].end, T[i].weight);
    }
}

方法2：

/*
void prim()
{
    MSF{};
    while(1)
    {
        v=未收入顶点中dist最小者//dist是指顶点Vj到树的最小距离
        if(v不存在)
            break;
        for(v的每个邻接点w)
        {
            if(w未被收录)
            {
                if(E 
                    parent[w]=v;//并查集？可以用来存路径
                }
            }
        }
    }
}
*/

#include 
#include 
#define INF 100000
#define MaxVertex 105
int G[MaxVertex][MaxVertex];
int parent[MaxVertex]; // 并查集 ，可以得到path，如果设立了这个，那么parent[0]=-1 0位置要空出来
int dist[MaxVertex];   // 距离 一点离树的距离的最小值
int Nv;                // 结点数
int Ne;                // 边数
int sum;               // 权重和
using namespace std;
vector<int> MST; // 最小生成树 存放里面已经有的结点

void build()
{
    printf("请输入结点数、边数\n");
    scanf("%d %d", &Nv, &Ne);
    int i, j, k;
    int weight;
    for (i = 0; i < Nv; i++)
    {
        for (j = 0; j < Nv; j++)
        {
            G[i][j] = INF;
        }
        dist[i] = INF;  //距离初始化
        parent[i] = -1; //并查集初始化
    }
    printf("请输入边 起点，终点，权值\n");
    for (k = 0; k < Ne; k++)
    {
        scanf("%d %d %d", &i, &j, &weight);
        G[i][j] = weight;
        G[j][i] = weight;
    }
}

void IniPrim(int s) //prim算法前的初始化,树从s点开始生长
{
    dist[s] = 0; //初始点s收入MST
    int i;
    MST.push_back(s);
    for (i = 0; i <= Nv; i++)
    {
        if (G[s][i] < INF)
        {
            dist[i] = G[s][i]; //s点的邻接点
            parent[i] = s;
        }
    }
}

int FindMin() //查找未收录的点中dist最小的点
{
    int min = INF;
    int v = -1;
    for (int i = 0; i < Nv; i++)
    {
        if (dist[i] != 0 && dist[i] < min)
        {
            min = dist[i];
            v = i;
        }
    }
    return v;
}

void Prim(int s)
{
    IniPrim(s); //从s点开始生长，初始化
    while (1)
    {
        int v = FindMin(); //未收录顶点中dist最小者（dist[i]!=0)
        if (v == -1)
            break;
        sum += dist[v];
        dist[v] = 0; //表示已经收录
        MST.push_back(v);
        for (int w = 0; w < Nv; w++) //v的每个邻接点w
        {
            if (G[v][w] < INF && dist[w]) //是v的邻接点并且没被收录
            {
                if (G[v][w] < dist[w])
                {
                    dist[w] = G[v][w];
                    parent[w] = v;
                }
            }
        }
    }
}
void output()
{
    printf("收录顺序：\n");
    for (int i = 0; i < Nv; i++)
        printf("%d ", MST[i]);
    printf("\n生成树：(s的parent结点)\n");
    for (int i = 0; i < Nv; i++)
        printf("%d ", parent[i]);
}
int main()
{
    build();
    Prim(1);
    output();
}

Kruskal

/*
int Kruskal()
{
    MST=包含所有顶点但没有边的图;//初始状态
    while(MST中收集的边不到Nv-1条&&原图的边集E非空)
    {
        从E中选择最小代价边（V,W) //用最小堆
        从E中删除此边（V,W）
        if((V,W)的选取不在MST中构成回路)//判断用并查集 Find  ，不在MST中构成回路，计V,W不在同一颗树上
            将（V,W）加入MST；
        else
            彻底丢弃（V,W）
    }
    if(MST中收集的边不到Nv-1条)
        return error
    else 
        return 最小权重和sum
}
*/

//Kruskal
#include 
#include 
#include 
#include 
using namespace std;
#define INF 100000
#define MaxVertex 100
int parent[MaxVertex]; // 并查集最小生成树
int Nv;                // 结点
int Ne;                // 边
int sum;               // 权重和

struct edge
{
    int v1, v2;
    int weight;
    int sign; //该边是否已经被选择过
};
struct edge E[MaxVertex];
vector<int> MST;  // 最小生成树
int G[MaxVertex]; //数组G 用于判定所选择的边是否在同一个分量上

void IniGraph()
{
    int v1, v2, w;
    int i;
    printf("请输入结点数、边数\n");
    scanf("%d %d", &Nv, &Ne);
    printf("请输入起点、终点、权值\n");
    for (i = 0; i < Ne; i++)
    {
        scanf("%d %d %d", &v1, &v2, &w);
        E[i].v1 = v1;
        E[i].v2 = v2;
        E[i].weight = w;
        E[i].sign = 0; //说明还没有进入MST
    }
    for (i = 0; i < Nv; i++)
    {
        G[i] = i; //说明在哪个分量上
    }
}

void Kruskal()
{
    int i, j = 0, MinEdge, start, end;
    int Min;
    while (j < Nv - 1)
    {
        Min = INF;
        for (i = 0; i < Ne; i++) //寻找最短边
        {
            if (E[i].sign == 0)
            {
                if (E[i].weight < Min)
                {
                    Min = E[i].weight;
                    MinEdge = i;
                    start = E[i].v1;
                    end = E[i].v2;
                    // E[i].sign=1;//why?
                }
            }
        }
        E[MinEdge].sign = 1;
        if (G[start] == G[end])
            E[MinEdge].sign = 2; //在同一个分量上，舍去 最终结果：sign=1的在树里面，sign=2的已经被丢弃，sign=0的是还没被选到
        else
        {
            j++;
            for (i = 0; i < Nv; i++)
            {
                if (G[i] == end) //并入同一分量
                    G[i] = G[start];
            }
        }
    }
}

int main()
{
    IniGraph();
    Kruskal();
    for (int i = 0; i < Ne; i++)
    {
        if (E[i].sign == 1)
        {
            printf("%d %d %d\n", E[i].v1, E[i].v2, E[i].weight);
        }
    }
}

最短路径

单源最短路：Djikstra

#include 
#include 
#include 
#include
using namespace std;
#define MAXN 100
#define INF 10000
#define ERROR -1
int G[MAXN][MAXN], Nv, Ne;
int path[MAXN];
int dist[MAXN];
bool collected[MAXN];

void BuildGraph()
{
    int i, j, v1, v2, w;

    scanf("%d", &Nv);
    // 初始化图
    for (i = 0; i < Nv; i++)
        for (j = 0; j < Nv; j++)
            G[i][j] = 0;
    scanf("%d", &Ne);
    // 插入边
    for (i = 0; i < Ne; i++)
    {
        scanf("%d %d %d", &v1, &v2, &w);
        G[v1][v2] = w;
        G[v2][v1] = w;
    }
}

// 遍历图
void print()
{
    int i, j;
    for (i = 0; i < Nv; i++)
    {
        for (j = 0; j < Nv; j++)
        {
            printf("%d ", G[i][j]);
        }
        printf("\n");
    }
}
int FindMinDist()
{
    int Minv,v;
    int MinDist=INF;

    for(v=0;v<Nv;v++)
    {
        if(collected[v]==false&&dist[v]<MinDist)
        {
            MinDist=dist[v];
            Minv=v;//更新结点
        }
    }
    if(MinDist<INF)
        return Minv;

}


bool Dijkstra(int s) //dist是不断更新的长度值，path记录的是parent，s是图的顶点
                                             //dist[s]=0
{
                    //collect[v] 表示顶点已经求得最短路径
    int v, w;
    //初始化
    for(v=0;v<Nv;v++)
    {
        dist[v]=G[s][v];
        if(dist[v]<INF)
            path[v]=s;
        else
            path[v]=-1;
        collected[v]=false;
    }

    dist[s]=0;
    collected[s]=true;

    while(1)
    {
        v=FindMinDist();//v为未被收录顶点中dist最小者
        if(v==ERROR)
            break;

        collected[v]=true;
        for(w=0;w<Nv;w++)
        {
            if(collected[w]==false&&G[v][w]<INF)//w是v的邻接点且未被收录
            {
                if(G[v][w]<0) //如果负边，Dijkstra不行
                    return false;
                if(dist[v]+G[v][w]<dist[w])//收录v使得dist[w]更小
                {
                    dist[w]=dist[v]+G[v][w];//那就更新d[w]吧！
                    path[w]=v;
                }
            }
        }
        return true;
    }

}

void output(){
	for(int i=0;i<Nv;i++)
		cout<<dist[i]<<" ";
	cout<<endl;
	for(int i=0;i<Nv;i++)
		cout<<path[i]<<" ";
	cout<<endl;
}

int main(){
	BuildGraph();
	Dijkstra(1);
	output();
	return 0;
}

多源最短路：Floyd

void Floyd()
{
	for(Vertex i=1;i<=Nv;i++)
    {
		for(Vertex j=1;j<=Nv;j++)
        {
			dist[i][j] = G[i][j];
			path[i][j] = -1;
		}
    }
	for(Vertex k=1;k<=Nv;k++)
    {
		for(Vertex i=1;i<=Nv;i++)
        {
			for(Vertex j=1;j<=Nv;j++)
            {
				if(dist[i][k] + dist[k][j] < dist[i][j])
                 {
					dist[i][j] = dist[i][k] + dist[k][j];
					path[i][j] = k;
				}
            }
        }
    }
}

AOE 网络

拓扑排序 Topsort

#include 
#include 
#include 
using namespace std;
#define MaxVertexNum 100
typedef struct AdjVNode *AdjList;
struct AdjVNode
{
    int weight;   // 权值
    int adjv;     // 下标
    AdjList next; // 其后一个
};
AdjList Graph[MaxVertexNum]; //全局变量了
int Ne, Nv;

// 建图
void BuildGraph()
{
    int i;
    int v1, v2, w;
    AdjList NewNode;
    scanf("%d", &Nv);
    for (i = 0; i < Nv; i++)
    { //初始化
        Graph[i] = (AdjList)malloc(sizeof(struct AdjVNode));
        Graph[i]->adjv = i;
        Graph[i]->next = NULL;
    }
    scanf("%d", &Ne);
    for (i = 0; i < Ne; i++)
    { //加入边
        scanf("%d %d %d", &v1, &v2, &w);
        NewNode = (AdjList)malloc(sizeof(struct AdjVNode));
        NewNode->adjv = v2;
        NewNode->weight = w;

        NewNode->next = Graph[v1]->next;
        Graph[v1]->next = NewNode;
    }
}
int Indegree[MaxVertexNum];
int TopOrder[MaxVertexNum];
bool Topsort()
{
    //初始化Indegree
    int i, v;
    AdjList w;
    queue<int> q;
    for (i = 0; i < Nv; i++)
        Indegree[i] = 0;

    for (i = 0; i < Nv; i++)
    {
        for (w = Graph[i]->next; w; w = w->next)
        {
            Indegree[w->adjv]++;
        }
    }
    //将所有入度为0的顶点入列
    for (i = 0; i < Nv; i++)
    {
        if (Indegree[i] == 0)
            q.push(i);
    }

    for (i = 0; i < Nv; i++)
        printf("%d", Indegree[i]);

    //拓扑排序
    int cnt = 0;
    while (!q.empty())
    {
        v = q.front();
        q.pop();
        TopOrder[cnt++] = v;
        for (w = Graph[v]; w; w = w->next)
        {
            if (--Indegree[w->adjv] == 0)
                q.push(w->adjv);
        }
    }

    if (cnt != Nv)
    {
        printf("图中有回路，失败！");
        return false;
    }
    else
        return true;
}

void print()
{
    AdjList tmp;
    int i;
    for (i = 0; i < Nv; i++)
    {
        tmp = Graph[i];
        while (tmp)
        {
            printf("%d ", tmp->adjv);
            tmp = tmp->next;
        }
        printf("\n");
    }
}

int main()
{
    BuildGraph();
    bool f = Topsort();
    if (f)
    {
        for (int i = 0; i < Nv; i++)
        {
            printf("%d ", TopOrder[i]);
        }
    }
}

AOE 网络

拓扑排序Topsort

习题1

判断是否存在vi到vj的路径

增加一个判断函数：

其中遍历过的一个连通分量存在vector<> path中，DFS/BFS时把元素加入这个容器中即可,无论是邻接表还是矩阵都是同理

bool Ispath(int i,int j)
{
    bool f1=false,f2=false;
    for(int k=0;k<path.size();k++)
    {
        if(path[k]==i)  f1=true;
        if(path[k]==j)  f2=true;
    }
    if(f1&&f2) return true;
    else return false;
}

完整程序：

#include 
#include 
#include
using namespace std;
#define MAXN 100
int G[MAXN][MAXN], Nv, Ne;
vector<int> path;

void BuildGraph()
{
    int i, j, v1, v2, w;

    scanf("%d", &Nv);
    // 初始化图
    for (i = 0; i < Nv; i++)
        for (j = 0; j < Nv; j++)
            G[i][j] = 0;
    scanf("%d", &Ne);
    // 插入边
    for (i = 0; i < Ne; i++)
    {
        scanf("%d %d %d", &v1, &v2, &w);
        G[v1][v2] = w;
        G[v2][v1] = w;
    }
}

// 遍历图
void print()
{
    int i, j;
    for (i = 0; i < Nv; i++)
    {
        for (j = 0; j < Nv; j++)
            {
                printf("%d ", G[i][j]);
                path.push_back(G[i][j]);
            }
        printf("\n");
    }
}

bool Ispath(int i,int j)
{
    bool f1=false,f2=false;
    for(int k=0;k<path.size();k++)
    {
        if(path[k]==i)  f1=true;
        if(path[k]==j)  f2=true;
    }
    if(f1&&f2) return true;
    else return false;
}

int main()
{
    BuildGraph();
    print();
    return 0;
}

给的答案：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qjh4DC64-1596643429823)(C:\Users\86133\AppData\Roaming\Typora\typora-user-images\1596558028023.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SQIbRkMo-1596643429825)(C:\Users\86133\AppData\Roaming\Typora\typora-user-images\1596558044209.png)]

哈希表

理论考试总结

考点：1.填空题

稠密索引：一个索引项对应数据表中一个对象的索引结构

稀疏索引：对一组记录建立一个索引项

2.分块查找的基本思想：首先查找索引表，因为索引表是有序表，所以可进行顺序查找或折半查找，以确定待查找的记录在哪一块中；然后在已确定的那一块中进行顺序查找

3.倒排表：先查的是数据(次关键字，也是属性）一个属性值和该属性的全部记录地址

4.概念：冲突装填因子

5.处理冲突的两种方法：开放地址法（线性探查法、二次探查法、随机探查法），拉链法

6.开放地址法的删除

7.ASL（平均查找长度）的计算

《王道》习题补充知识点：
1. 散列表的平均查找长度与α相关，不直接依赖于n/m
2. 散列函数有一个共同的性质，即函数应当以(等概率 )取其值域的每个值
3. …

排序算法

归并排序

归并排序（Merge Sort）是将两个或两个以上的有序表合成一个新的有序表。
归并排序基本思想是：
1）当n=1时，终止排序；
2）否则将待排序的元素分成大致相同的两个子集合，分别对两个子集合进行归并排序；
3）将排好序的子集合合并成所要求的排序结果

void MergeSort(DataType R[], int left, int right)
{
	if (left < right ) {//至少有两个元素
	      i = ( left + right )/2;//取中点
	     MergeSort ( R, left, i );
	     MergeSort ( R, i, right );
	     Merge ( a, b, left, i, right );归并到b数组
	    Copy ( a, b, left, right);//复制回a数组
             }
}

上述归并算法的递归过程只是将待排序的顺序表一分为二，直至待排序顺序表中只剩下一个元素为止；然后不断合并两个排好序的数组段。
可以从分治策略入手，消除算法中的递归。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uS8AnlCP-1596643429827)(C:\Users\86133\AppData\Roaming\Typora\typora-user-images\1596557365420.png)]

转载于菜鸟的通俗解释：

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用*分治法（Divide and Conquer）*的一个非常典型的应用。

首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。

快速排序

快速排序算法是基于分治策略的另一个排序算法。其基本思想是：对输入的数组R[l:h]按以下三个步骤进行排序：

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iSGG4qGS-1596643429874)(C:\Users\86133\AppData\Roaming\Typora\typora-user-images\1596557298152.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gcn1cDHq-1596643429875)(C:\Users\86133\AppData\Roaming\Typora\typora-user-images\1596557315808.png)]

1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。
2．j–由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

int AdjustArray(int s[],int l,int r)  //挖坑填数的代码，相当于是一轮
{
    int i=l,j=r;
    int x=s[l];
    while(i<j)
    {
        while(i<j&&s[j]>x) //从右向左找小于x的数来填s[i]
            j--;
        if(i<j)
        {
            s[i]=s[j];
            i++;
        }

        while(i<j&&s[i]<x)
            i++;
        if(i<j)
        {
            s[j]=s[i];
            j--;
        }
    }
    //退出时，i==j 将x填入此坑中
    s[i]=x;
    return i;
}

void quick_sort1(int s[],int l,int r)
{
    if(l<r)
    {
        int i=AdjustArray(s,l,r);
        quick_sort1(s,l,i-1);
        quick_sort1(s,i+1,r);
    }
}
/*---------------------------分割线------------------------------*/

//组合整理(整合为一个函数)
void quick_sort(int s[],int l,int r)
{
    if(l<r)
    {
        int i=l,j=r,x=s[l];
        while(i<j)
        {
            while(i<j&&s[j]>=x)
                j--;
            if(i<j)
                s[i++]=s[j];
            
            while(i<j&&s[i]<=x)
                i++;
            if(i<j)
                s[j--]=s[i];
        }
        s[i]=x;
        quick_sort(s,l,i-1);
        quick_sort(s,l+1,r);
    }
}

考点：求第N趟排序后的状态

排序算法的总结（考点）

内部排序
- 冒泡排序 O(N^2)
- 选择排序O(N^2) 不稳定
- 插入排序O(N^2)
- 希尔排序O(N^1.5) 不稳定
- 归并排序O(NlogN)
- 快速排序O(NlogN) 不稳定
- 堆排序O(NlogN) 不稳定
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ArKVe4EQ-1596643429877)(C:\Users\86133\AppData\Roaming\Typora\typora-user-images\1596607326539.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zzcfrepj-1596643429877)(C:\Users\86133\AppData\Roaming\Typora\typora-user-images\1596607352122.png)]

可以参考https://www.cnblogs.com/onepixel/articles/7674659.html

习题

1.对任意7个关键字进行基于比较的排序，至少要进行____次关键字之间的两两比较

考虑最坏的情况，公式 [log n!]

n=7代入，得13

动态规划和贪心算法（具体略）

在动态规划算法中，每步所作出的选择往往依赖于相关子问题的解，因此只有在解出相关子问题的解后才能做出选择；
而贪心算法所作的贪心选择仅在当前状态下做出的最好选择，即局部最优选择，然后再求解作出该选择后所产生的相应子问题的解，即贪心算法所作出的贪心选择可以依赖于“过去”所作出的选择，但绝不依赖于将来所作出的选择，也不依赖于子问题的解。
贪心算法和动态规划算法都具有最优子结构性质。

0-1背包问题（略）

操作；

递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

[外链图片转存中…(img-iSGG4qGS-1596643429874)]

[外链图片转存中…(img-Gcn1cDHq-1596643429875)]

1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。
2．j–由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。
[外链图片转存中…(img-vgU1iKEv-1596643429876)]

int AdjustArray(int s[],int l,int r)  //挖坑填数的代码，相当于是一轮
{
    int i=l,j=r;
    int x=s[l];
    while(i<j)
    {
        while(i<j&&s[j]>x) //从右向左找小于x的数来填s[i]
            j--;
        if(i<j)
        {
            s[i]=s[j];
            i++;
        }

        while(i<j&&s[i]<x)
            i++;
        if(i<j)
        {
            s[j]=s[i];
            j--;
        }
    }
    //退出时，i==j 将x填入此坑中
    s[i]=x;
    return i;
}

void quick_sort1(int s[],int l,int r)
{
    if(l<r)
    {
        int i=AdjustArray(s,l,r);
        quick_sort1(s,l,i-1);
        quick_sort1(s,i+1,r);
    }
}
/*---------------------------分割线------------------------------*/

//组合整理(整合为一个函数)
void quick_sort(int s[],int l,int r)
{
    if(l<r)
    {
        int i=l,j=r,x=s[l];
        while(i<j)
        {
            while(i<j&&s[j]>=x)
                j--;
            if(i<j)
                s[i++]=s[j];
            
            while(i<j&&s[i]<=x)
                i++;
            if(i<j)
                s[j--]=s[i];
        }
        s[i]=x;
        quick_sort(s,l,i-1);
        quick_sort(s,l+1,r);
    }
}

考点：求第N趟排序后的状态

排序算法的总结（考点）

内部排序
- 冒泡排序 O(N^2)
- 选择排序O(N^2) 不稳定
- 插入排序O(N^2)
- 希尔排序O(N^1.5) 不稳定
- 归并排序O(NlogN)
- 快速排序O(NlogN) 不稳定
- 堆排序O(NlogN) 不稳定
- [外链图片转存中…(img-ArKVe4EQ-1596643429877)]

[外链图片转存中…(img-zzcfrepj-1596643429877)]

可以参考https://www.cnblogs.com/onepixel/articles/7674659.html

习题

1.对任意7个关键字进行基于比较的排序，至少要进行____次关键字之间的两两比较

考虑最坏的情况，公式 [log n!]

n=7代入，得13

动态规划和贪心算法（具体略）

0-1背包问题（略）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GxI4vwBi-1596643429878)(C:\Users\86133\AppData\Roaming\Typora\typora-user-images\1596557588015.png)]

你可能感兴趣的:(数据结构,XDOJ)

数组去重好奇的猫猫猫
整理自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 redis bootstrap 数据库
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》和《
【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】 NeVeRMoRE_2024 数据结构与算法实践数据结构算法 leetcode b树
数据结构和算法实践-树-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教你学Python python 开发语言人工智能 AIGC
第四天：数据结构一、什么是数据结构？数据结构是计算机科学中用于组织和存储数据的特定方式。良好的数据结构能够提高数据的访问效率、修改频率和管理能力。Python提供了多种内置数据结构，如列表、元组、字典和集合，便于开发者更有效地处理数据。二、Python中的基本数据结构1.列表（List）定义：列表是一个有序的可变集合，允许重复元素。使用方括号[]表示。#示例：定义一个列表fruits=['appl
互联网 Java 工程师面试题（Java 面试题四）苹果酱0567 面试题汇总与解析 java 中间件开发语言 spring boot 后端
下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
C# Tuple、ValueTuple 語衣 C#知识补充 c#
栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
Rust中的所有权和借用规则详解代码云1 rust 开发语言后端
Rust是一种系统编程语言，其设计目标包括内存安全、并发安全以及性能。为了实现这些目标，Rust引入了一系列独特的编程概念，其中最为核心的就是所有权（Ownership）和借用（Borrowing）规则。本文将详细解释Rust中的所有权和借用规则，以及它们如何确保内存安全和并发安全。一、所有权规则在Rust中，每一个值都有一个与之关联的所有者。这个所有者可以是变量、数据结构或者是其他形式的存储。所
二叉树--python 电子海鸥 Python数据结构与算法 python 开发语言数据结构
二叉树一、概述1、介绍是一种非线性数据结构，将数据一分为二，代表根与叶的派生关系，和链表的结构类似，二叉树的基本单元是结点，每个节点包括值和左右子节点引用。每个节点都有两个引用（类似于双向链表），分别指向左子节点和右子节点，该节点被称为这两个子节点的父节点。当给定一个二叉树的结点时，我们将在该节点的左子节点以及其以下结点所形成的树称为左子树，同理，右子节点的部分被称为右子树。在二叉树中，除了叶节点
使用WAF防御网络上的隐蔽威胁之反序列化攻击 baiolkdnhjaio 网络安全
什么是反序列化反序列化是将数据结构或对象状态从某种格式转换回对象的过程。这种格式通常是二进制流或者字符串（如JSON、XML），它是对象序列化（即对象转换为可存储或可传输格式）的逆过程。反序列化的安全风险反序列化的安全风险主要来自于处理不受信任的数据源时的不当反序列化。如果应用程序反序列化了恶意构造的数据，攻击者可能能够执行代码、访问敏感数据、进行拒绝服务攻击等。这是因为反序列化过程中可能会自动触
java 线程池队列封装_java线程池（线程池组---分离任务队列和线程池）爱打怪的小魔女 java 线程池队列封装
线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。生产消费外部线程(生产者)－－－>任务消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝2
java短路运算符和逻辑运算符的区别 3213213333332132 java基础
/* * 逻辑运算符——不论是什么条件都要执行左右两边代码 * 短路运算符——我认为在底层就是利用物理电路的“并联”和“串联”实现的 * 原理很简单，并联电路代表短路或（||），串联电路代表短路与（&&）。 * * 并联电路两个开关只要有一个开关闭合，电路就会通。 * 类似于短路或（||），只要有其中一个为true（开关闭合）是
Java异常那些不得不说的事白糖_ java exception
一、在finally块中做数据回收操作比如数据库连接都是很宝贵的，所以最好在finally中关闭连接。 JDBCAgent jdbc = new JDBCAgent(); try{ jdbc.excute("select * from ctp_log"); }catch(SQLException e){ ... }finally{ jdbc.close();
utf-8与utf-8(无BOM)的区别 dcj3sjt126com PHP
BOM——Byte Order Mark，就是字节序标记在UCS 编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输字符"ZERO WIDTH NO-BREAK SPACE"。这样如
JAVA Annotation之定义篇周凡杨 java 注解 annotation 入门注释
Annotation: 译为注释或注解 An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, pa
tomcat的多域名、虚拟主机配置 g21121 tomcat
众所周知apache可以配置多域名和虚拟主机，而且配置起来比较简单，但是项目用到的是tomcat，配来配去总是不成功。查了些资料才总算可以，下面就跟大家分享下经验。很多朋友搜索的内容基本是告诉我们这么配置：在Engine标签下增面积Host标签，如下： <Host name="www.site1.com" appBase="webapps"
Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ） 510888780 linux capistrano
1.ssh -v [email protected] 出现 Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password). 错误运行状况如下： OpenSSH_5.3p1, OpenSSL 1.0.1e-fips 11 Feb 2013 debug1: Reading configuratio
log4j的用法 Harry642 java log4j
一、前言： log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中
mysql、sqlserver、oracle分页，java分页统一接口实现 aijuans oracle jave
定义：pageStart 起始页，pageEnd 终止页,pageSize页面容量 oracle分页：　　　　select * from ( select mytable.*,rownum num from (实际传的SQL) where rownum<=pageEnd) where num>=pageStart sqlServer分页：
Hessian 简单例子 antlove java Web service hessian
hello.hessian.MyCar.java package hessian.pojo; import java.io.Serializable; public class MyCar implements Serializable { private static final long serialVersionUID = 473690540190845543
数据库对象的同义词和序列百合不是茶 sql 序列同义词 ORACLE权限
回顾简单的数据库权限等命令; 解锁用户和锁定用户 alter user scott account lock/unlock; //system下查看系统中的用户 select * dba_users; //创建用户名和密码 create user wj identified by wj; identified by //授予连接权和建表权 grant connect to
使用Powermock和mockito测试静态方法 bijian1013 持续集成单元测试 mockito Powermock
实例： package com.bijian.study; import static org.junit.Assert.assertEquals; import java.io.IOException; import org.junit.Before; import org.junit.Test; import or
精通Oracle10编程SQL(6)访问ORACLE bijian1013 oracle 数据库 plsql
/* *访问ORACLE */ --检索单行数据 --使用标量变量接收数据 DECLARE v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; BEGIN select ename,sal into v_ename,v_sal from emp where empno=&no; dbms_output.pu
【Nginx四】Nginx作为HTTP负载均衡服务器 bit1129 nginx
Nginx的另一个常用的功能是作为负载均衡服务器。一个典型的web应用系统，通过负载均衡服务器，可以使得应用有多台后端服务器来响应客户端的请求。一个应用配置多台后端服务器，可以带来很多好处：负载均衡的好处增加可用资源增加吞吐量加快响应速度，降低延时出错的重试验机制 Nginx主要支持三种均衡算法： round-robin l
jquery-validation备忘白糖_ jquery css F#Firebug
留点学习jquery validation总结的代码： function checkForm(){ validator = $("#commentForm").validate({// #formId为需要进行验证的表单ID errorElement :"span",// 使用"div"标签标记错误，默认:&
solr限制admin界面访问（端口限制和http授权限制） ronin47 限定Ip访问
solr的管理界面可以帮助我们做很多事情，但是把solr程序放到公网之后就要限制对admin的访问了。可以通过tomcat的http基本授权来做限制，也可以通过iptables防火墙来限制。我们先看如何通过tomcat配置http授权限制。第一步：在tomcat的conf/tomcat-users.xml文件中添加管理用户，比如： <userusername="ad
多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 bylijinnan java 多线程
public class IncDecThread { private int j=10; /* * 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 * 两个问题： * 1、线程同步--synchronized * 2、线程之间如何共享同一个j变量--内部类 */ public static
买房历程 cfyme
2015-06-21: 万科未来城，看房子 2015-06-26: 办理贷款手续，贷款73万，贷款利率5.65=5.3675 2015-06-27: 房子首付,签完合同 2015-06-28，央行宣布降息 0.25，就2天的时间差啊，没赶上。首付，老婆找他的小姐妹接了5万，另外几个朋友借了1-
[军事与科技]制造大型太空战舰的前奏 comsci 制造
天气热了........空调和电扇要准备好.......... 最近,世界形势日趋复杂化,战争的阴影开始覆盖全世界.......... 所以,我们不得不关
dateformat dai_lm DateFormat
"Symbol Meaning Presentation Ex." "------ ------- ------------ ----" "G era designator (Text) AD" "y year
Hadoop如何实现关联计算 datamachine mapreduce hadoop 关联计算
选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。以关联计算为例。假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单列表中？ &nbs
用户模型中修改用户信息时，密码是如何处理的 dcj3sjt126com yii
当我添加或修改用户记录的时候对于处理确认密码我遇到了一些麻烦，所有我想分享一下我是怎么处理的。场景是使用的基本的那些(系统自带)，你需要有一个数据表(user)并且表中有一个密码字段(password),它使用 sha1、md5或其他加密方式加密用户密码。面是它的工作流程: 当创建用户的时候密码需要加密并且保存，但当修改用户记录时如果使用同样的场景我们最终就会把用户加密过的密码再次加密，这
中文 iOS/Mac 开发博客列表 dcj3sjt126com Blog
本博客列表会不断更新维护，如果有推荐的博客，请到此处提交博客信息。本博客列表涉及的文章内容支持定制化Google搜索，特别感谢 JeOam 提供并帮助更新。本博客列表也提供同步更新的OPML文件（下载OPML文件），可供导入到例如feedly等第三方定阅工具中，特别感谢 lcepy 提供自动转换脚本。这里有导入教程。
js去除空格，去除左右两端的空格蕃薯耀去除左右两端的空格 js去掉所有空格 js去除空格
js去除空格，去除左右两端的空格 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&g
SpringMVC4零配置--web.xml hanqunfeng springmvc4
servlet3.0+规范后，允许servlet，filter，listener不必声明在web.xml中，而是以硬编码的方式存在，实现容器的零配置。 ServletContainerInitializer：启动容器时负责加载相关配置 package javax.servlet; import java.util.Set; public interface ServletContainer
《开源框架那些事儿21》：巧借力与借巧力 j2eetop 框架 UI
同样做前端UI，为什么有人花了一点力气，就可以做好？而有的人费尽全力，仍然错误百出？我们可以先看看几个故事。故事1：巧借力，乌鸦也可以吃核桃有一个盛产核桃的村子，每年秋末冬初，成群的乌鸦总会来到这里，到果园里捡拾那些被果农们遗落的核桃。核桃仁虽然美味，但是外壳那么坚硬，乌鸦怎么才能吃到呢？原来乌鸦先把核桃叼起，然后飞到高高的树枝上，再将核桃摔下去，核桃落到坚硬的地面上，被撞破了，于是，
JQuery EasyUI 验证扩展可怜的猫 jquery easyui 验证
最近项目中用到了前端框架-- EasyUI，在做校验的时候会涉及到很多需要自定义的内容，现把常用的验证方式总结出来，留待后用。以下内容只需要在公用js中添加即可。使用类似于如下： <input class="easyui-textbox" name="mobile" id="mobile&
架构师之httpurlconnection----------读取和发送(流读取效率通用类) nannan408
1.前言. 如题. 2.代码. /* * Copyright (c) 2015, S.F. Express Inc. All rights reserved. */ package com.test.test.test.send; import java.io.IOException; import java.io.InputStream
Jquery性能优化 r361251 JavaScript jquery
一、注意定义jQuery变量的时候添加var关键字这个不仅仅是jQuery，所有javascript开发过程中，都需要注意，请一定不要定义成如下： $loading = $('#loading'); //这个是全局定义，不知道哪里位置倒霉引用了相同的变量名，就会郁闷至死的二、请使用一个var来定义变量如果你使用多个变量的话，请如下方式定义： . 代码如下: var page
在eclipse项目中使用maven管理依赖 tjj006 eclipse maven
概览: 如何导入maven项目至eclipse中建立自有Maven Java类库服务器建立符合maven代码库标准的自定义类库 Maven在管理Java类库方面有巨大的优势，像白衣所说就是非常“环保”。我们平时用IDE开发都是把所需要的类库一股脑的全丢到项目目录下，然后全部添加到ide的构建路径中，如果用了SVN/CVS，这样会很容易就把
中国天气网省市级联页面 x125858805 级联
1、页面及级联js <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> &l