文档章节

C和指针---第十二章:使用结构和指针

fzyz_sb
 fzyz_sb
发布于 2013/09/19 17:15
字数 2903
阅读 74
收藏 0
点赞 0
评论 0

12.1 链表

链表中的每个节点通过链或指针连接在一起。程序通过指针访问链表中的节点。通常节点是动态分配的,但有时也有节点数组构建的链表,但依旧通过指针来遍历链表的。

12.2 单链表

typedef struct NODE  {
	struct NODE		*link;
	int			value;
}Node;
链表中的节点可能分布于内存中的各个地方。节点在物理上相连与否并不重要,因为程序始终用链(指针)从一个节点移动到另一个节点。

12.2.1 在单链表中插入

#include <stdio.h>
#include <stdlib.h>

typedef struct NODE  {
	struct NODE	*link;
	int		value;
}Node;

int sll_insert( Node **rootp, int new_value )
{
	Node	*current;
	Node	*previous;
	Node	*new;

	current = *rootp;
	previous = NULL;

	while ( current != NULL && current->value < new_value ){
		previous = current;
		current = current->link;
	}

	new = (Node *)malloc( sizeof( Node ) );
	if ( NULL == new ){
		return 0;
	}

	new->value = new_value;
	new->link = current;
	if ( NULL == previous ){
		*rootp = new;
	}
	else{
		previous->link = new;
	}

	return 1;
}

int main(void)
{
	
	//备注:root是指向节点的指针,这样才能不包含任何的数据,而且指向第一个节点
	//如果声明为Node *root,则只是一个节点而已,那么它必须被第一个节点赋值,即本身必须存在值,而不是指向节点的指针了。
	Node	*p1 = (Node *)malloc( sizeof( Node ) );
	Node	*p2 = (Node *)malloc( sizeof( Node ) );
	Node	*p3 = (Node *)malloc( sizeof( Node ) );
	Node	*current;
	p1->value = 5;
	p1->link = p2;

	p2->value = 10;
	p2->link = p3;

	p3->value = 15;
	p3->link = NULL;
	

	sll_insert( &p1, 3 );
	sll_insert( &p1, 12 );
	sll_insert( &p1, 20 );
	current = p1;
	while ( current ){
		printf("%d\n", current->value );
		current = current->link;
	}

	return 0;
}

备注:之前我这里理解出错了,导致写了错误的代码。实际上并不存在指向头节点的指针,即Node**,因为你最终都得初始化为头节点,故直接用头节点的地址传递进去。

函数中第一个参数为Node**,指的意思是头节点的地址,因为这样可以被修改!!!而不是指向头节点的一个额外的指针。

优化单链表的插入:

#include <stdio.h>
#include <stdlib.h>

typedef struct NODE  {
	struct NODE	*link;
	int		value;
}Node;

int sll_insert( register Node **linkp, int new_value )
{
	register Node *current;
	register Node *new;

	while ( ( current = *linkp ) != NULL && current->value < new_value ){
		linkp = &current->link;
	}

	new = (Node *)malloc( sizeof( Node ) );
	if ( NULL == new ){
		return 0;
	}

	new->value = new_value;

	new->link = current;
	*linkp = new;

	return 1;
}

int main(void)
{
 
 //备注:root是指向节点的指针,这样才能不包含任何的数据,而且指向第一个节点
 //如果声明为Node *root,则只是一个节点而已,那么它必须被第一个节点赋值,即本身必须存在值,而不是指向节点的指针了。
 Node	*p1 = (Node *)malloc( sizeof( Node ) );
 Node	*p2 = (Node *)malloc( sizeof( Node ) );
 Node	*p3 = (Node *)malloc( sizeof( Node ) );
 Node	*current;
 p1->value = 5;
 p1->link = p2;


 p2->value = 10;
 p2->link = p3;


 p3->value = 15;
 p3->link = NULL;
 


 sll_insert( &p1, 3 );
 sll_insert( &p1, 12 );
 sll_insert( &p1, 20 );
 current = p1;
 while ( current ){
 printf("%d\n", current->value );
 current = current->link;
 }


 return 0;
}
程序输出:

这种优化是否值得,有待商讨,因为它是函数的调用变得复杂,而且代码增加了阅读的难度。

12.3 双向链表

#include <stdio.h>
#include <stdlib.h>

typedef struct NODE {
	struct NODE		*fwd;
	struct NODE		*bwd;
	int			value;
}Node;

int dll_insert( Node *rootp, int value )
{
	Node *this;
	Node *next;
	Node *newnode;

	for ( this = rootp; ( next = this->fwd) != NULL; this = next ){
		if ( next->value == value ){
			return 0;
		}
		if ( next->value > value ){
			break;
		}
	}

	newnode = (Node *)malloc( sizeof( Node ) );
	if ( newnode == NULL ){
		return -1;
	}
	newnode->value = value;

	if ( next != NULL ){
		if ( this != rootp ){
			newnode->fwd = next;
			this->fwd = newnode;
			newnode->bwd = this;
			next->bwd = newnode;
		}
		else{
			newnode->fwd = next;
			rootp->fwd = newnode;
			newnode->bwd = NULL;
			next->bwd = newnode;
		}
	}
	else{
		if ( this != rootp ){
			newnode->fwd = NULL;
			this->fwd = newnode;
			newnode->bwd = this;
			rootp->bwd = newnode;
		}
		else{
			newnode->fwd = NULL;
			rootp->fwd = newnode;
			newnode->bwd = NULL;
			rootp->bwd = newnode;
		}
	}

	return 1;
}

int main(void)
{
	Node	*rootp = (Node *)malloc( sizeof( Node ) );
	Node	*dp1 = (Node *)malloc( sizeof( Node ) );
	Node	*dp2 = (Node *)malloc( sizeof( Node ) );
	Node	*dp3 = (Node *)malloc( sizeof( Node ) );
	Node	*current;

	dp1->bwd = NULL;		//第一个节点的后向指针为空,而最后一个节点的前向指针为空,根节点指向第一个节点和最后一个节点。
	dp1->fwd = dp2;
	dp1->value = 5;

	dp2->bwd = dp1;
	dp2->fwd = dp3;
	dp2->value = 10;

	dp3->bwd = dp2;
	dp3->fwd = NULL;
	dp3->value = 15;

	rootp->fwd = dp1;
	rootp->bwd = dp3;
	rootp->value = 3;

	dll_insert( rootp, 3 );
	dll_insert( rootp, 12 );
	dll_insert( rootp, 20 );

	current = rootp->fwd;
	while ( current ){
		printf("%d\n", current->value );
		current = current->fwd;
	}

	return 0;
}
程序输出:

但是,我们对代码可以进行简化,简化的代码如下:

int dll_insert( register Node *rootp, int value )
{
	register Node	*this;
	register Node	*next;
	register Node	*newnode;

	for ( this = rootp; ( next = this->fwd) != NULL; this = next ){
		if ( next->value_traits == value ){
			return 0;
		}
		if ( next->value > value ){
			break;
		}
	}
	newnode = (Node *)malloc( sizeof( Node ) );
	if ( NULL == newnode ){
		return -1;
	}
	newnode->value = value;

	newnode->fwd = next;
	this->fwd = newnode;

	if ( this != rootp ){
		newnode->bwd = this;
	}
	else{
		newnode->bwd = NULL;
	}

	if ( NULL != next ){
		next->bwd = newnode;
	}
	else{
		rootp->bwd = newnode;
	}

	return 1;
}
不过,代码的可阅读性的重要性永远高于代码的质量,所以支持第一种写法。

习题:

1. 

#include <stdio.h>
#include <stdlib.h>

typedef struct NODE  {
	struct NODE	*link;
	int		value;
}Node;

int sll_insert( Node **rootp, int new_value )
{
	Node	*current;
	Node	*previous;
	Node	*new;

	current = *rootp;
	previous = NULL;

	while ( current != NULL && current->value < new_value ){
		previous = current;
		current = current->link;
	}

	new = (Node *)malloc( sizeof( Node ) );
	if ( NULL == new ){
		return 0;
	}

	new->value = new_value;
	new->link = current;
	if ( NULL == previous ){
		*rootp = new;
	}
	else{
		previous->link = new;
	}

	return 1;
}

int main(void)
{

	//备注:root是指向节点的指针,这样才能不包含任何的数据,而且指向第一个节点
	//如果声明为Node *root,则只是一个节点而已,那么它必须被第一个节点赋值,即本身必须存在值,而不是指向节点的指针了。
	Node	*p1 = (Node *)malloc( sizeof( Node ) );
	Node	*p2 = (Node *)malloc( sizeof( Node ) );
	Node	*p3 = (Node *)malloc( sizeof( Node ) );
	Node	*current;
	int		count = 0;
	p1->value = 5;
	p1->link = p2;

	p2->value = 10;
	p2->link = p3;

	p3->value = 15;
	p3->link = NULL;


	sll_insert( &p1, 3 );
	sll_insert( &p1, 12 );
	sll_insert( &p1, 20 );
	current = p1;
	while ( current ){
		count++;
		printf("%d\n", current->value );
		current = current->link;
	}

	printf("the code number is: %d\n", count );

	return 0;
}

程序输出:

2. 

#include <stdio.h>
#include <stdlib.h>

typedef struct NODE {
	struct NODE *p_next;
	int	value;
}Node;

int main(void)
{
	Node *p1 = (Node *)malloc( sizeof( Node ) );
	Node *p2 = (Node *)malloc( sizeof( Node ) );
	Node *p3 = (Node *)malloc( sizeof( Node ) );
	Node *p4 = (Node *)malloc( sizeof( Node ) );
	Node *p5 = (Node *)malloc( sizeof( Node ) );
	Node *current;
	int		value = 0;

	p1->p_next = p2;
	p2->p_next = p3;
	p3->p_next = p4;
	p4->p_next = p5;
	p5->p_next = NULL;

	p1->value = 1;
	p2->value = 3;
	p3->value = 5;
	p4->value = 2;
	p5->value = 4;

	current = p1;
	value = 2;
	while ( current ){
		if ( current->value == value ){
			printf("%x---%d", current, current->value );
			break;
		}
		current = current->p_next;
	}
	if ( NULL == current){
		printf("not found\n");
	}

	return 0;
}

并没有封装成函数。程序输出:

3.

#include <stdio.h>
#include <stdlib.h>

typedef struct NODE {
	struct NODE		*fwd;
	struct NODE		*bwd;
	int			value;
}Node;

int dll_insert( Node *head, Node *tail, int value )
{
	Node *this;
	Node *next;
	Node *newnode;

	for ( this = head; ( next = this->fwd ) != tail; this = next ){
		if ( next->value == value ){
			return 0;
		}
		if ( next->value > value ){
			break;
		}
	}

	newnode = (Node *)malloc( sizeof( Node ) );
	if ( NULL == newnode ){
		return -1;
	}
	newnode->value = value;

	if ( tail != next ){
		if ( this != head ){
			newnode->fwd = next;
			this->fwd = newnode;
			newnode->bwd = this;
			next->bwd = newnode;
		}
		else{
			newnode->fwd = next;
			head->fwd = newnode;
			newnode->bwd = head;
			next->bwd = newnode;
		}
	}
	else{
		if ( this != head ){
			newnode->fwd = tail;
			this->fwd = newnode;
			newnode->bwd = this;
			tail->bwd = newnode;
		}
		else{
			newnode->fwd = tail;
			head->fwd = newnode;
			newnode->bwd = head;
			tail->bwd = newnode;
		}
	}
}

int main(void)
{
	Node	*head = (Node *)malloc( sizeof( Node ) );
	Node	*tail = (Node *)malloc( sizeof( Node ) );
	Node	*dp1 = (Node *)malloc( sizeof( Node ) );
	Node	*dp2 = (Node *)malloc( sizeof( Node ) );
	Node	*dp3 = (Node *)malloc( sizeof( Node ) );
	Node	*current;

	dp1->bwd = head;		//第一个节点的后向指针为空,而最后一个节点的前向指针为空,根节点指向第一个节点和最后一个节点。
	dp1->fwd = dp2;
	dp1->value = 5;

	dp2->bwd = dp1;
	dp2->fwd = dp3;
	dp2->value = 10;

	dp3->bwd = dp2;
	dp3->fwd = tail;
	dp3->value = 15;

	head->fwd = dp1;
	tail->bwd = dp3;

	dll_insert( head, tail, 3 );
	dll_insert( head, tail, 12 );
	dll_insert( head, tail, 20 );

	current = head->fwd;
	while ( current != tail ){
		printf("%d\n", current->value );
		current = current->fwd;
	}

	return 0;
}

备注:虽然代码量多了点,但是个人感觉阅读起来更轻松吧。程序输出:

4. 这道题的答案从Google上搜来的,最后发现其实自己想的和答案的意义,但是唯一的区别是:我用到的是指针,导致赋值的时候进行了覆盖。而原答案没用到指针,可以临时建立节点。代码如下:

#include <stdio.h>

typedef struct Node {
	char	value;
	struct	Node	*next; 
} Node;

void print_list( Node *root )
{
	while ( root ){
		printf("%c-->", root->value );
		root = root->next;
	}
	printf("NULL\n");
}

void reverse_list( Node *root )
{
	Node *new_root = 0;
	while ( root ){
		Node *next = root->next;
		root->next = new_root;
		new_root = root;
		root = next;
	}
}

int main(void)
{
	Node d = { 'd', 0 };
	Node c = { 'c', &d };
	Node b = { 'b', &c };
	Node a = { 'a', &b };

	print_list( &a );
	reverse_list( &a );
	print_list( &d );

	return 0;
}
程序输出:

5. 

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
	char	value;
	struct	Node	*next; 
} Node;

void print_list( Node *root )
{
	while ( root ){
		printf("%c-->", root->value );
		root = root->next;
	}
	printf("NULL\n");
}

int sll_remove( Node **rootp, Node *node )
{
	Node *current = *rootp;
	Node *previous = NULL;
	while ( current ){
		if ( current == node ){
			current = current->next;
			if ( previous ){
				previous->next = current;
			}
			else{
				( *rootp ) = ( *rootp )->next;	//头节点进行特殊处理
			}
			return 1;
		}
		previous = current;
		current = current->next;
	}

	return 0;
}

int main(void)
{
	Node *a = (Node *)malloc( sizeof( Node ) );
	Node *b = (Node *)malloc( sizeof( Node ) );
	Node *c = (Node *)malloc( sizeof( Node ) );
	Node *d = (Node *)malloc( sizeof( Node ) );
	Node *falseNode = (Node *)malloc( sizeof( Node ) );

	a->next = b;
	b->next = c;
	c->next = d;
	d->next = NULL;
	a->value = 'a';
	b->value = 'b';
	c->value = 'c';
	d->value = 'd';

	falseNode->next = d;
	falseNode->value = 'dd';

	print_list( a );
	sll_remove( &a, a );	//删除头节点
	print_list( a );

	sll_remove( &a, c );	//删除中间节点
	print_list( a );

	sll_remove( &a, falseNode );	//删除一个错误的节点
	print_list( a );

	return 0;
}

程序输出:

使用节点而不是一个值的好处是:你可以直接进行节点的比较和赋值。

6.

#include <stdio.h>
#include <stdlib.h>

typedef struct NODE {
	struct NODE		*fwd;
	struct NODE		*bwd;
	char			value;
} Node;

void print_list( struct NODE *rootp ){
	Node *current = rootp->fwd;
	while ( current ){
		printf("%c-->", current->value );
		current = current->fwd;
	}
	printf("NULL\n");
}

int dll_remove( struct NODE *rootp, struct NODE *node )
{
	Node *current = rootp->fwd;
	Node *previous = NULL;

	while ( current ){
		if ( current == node ){
			if ( previous ){				//解决头节点为删除的节点的特殊情况
				previous->fwd = current->fwd;
			}
			else{
				rootp->fwd = current->fwd;
			}
			if ( current->fwd ){	
				current->fwd->bwd = previous;
			}
			else{
				rootp->bwd = previous;		//解决尾节点为删除节点的特殊情况
			}
			return 1;
		}
		previous = current;
		current = current->fwd;
	}

	return 0;
}

int main(void)
{
	Node	*rootp = (Node *)malloc( sizeof( Node ) );
	Node	*dp1 = (Node *)malloc( sizeof( Node ) );
	Node	*dp2 = (Node *)malloc( sizeof( Node ) );
	Node	*dp3 = (Node *)malloc( sizeof( Node ) );
	Node	*dp4 = (Node *)malloc( sizeof( Node ) );
	Node	*dp5 = (Node *)malloc( sizeof( Node ) );
	Node	*dp6 = (Node *)malloc( sizeof( Node ) );

	dp1->bwd = NULL;		//第一个节点的后向指针为空,而最后一个节点的前向指针为空,根节点指向第一个节点和最后一个节点。
	dp1->fwd = dp2;
	dp1->value = 'a';

	dp2->bwd = dp1;
	dp2->fwd = dp3;
	dp2->value = 'b';

	dp3->bwd = dp2;
	dp3->fwd = dp4;
	dp3->value = 'c';

	dp4->bwd = dp3;
	dp4->fwd = dp5;
	dp4->value = 'd';

	dp5->bwd = dp4;
	dp5->fwd = dp6;
	dp5->value = 'e';

	dp6->bwd = dp5;
	dp6->fwd = NULL;
	dp6->value = 'f';

	rootp->fwd = dp1;
	rootp->bwd = dp6;

	print_list( rootp );

	dll_remove( rootp, dp1 );
	print_list( rootp );

	dll_remove( rootp, dp6 );
	print_list( rootp );

	dll_remove( rootp, dp4 );
	print_list( rootp );

	return 0;
}

程序输出:

7.

#include <stdio.h>
#include <stdlib.h>

//保存由value开头的所有单词
typedef struct SWORD{
	struct SWORD	*next;
	char		*value;
} Sword;

//一个链表,保存所有的单词
typedef struct NODE{
	struct NODE	*next;
	struct SWORD	*value;
} Node;

//打印整个链表
void print_list( Node *node )
{
	Node *current = node;
	while ( current ){
		Sword *currentWord = current->value;
		while ( currentWord ){
			printf("%s-->", currentWord->value );
			currentWord = currentWord->next;
		}
		printf("NULL\n");
		current = current->next;
	}
}

//在表SWORD中查找是否出现单词string
int sll_find( Sword *sword, char *string )
{
	Sword *current = sword;
	while ( current ){
		if ( current->value == string ){
			return 1;
		}
		current = current->next;
	}

	return 0;
}

//在单词表中插入单词string
void sll_insertWord( Sword **sword, char *string )		//传入的指针必须为指向头节点的指针,否则当节点为空的时候,无法完成插入
{
	Sword *current = *sword;
	Sword *previous = NULL;
	Sword *new;
	while ( current != NULL && current->value < string ){
		previous = current;
		current = current->next;
	}
	
	new = (Sword *)malloc( sizeof( Sword ) );
	if ( NULL == new ){
		return;
	}
	new->value = string;

	new->next = current;
	if ( previous ){
		previous->next = new;
	}
	else{
		*sword = new;			//处理链表为空的情况
	}
}

void sll_insertWordList( Node **node, Sword *sword )		
{
	Node *current = *node;
	Node *previous = NULL;
	Node *new;
	while ( current != NULL && current->value < sword ){
		previous = current;
		current = current->next;
	}

	new = (Node *)malloc( sizeof( Node ) );
	if ( NULL == new ){
		return;
	}
	new->value = sword;

	new->next = current;
	if ( previous ){
		previous->next = new;
	}
	else{
		*node = new;
	}
}

int sll_insertNode( Node **node, char *string )
{
	char	ch = *string;
	Node	*current = *node;
	Node	*previous = NULL;
	Sword	*newword;
	while ( current != NULL ){
		if ( ch == *(current->value->value) ){				//存在包含和string一样开头字母的单词
			if ( sll_find( current->value, string ) ){
				return 0;
			}
			else{
				sll_insertWord(&current->value, string );
				return 1;
			}
		}
		previous = current;								//用于判断node是否为空的链表
		current = current->next;
	}

	newword = (Sword *)malloc( sizeof( Sword ) );
	if ( NULL == newword ){
		return 0;
	}
	newword->next = NULL;
	newword->value = string;
	sll_insertWordList(&current, newword );
	if ( previous ){
		previous->next = current;					//如果链表不为空,则将节点插入到链表中
	}
	else{
		( *node )->next = NULL;						//如果链表为空,则进行特殊处理
		( *node )->value = newword;
	}

	return 0;
}

int main(void)
{
	char a[] = "aaa";
	char b[] = "aab";
	char c[] = "ccc";
	char d[] = "ddd";
	char e[] = "ddf";

	Sword *sword = (Sword *)malloc( sizeof( Sword ) );
	Node *node = (Node *)malloc( sizeof( Node ) );

	sword->next = NULL;
	sword->value = a;

	
	node->next = NULL;
	node->value = sword;

	sll_insertNode( &node, b );
	sll_insertNode( &node, c );
	sll_insertNode( &node, d );
	sll_insertNode( &node, e );
	print_list( node );

	return 0;
}

程序输出:

备注:做出这道题,心情突然好愉快。

© 著作权归作者所有

共有 人打赏支持
fzyz_sb
粉丝 404
博文 209
码字总数 447144
作品 0
武汉
程序员
《程序员面试宝典》精华 编程语言部分

《程序员面试宝典》精华 编程语言部分 正所谓取其精华,去其糟粕。本文谨记录下《程序员面试宝典》一些关键的知识点、易错点,对于一些虽然重要但书中没有解释清楚的地方不做记录。当然这里的...

modernizr ⋅ 2014/08/11 ⋅ 2

C++Primer第五版 第十二章习题答案(11~20)

11:知识点1:理解变量的销毁与其内存的释放之间的关系:内置类型的指针在离开作用域时,本身会被销毁,但是其指向的内存空间什么都不会发生,必须以显式的delete进行释放空间。智能指针在离...

misayaaaaa ⋅ 2017/03/05 ⋅ 0

C++快速入门

只学过Java的我最近笔试接触到各种C++的题目,于是稍微恶补了一下C++的基础部分,以下内容是基于《21天学通C++》的部分读书笔记,按照章节写的。 第二章 C++程序的组成部分 ①#include 预处理...

waffle930 ⋅ 2016/10/02 ⋅ 0

Head First C 第十二章 线程 平行世界

Head First C 第十二章 线程 平行世界 前面我们已经会用多进程的方式,来让计算机同时做多件事,但是进程还有以下几个缺点: 创建进程要花时间 有的机器创建进程只需要花一丁点时间,虽然时间...

AlexTuan ⋅ 2016/04/27 ⋅ 0

golang 内存分析之字节对齐规则

c 的字节对齐很重要,因为c 支持指针运算。在golang 里面一般是慎用指针运算的,所以,这部分很少用,但是有些场景为了性能不得不用到指针运算,这个时候,知道golang 的内存分配就很重要了。...

鼎铭 ⋅ 06/12 ⋅ 0

测试下C语言的基础水平(答案)

第一题 分析:主要考察setjump和longjump这两个函数的作用。从英文字面意思我们可以知道是跳转,程序的非本地跳转。 只要知道了这两个函数的功能,就很容易知道本题的答案为:(b) 5 第二题 ...

开心303 ⋅ 2011/08/05 ⋅ 0

【C++】第7章 函数 知识总结

《C++ Primer Plus》第7章知识点总结 简单的知识不再进行赘述 形参:函数头中用于接受传递值的变量 实参:传递给函数的值 使用C++函数,必须完成以下工作: (1)提供函数定义 (2)提供函数...

qq_37792173 ⋅ 2017/10/10 ⋅ 0

Linux内核编码规范

这是一个简短的文档,描述了linux内核的首选代码风格。代码风格是因人而异的,而且我不愿意把我的观点强加给任何人,不过这里所讲述的是我必须要维护的代码所遵守的风格,并且我也希望绝大多...

最新更新消息 ⋅ 2015/12/04 ⋅ 0

CodingStyle: Linux内核代码风格

--------------------------------------------------------------------- Linux内核代码风格 这是一个简短的文档,描述了linux内核的首选代码风格。代码风格是因人而异的,而且我 不愿意把我...

长平狐 ⋅ 2012/06/20 ⋅ 0

【C++】第4章 复合类型 知识总结

《C++ Primer Plus》第4章知识点总结 内置的C++类型分两组:基本类型和复合类型。本文将介绍复合类型 数组 声明数组的通用格式:typeName arrayName[arraySize]; 数组的初始化 (1)只有在定...

qq_37792173 ⋅ 2017/09/20 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

使用 vue-cli 搭建项目

vue-cli 是一个官方发布 vue.js 项目脚手架,使用 vue-cli 可以快速创建 vue 项目,GitHub地址是:https://github.com/vuejs/vue-cli 一、 安装 node.js 首先需要安装node环境,可以直接到中...

初学者的优化 ⋅ 23分钟前 ⋅ 0

设计模式 之 享元模式

设计模式 之 享元模式 定义 使用共享技术来有效地支持大量细粒度对象的复用 关键点:防止类多次创建,造成内存溢出; 使用享元模式来将内部状态与外部状态进行分离,在循环创建对象的环境下,...

GMarshal ⋅ 38分钟前 ⋅ 0

SpringBoot集成Druid的最简单的小示例

参考网页 https://blog.csdn.net/king_is_everyone/article/details/53098350 建立maven工程 Pom文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM......

karma123 ⋅ 今天 ⋅ 0

Java虚拟机基本结构的简单记忆

Java堆:一般是放置实例化的对象的地方,堆分新生代和老年代空间,不断未被回收的对象越老,被放入老年代空间。分配最大堆空间:-Xmx 分配初始堆空间:-Xms,分配新生代空间:-Xmn,新生代的大小一...

算法之名 ⋅ 今天 ⋅ 0

OSChina 周日乱弹 —— 这么好的姑娘都不要了啊

Osc乱弹歌单(2018)请戳(这里) 【今日歌曲】 @TigaPile :分享曾惜的单曲《讲真的》 《讲真的》- 曾惜 手机党少年们想听歌,请使劲儿戳(这里) @首席搬砖工程师 :怎样约女孩子出来吃饭,...

小小编辑 ⋅ 今天 ⋅ 8

Jenkins实践3 之脚本

#!/bin/sh# export PROJ_PATH=项目路径# export TOMCAT_PATH=tomcat路径killTomcat(){pid=`ps -ef | grep tomcat | grep java|awk '{print $2}'`echo "tom...

晨猫 ⋅ 今天 ⋅ 0

Spring Bean的生命周期

前言 Spring Bean 的生命周期在整个 Spring 中占有很重要的位置,掌握这些可以加深对 Spring 的理解。 首先看下生命周期图: 再谈生命周期之前有一点需要先明确: Spring 只帮我们管理单例模...

素雷 ⋅ 今天 ⋅ 0

zblog2.3版本的asp系统是否可以超越卢松松博客的流量[图]

最近访问zblog官网,发现zlbog-asp2.3版本已经进入测试阶段了,虽然正式版还没有发布,想必也不久了。那么作为aps纵横江湖十多年的今天,blog2.2版本应该已经成熟了,为什么还要发布这个2.3...

原创小博客 ⋅ 今天 ⋅ 0

聊聊spring cloud的HystrixCircuitBreakerConfiguration

序 本文主要研究一下spring cloud的HystrixCircuitBreakerConfiguration HystrixCircuitBreakerConfiguration spring-cloud-netflix-core-2.0.0.RELEASE-sources.jar!/org/springframework/......

go4it ⋅ 今天 ⋅ 0

二分查找

二分查找,也称折半查找、二分搜索,是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始,如果中间元素正好是要查找的元素,则搜素过程结束;如果某一特定元素大于...

人觉非常君 ⋅ 今天 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部