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

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量115 收藏
点赞数
文章标签： 数据结构与算法
原文链接：https://my.oschina.net/voler/blog/162659
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

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;
}

程序输出：

备注：做出这道题，心情突然好愉快。

转载于:https://my.oschina.net/voler/blog/162659

weixin_33753003
关注
《C和指针》第12章 使用结构和指针
坤的专栏
04-30 955
这一章详细讲了单链表，考虑的很全面，我感觉很有用，特此记录下来。 单链表的头文件（sll_node.h）： typedef struct NODE { struct NODE *link; int value; } Node; 插入函数（sll_insert）： #include #include #include "sll_node.h" defi
C和指针 （pointers on C）——第十二章：使用结构和指针
07-23 657
第十二章 使用结构和指针 这章就是链表。先单链表，后双向链表。 总结： 单链表是一种使用指针来存储值的数据结构。链表中的每个节点包含一个字段，用于指向链表的下一个节点。 有一个独立的根指针指向链表的第1个节点。单链表只能从一个方向遍历。 如何insert单链表：1、新节点的link字段必须设置为指向它的后面节点。2、前一个节点的link字段必须指向这个新节点。 为了
C和指针读书笔记-第12章（使用结构和指针）
欢迎来到饭没了吃的博客
04-27 473
1.链表就一些包含数据的独立数据结构（通常称为节点）的集合。 2.根指针指向链表的第1个节点，注意根指针只是一个指针，它不包含任何数据。 3.在单链表中插入节点，要始终保存一个指向链表当前节点之前那个节点的指针。 4.在单链表中插入一个新节点： 注意,解决这个问题的方法是始终保存一个指向链表当前节点之前的那个节点指针。 注意为新节点分配内存 new=（Node *)malloc (si
《c和指针》第十二章单链表练习
lajidui1234的专栏
07-22 500
#include #include struct Node{ int value; Node *link; }; Node *sll_reverse(Node *rootp); int sll_insert(Node **rootp,int value); int remove(Node **rootp,Node *node); int my_free(Node *rootp);
C和指针读书笔记（第十二章）
7now_的博客
10-11 400
1. 单链表P235 1.1 单链表的结构 typedef struct NODE{ STRUCT NODE *link; int value; }Node; //根指针只是一个指针 //链表最后一个节点的指针字段的值为NULL 1.2 单链表的插入
C和指针 学习笔记—第1-2章
假装在纽约
08-28 1318
C和指针这本经典著作，最近开始学习，然后想与大家共享下，希望共同进步！网络的力量是强大的，会碰撞出思想的火花来！ 第一章 快速上手 1、要从逻辑上删除一段C代码，更好的办法是使用#if指令： #if 0 statements #endif 在 #if 和 #endif 之间的程序段就可以有效地从程序中去除，即使这段代码之间原先存在注释也无妨 2、关于scanf返回值的问题 　 scanf函数，与printf函数一样，都被定义在stdio.h里，因此在使用scanf函数时要加上#
C和指针(第三章)
Alanadle的博客
07-03 194
(一)看了半天,觉得最有价值的地方莫过于是数据的存储和字符类型和指针之间的混沌关系 #数据存储: 1.1栈区:编译器在需要的时候分配,不需要的时候回收(一般变量的生命周期到外面的"}"为止),它的内存空间相对于堆来说,要小很多(比如申请int A[10000000000000],编译器就会报错),但是好在执行效率高,因为malloc/new都是要通过复杂的算法才可以申请到空间,花费了一定的时间,更不用说还有delete/free了 1.2堆区:堆并不是一无是处,相反,它拥有较大的内存空间,相对栈来说可以存储
S7-200SMART PLC指针学习（二）指针的内部结构.docx
11-25
本文将深入探讨指针的内部结构，帮助我们更好地理解和使用指针。 首先，我们要了解指针在S7-200SMART PLC中的表示方式。在示例中，VD100是一个双字（DWORD）类型的指针，它存储了VB4523的地址。VD100包含了四个字节...
C语言程序设计题库 第九章：指针
08-29
指针的使用极大地提升了C语言的灵活性和性能，但也增加了程序的复杂性。 1. **指针的作用**： - **共享内存**：指针可以用来在不同部分的代码之间共享内存，避免了大体积数据（如结构体）的复制，提高了效率。 - ...
谭浩强-C程序设计第三版第章ppt课件.ppt
11-15
- 第12章：介绍位运算，如何在二进制层面操作数据。 - 第13章：讲解文件操作，包括文件的打开、读写和关闭。 - 第14章：分析常见的编程错误和调试技巧，帮助开发者提高代码质量。 4. **学习C语言的意义** - ...
[C语言习题]第8章-善于利用指针
09-26
12. **指针的安全使用**：避免空指针解引用、内存泄漏和野指针等问题，是编写可靠代码的关键。 熟练掌握这些知识点，能够让你在C语言编程中游刃有余，尤其是在处理复杂数据结构、算法实现以及系统级编程时，指针的...
数据结构与算法-链表
iamsongyu的博客
09-14 378
链表 链表也是一个非常基本的数据结构，跟数组有很大的不同。 我们知道数组是占用连续内存的线性结构 ADD就是该数组的首地址，访问元素可以使用ADD【下标】。然而我们可以发现数组占用连续的空间，需要扩容的时候需要开辟更大的连续空间然后复制过去，并且当我们移除 插入元素时，需要遍历数组将元素进行前移补位和后移空位。数组虽然访问方便，但是对于这样的操作是在是太不友好了。 为了，出现了链表结构...
数据结构——链表（三）
Blankit1的博客
10-11 1161
链表 链表是有0个或多个相互间有连接的结点构成的。每个结点包含数据区和链接取（指针区） 1. 单链表 1.1 单链表的特性 这是通过单链表构成的一个数组Li = [200,400,600]] 每个结点的指针区指向下一个节点 最后一个节点指向None 链表有一个头指针 1.2 单链表支持的操作 链表由结点构成，在建链表前，新建结点类 结点类 class Node(object): de...
《C与指针》第十二章练习
weixin_30821731的博客
11-29 403
本章例程 //12.3 #include <stdio.h> #include <stdlib.h> typedef struct NODE{ struct NODE *link; int value; }Node; #define FALSE 0 #define TRUE 1 int sll_insert(registe...
c++ 智能指针示例 总结
清流弯弯
12-23 581
很多理论介绍的很好了，但看了后还是难以下手。 有时候实际的例子更有代入感，本文主要介绍项目中实际的智能指针应用例子。 一 局部函数中使用 几乎所有资料，介绍的都是智能指针在局部函数中的使用 0）直接定义方式 整形智能指针 unique_ptr<uint8_t> bits(new uint8_t[size.cx * size.cy * 4]).........
数据结构之双向链表----Python
程序员晓老九
07-16 158
双向链表 双向链表是指节点有三部分，数据、前向指针和后向指针。简单的图示可以参考看图轻松理解数据结构与算法系列(双向链表) 作者：程序员老九 掘金：https://juejin.im/post/5d1365c7e51d4510a73280f6 来源：请关注我的掘金博客 #定义一个节点类 class Node: def __init__(self,dataval): self.d...
内核双向循环链表
Lotuscc的博客
04-01 137
内核双向循环链表 普通的双向循环链表，一般将前向指针prevprevprev以及后向指针nextnextnext内嵌到特定的数据结构中。 再根据这种特定的结构编写插入，删除等函数。 struct myOrdinaryType { int data; struct myOrdinaryType *prev, *next; }; 这里介绍一种通用的双向循环链表，可以不依赖具体的数据类型。 struct list_entry_t { struct list_entry_t *prev,
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 117
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值