C语言单链表实现

最新推荐文章于 2022-11-26 11:32:38 发布
最新推荐文章于 2022-11-26 11:32:38 发布
阅读量538 收藏 1
点赞数 1
分类专栏： C语言数据结构 文章标签： 单链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huang7094748/article/details/51082052
版权

最近又用C语言把单链表重新写了一遍，在这个过程中学到了不少的东西，特别是C语言内存的具体分配过程、断言的使用、C语言函数参数的传递形式。
现在把我的代码贴出来供大家参考，还 望大家不吝赐教。 
/*
 *	Copyright  : 2015-2020 湖南农业大学 理学院
 * <span style="white-space:pre">	</span>File name  : link_list.c
 *	Description:
 *
 *	Author	   : Jack Huang
 *	Version	   : V1.0
 *	Date	   : Mar 28, 2016
 *
 *	History	   : 
 */
#include <assert.h>
#include <stdlib.h>
#include "link_list.h"


#undef  NDEBUG			// 调试模式


/**
 * @brief  对单链表的操作函数
 * @param
 * @retval
 */
void link_list_opreation(void)
{
	link_list *list_A = NULL;
	link_list *list_B = NULL;
	link_list *list_C = NULL;
	bool flag = false;
	Elemtype elem = 0;
	Elemtype *temp_elem = NULL;
	Elemtype data[20];
	int i = 0;

	for(i = 0; i < 20; i++)
	{
		data[i] = i;
	}
	// 输出标题
	printf("\t\tthis is a programm to test link list\n\n");
	// list_A 头表法建表
	list_A = create_link_list_tail(list_A, data, 20);
	// list_B 尾表法建表
	list_B = create_link_list_tail(list_B, data, 20);
	printf("create --- list_A is created by front_creator...\n\n");
	print_link_list(list_A);
	printf("create --- list_B is created by tail_creator...\n\n");
	print_link_list(list_B);
	// 取得单链表长度
	printf("1 --- get the length of list_A...\n");
	printf("reply --- the length of list_A = %d\n\n", get_link_list_length(list_A));

	// 查看单链表是否为空
	printf("2 --- Is the list_A is NULL?\n");

	flag = is_link_list_empty(list_A);
	if(flag == true)
	{
		printf("reply --- the answer is ture...\n\n");
	}
	else
	{
		printf("reply --- the answer is false...\n\n");
	}

	// 取得单链表元素
	printf("3 --- get the element form list_A...\n");
	flag = get_link_list_element(list_A, 2, &elem);
	if(flag == true)
	{
		printf("reply --- elem = %d\n\n", elem);
	}
	else
	{
		printf("reply --- failed...\n\n");
	}

	// 查找单链表元素 测试成功
	printf("4 --- find the element in link list...\n");
	// 返回数据域地址
	temp_elem = find_link_list_element(list_A, elem);
	if(temp_elem != NULL)
	{
		printf("reply --- temp_elem = %d\n\n", *temp_elem);
	}
	else
	{
		printf("reply --- failed...\n\n");
	}

	// 修改顺序表元素
	printf("5 --- modify element in link list...\n");
	flag = modify_link_list_element(list_A, 2, 300);
	if(flag == true)
	{
		get_link_list_element(list_A, 2, &elem);
		printf("reply --- the new value of element = %d\n\n", elem);
	}
	else
	{
		printf("reply --- failed...\n\n");
	}

	// 向单链表插入节点
	printf("6 --- insert elemnt to link list...\n");
	insert_link_list_element(list_A, 500, 11);
	flag = get_link_list_element(list_A, 11, &elem);
	if(flag == true)
	{
		printf("reply --- elem = %d\n\n", elem);
	}
	else
	{
		printf("reply --- failed...\n\n");
	}

	// 按位置删除单链表节点
	printf("7 --- delete elemnt by position...\n");
	flag = delete_link_list_element_by_index(list_A, 10, &elem);
	if(flag == true)
	{
		printf("reply --- list_A is fllowing...");
		print_link_list(list_A);
	}
	else
	{
		printf("reply --- failed\n\n");
	}

	// 按元素值删除单链表节点
	printf("8 --- delete element by value...\n");
	flag = delete_link_list_element_by_value(list_A, 300);
	if(flag == true)
	{
		printf("reply --- list_A is fllowing...\n");
		print_link_list(list_A);
	}
	else
	{
		printf("reply --- failed\n\n");
	}

	// 按元素顺序合并两个单链表
	printf("9 --- meger two srouce lists into a new sorted list...(need memory)\n");
	list_C = merge_link_list_need_memory(list_A, list_B, list_C);
	printf("reply...\n");
	print_link_list(list_C);

	printf("10 --- meger two srouce lists into a new sorted list...(don't need memory)\n");
	list_C = destory_link_list(list_C);
	list_C = merge_link_list_no_memory(list_A, list_B, list_C);
	printf("reply...\n");
	print_link_list(list_C);

	// 销毁单链表，释放堆内存
	printf("finish --- destory list_A and list_B...\n");
	list_A = destory_link_list(list_A);			// 返回NULL给list，杜绝野指针
	list_B = destory_link_list(list_B);
}


/**
 * @brief  头表法建表 已测试
 * @param
 * @retval
 */
link_list *create_link_list_front(link_list *list, Elemtype *data, int length)
{
	int i = 0;
	link_list *node = NULL;

	assert(list == NULL);
	assert(data != NULL);
	// 给头节点分配内存, 不能对指针参数修改其指向的地址，这样写有错误
	list = (link_list *)malloc(sizeof(link_list));
	assert(list != NULL);
	list->next = NULL;				// 头指针首先指向空
	for(i = 0; i < length; i++)
	{
		node = (link_list *)malloc(sizeof(link_list));	// 为新节点分配内存
		assert(node != NULL);		// 断言node分配内存是否成功
		node->data = *(data + i);	// 为新插入的节点数据域赋值
		node->next = list->next;	// 新节点接在头节点的后面
		list->next = node;			// 头节点next指针进行更新，指向新插入的元素
	}
	return list;
}



/**
 * @brief  尾表法建表	已测试
 * @param
 * @retval
 */
link_list *create_link_list_tail(link_list *list, Elemtype *data, int length)
{
	int i = 0;
	link_list *node = NULL;
	link_list *tail = NULL;				// 尾巴指针，始终指向表尾

	assert(list == NULL);
	assert(data != NULL);

	list = (link_list *)malloc(sizeof(link_list));
	tail = list;
	assert(list != NULL);
	list->next = NULL;

	for(i = 0; i < length; i++)
	{
		node = (link_list *)malloc(sizeof(link_list));
		node->data = *(data + i);		// 为新元素赋值
		tail->next = node;				// 将尾巴的next指针指向新元素
		tail = node;					// 更新尾巴指针
	}
	tail->next = NULL;					// 尾节点指向空
	return list;
}


/**
 * @brief  输出单链表	已测试
 * @param
 * @retval
 */
void print_link_list(link_list *list)
{
	int i = 0;
	link_list *node = NULL;				// 指向链表中的地第一个元素

	assert(list != NULL);
	node  = list->next;
	printf("the head address link list = %08x\n", list);
	while( node != NULL )				// 当前元素的地址不为空的，则有数据
	{
		printf("%d\t", node->data);
		if( (i + 1) % 8 == 0 )
		{
			printf("\n");
		}
		i++;
		node = node->next;
	}
	printf("\n\n");
}


/**
 * @beief  销毁单链表，释放堆内存 已测试
 * @param
 * @retval
 */
link_list *destory_link_list(link_list *list)
{
	link_list *node = NULL;
	assert(list != NULL);

	while(list->next != NULL)
	{
		node = list->next;		// 保存下一个节点的指针
		free(list);				// 释放表头内存
		list = node;			// 表头向下一个节点移动
	}
	list = NULL;
	return list;
}


/**
 * @beief  获取单链表数据长度 已测试
 * @param
 * @retval
 */
int get_link_list_length(link_list *list)
{
	int length = 0;
	link_list *node = NULL;

	assert(list != NULL);
	node = list->next;

	while(node != NULL)
	{
		length++;
		node = node->next;
	}
	return length;
}



/**
 * @brief  查看单链表是否为空
 * @param
 * @retval
 */
bool is_link_list_empty(link_list *list)
{
	assert(list != NULL);

	if(list->next != NULL)
	{
		return false;
	}
	return true;
}



/**
 * @brief  取得单链表确定位置的元素,从0开始
 * @param
 * @retval
 */
bool get_link_list_element(link_list *list, int index, Elemtype *element)
{
	int i = 0;
	link_list *node = NULL;

	assert(list != NULL);
	node = list->next;
	while( (node != NULL) && (i < index) )
	{
		i ++;
		node = node->next;
	}
	// 判断是否找到元素
	if( node == NULL )
	{
		return false;
	}
	*element = node->data;
	return true;
}




/**
 * @brief  查询顺序中的元素,查询成功返回数据域地址
 * @param
 * @retval
 */
Elemtype *find_link_list_element(link_list *list, Elemtype e)
{
	link_list *node = NULL;

	assert(list != NULL);
	node = list->next;

	while( (node != NULL) && (node->data != e) )
	{
		node = node->next;
	}

	if(node == NULL)
	{
		return NULL;
	}
	return &(node->data);
}




/**
 * @brief  修改指定位置元素的数据域
 * @param
 * @retval
 */
bool modify_link_list_element(link_list *list, int index, Elemtype new_data)
{
	int i = 0;
	link_list *node = NULL;

	assert(list != NULL);
	assert(index >= 0);
	node = list->next;

	while( (i < index) && (node != NULL) )
	{
		i++;
		node = node->next;
	}
	// 判断是否修改错误
	if(node == NULL)
	{
		return false;
	}
	node->data = new_data;
	return true;
}



/**
 * @brief  向单链表插入一个元素
 * @param
 * @retval
 */
bool insert_link_list_element(link_list *list, Elemtype data, int index)
{
	int i = 0;
	link_list *node = NULL;
	link_list *new_node = NULL;

	assert(list != NULL);
	assert(index >= 0);
	assert(index < get_link_list_length(list));
	node = list;

	while( (node != NULL) && (i < index) )
	{
		i++;
		node = node->next;
	}
	// 插入不成功
	if(node == NULL)
	{
		return false;
	}
	new_node = (link_list *)malloc(sizeof(link_list));
	assert(new_node != NULL);
	// 插入到单链表中
	new_node->next = node->next;
	node->next = new_node;
	new_node->data = data;
	return true;
}



/**
 * @brief  在单链表中删除一个元素
 * @param
 * @retval
 */
bool delete_link_list_element_by_index(link_list *list, int index, Elemtype *e)
{
	int i = 0;
	link_list *node = NULL;
	link_list *temp = NULL;
	assert(list != NULL);
	node = list->next;

	while( (node != NULL) && (i < index) )
	{
		i++;
		node = node->next;
	}
	if(node == NULL)
	{
		return false;
	}

	temp = node->next;
	node->next = temp->next;
	*e = temp->data;
	free(temp);
	temp = NULL;
	return true;
}



/**
 * @brief  在单链表中删除值为data的元素
 * @param
 * @retval
 */
bool delete_link_list_element_by_value(link_list *list, Elemtype data)
{
	link_list *node;
	link_list *temp;

	assert(list != NULL);
	node = list;

	while(node->next != NULL)
	{
		if(node->next->data == data)
		{
			temp = node->next;
			node->next = temp->next;
			free(temp);
			temp = NULL;
		}
		node = node->next;
	}
	return true;
}



/**
 * @brief  按照元素顺序合并两个有序单链表到一个新的有序单链表
 * 		   需要开辟新的空间
 * @param
 * @retval
 */
link_list  *merge_link_list_need_memory(link_list *list_src_a,
					link_list *list_src_b,
					link_list *list_destination)
{
	link_list *p_src_a = NULL;
	link_list *p_src_b = NULL;
	link_list *temp_elem = NULL;
	link_list *tail = NULL;

	assert(list_src_a->next != NULL);
	assert(list_src_b->next != NULL);
	assert(list_destination == NULL);

	p_src_a = list_src_a->next;
	p_src_b = list_src_b->next;
	// 初始化目的单链表
	list_destination = (link_list *)malloc(sizeof(link_list));
	assert(list_destination != NULL);
	// 尾巴指针初始化
	tail = list_destination;

	while( (p_src_a != NULL) && (p_src_b != NULL) )
	{
		// 给新节点分配内存
		temp_elem = (link_list *)malloc(sizeof(link_list));
		// 给新节点赋值
		if( p_src_a->data < p_src_b ->data )
		{
			temp_elem->data = p_src_a->data;
			p_src_a = p_src_a->next;
		}
		else
		{
			temp_elem->data = p_src_b->data;
			p_src_b = p_src_b->next;
		}
		tail->next = temp_elem;
		tail = temp_elem;
	}

	while(p_src_a != NULL)
	{
		temp_elem = (link_list *)malloc(sizeof(link_list));
		temp_elem->data = p_src_a->data;
		tail->next = temp_elem;
		tail = temp_elem;
		p_src_a = p_src_a->next;
	}

	while(p_src_b != NULL)
	{
		temp_elem = (link_list *)malloc(sizeof(link_list));
		temp_elem->data = p_src_b->data;
		tail->next = temp_elem;
		tail = temp_elem;
		p_src_b = p_src_b->next;
	}

	return list_destination;
}



/**
 * @brief  按照元素顺序合并两个有序单链表到一个新的有序单链表
 * 		   不需要开辟新的空间
 * @param
 * @retval
 */
link_list  *merge_link_list_no_memory(link_list *list_src_a,
				      link_list *list_src_b,
				      link_list *list_destination)
{
	link_list *p_src_a = NULL;
	link_list *p_src_b = NULL;
	link_list *tail = NULL;

	// 对参数进行处理
	assert(list_src_a->next != NULL);
	assert(list_src_b->next != NULL);
	assert(list_destination == NULL);
	// 为局部变量赋初值
	p_src_a = list_src_a->next;
	p_src_b = list_src_b->next;
	list_destination = list_src_a;
	tail = list_destination;
	// 开始插入元素
	while( (p_src_a != NULL) && (p_src_b != NULL) )
	{
		if(p_src_a->data < p_src_b->data)
		{
			tail->next = p_src_a;
			tail = p_src_a;
			p_src_a = p_src_a->next;
		}
		else
		{
			tail->next = p_src_b;
			tail = p_src_b;
			p_src_b = p_src_b->next;
		}
	}
	// 放入剩下的元素
	tail->next = p_src_a ? p_src_a : p_src_b;
	return list_destination;
}







<pre name="code" class="cpp">/*
 *	Copyright  : 2015-2020 湖南农业大学 理学院
 *  File name  : link_list.h
 *	Description:
 *
 *	Author	   : Jack Huang
 *	Version	   : 
 *	Date	   : Mar 28, 2016
 *
 *	History	   : 
 */

#ifndef LINK_LIST_H_
#define LINK_LIST_H_

#include <stdio.h>


#define MAX_SZIE 100	// 最大数据长度
#define	not_find		(int)-1
#define false 			(int)1
#define true 			(int)0

typedef int 			bool;
typedef int 			Elemtype;

typedef struct link_node
{
	Elemtype data;
	// 这是C语言中唯一允许的先使用后定义的数据结构
	struct link_node *next;
}link_list;



void link_list_opreation(void);														// 对单链表的操作函数
link_list *create_link_list_front(link_list *list, Elemtype *data, int length);		// 头插法建表
link_list *create_link_list_tail(link_list *list, Elemtype *data, int length);		// 尾插法建表
link_list *destory_link_list(link_list *list);										// 销毁单链表
bool get_link_list_element(link_list *list, int index, Elemtype *element);			// 查找单链表某个位置上的元素
int  get_link_list_length(link_list *list);											// 获取单链表数据长度
bool is_link_list_empty(link_list *list);											// 查看单链表是否为空
Elemtype *find_link_list_element(link_list *list, Elemtype e);						// 查询单链表
bool modify_link_list_element(link_list *list, int index, Elemtype new_data);
bool insert_link_list_element(link_list *list, Elemtype data, int index);			// 向单链表插入一个元素
bool delete_link_list_element_by_index(link_list *list, int index, Elemtype *e);	// 删除一个指定位置的元素，返回删除的值
bool delete_link_list_element_by_value(link_list *list, Elemtype data);				// 删除一个指定数据的元素
void print_link_list(link_list *list);												// 输出单链表
link_list *merge_link_list_need_memory(link_list *list_src_a, link_list *list_src_b, link_list *list_destination);
link_list *merge_link_list_no_memory(link_list *list_src_a, link_list *list_src_b, link_list *list_destination);

#endif /* LINK_LIST_H_ */


 

 

 
  

 

 


                

        

        

    




    

      

        

            

              
                
                  JackHuang21
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    1
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
C语言 单链表的实现

				
			

			

				

					06-28
				

			

		

		

			
				
(1)熟悉将算法转换为程序代码的过程。 (2)了解顺序表的逻辑结构特性，熟练学握顺序表存储结构的 C 语言描述方法。 (3)熟练学握顺序表的基本运算:查找、插入、删除等，学握顺序表的随机存取特性。 (4)了解线性表的链式存储结构，熟练学握线性表的链式存储结构的 C 语言描述方法。 (5)熟练掌握线性链表(单链表)的基本运算:查找、插入、删除等，能在实际应用中灵活选择适当的链表结构。

			
		

	



                

              
                



	

		

			

				
					
[数据结构]C语言链表实现

				
			

			

				

					shenghua
				

				

					12-26
					
					340
					
				

			

		

		

			
				
[数据结构]C语言链表实现http://www.cnblogs.com/racaljk/p/7822311.html





目录
  静态单链表实现
  动态单链表实现
  双向链表实现
  循环单链表





我学数据结构的时候也是感觉很困难，当我学完后我发现了之所以困难时因为我没有系统的进行学习，而且很多教授都只是注重数据结构思想，而忽略了代码方面，为此我

			
		

	



                


  
              

                


	

		

			

				
					
c语言单链表的实现,C语言 单链表的实现

				
			

			

				

					weixin_42514711的博客
				

				

					05-19
					
					268
					
				

			

		

		

			
				
链表由多个节点构成，节点之间可以灵活的插入、删除。链表以结构体的自引用原理，可以在内存中以不连续的方式动态分配内存来存储数据，这样的结构体就是链表的一个节点。 一个节点分为两个域：一个是数据域，一个是指针域，这方便链表在存储数据的同时可以方便地找到下一个节点。相比于数组：数组定义相对简单些，是以连续的内存存储数据，在定义时就确定了长度，这样相比于链表的动态存储，数组就存在有可能数据不够长或内存浪费...

			
		

	





	

		

			

				
					
C语言单链表的实现

				
			

			

				

					12-08
				

			

		

		

			
				
做了个简单的单链表实现，基本的功能都齐全了。而且我习惯附上详细的注释，应该对初学者蛮友好的了。

			
		

	



		

			
		



	

		

			

				
					
C语言单链表实现多项式相加

				
			

			

				

					08-29
				

			

		

		

			
				
主要为大家详细介绍了C语言单链表实现多项式相加，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

			
		

	





	

		

			

				
					
C语言单链表实现方法详解

				
			

			

				

					08-27
				

			

		

		

			
				
主要介绍了C语言单链表实现方法,结合实例形式分析了基于C语言的单链表定义、创建、添加、删除、排序、打印等操作技巧,并附带了相关的优化算法,需要的朋友可以参考下

			
		

	





	

		

			

				
					
C语言单链表实现19个功能完全详解.zip_C语言_C语言单链表_单链表

				
			

			

				

					09-20
				

			

		

		

			
				
C语言单链表，实现19个不同功能的完全详细解答

			
		

	





	

		

			

				
					
C语言实现单链表

				
			

			

				

					m0_60447315的博客
				

				

					03-20
					
					1819
					
				

			

		

		

			
				
📋 个人简介
💖 作者简介：大家好，我是菀枯😜
🎉 支持我：点赞👍+收藏⭐️+留言📝
💬格言：不要在低谷沉沦自己，不要在高峰上放弃努力！☀️
一.为什么使用链表
在学习链表以前，我们存储数据用的方式就是数组。使用数组的好处就是便于查找数据，但缺点也很明显。


使用前需声明数组的长度，一旦声明长度就不能更改
插入和删除操作需要移动大量的数组元素，效率慢
只能存储一种类型的数据.


为了解决上述的问题，我们就可以使用链表来存储数据。
二.链表的概念

概念：链表是一种物理存储结构上非连续、

			
		

	





	

		

			

				
					
单链表的实现（c 语言）

				
			

			

				

					MT_125的博客
				

				

					04-27
					
					2065
					
				

			

		

		

			
				
单链表的实现（附详细图解）！！！

			
		

	





	

		

			

				
					
单链表的实现（C语言）

				
			

			

				

					weixin_57604904的博客
				

				

					10-11
					
					1238
					
				

			

		

		

			
				
单链表的实现

			
		

	





	

		

			

				
					
【C语言】单链表的实现

				
			

			

				

					Skanda_victor的博客
				

				

					09-15
					
					210
					
				

			

		

		

			
				
1、创建个节点并初始化，返回该节点地址


single_list* create_node(void)
{
    single_list *phead = (single_list *)xmalloc(sizeof(single_list));
    phead->data = 0;
    phead->next = NULL;

    return phead;
}

2、创建链表（前插法）


/*
   操作前：空链表存在
   操作后：创建了一个链表
*/
Status cre

			
		

	





	

		

			

				
					
用c语言实现单链表

				
			

			

				

					gunqu_d的博客
				

				

					09-26
					
					326
					
				

			

		

		

			
				
用c语言实现单链表

Node.h

#pragma once
typedef int DataType;
typedef struct Node
{
	DataType data;
	struct Node* next;
}Node;

Node* BuyNode(DataType x); //增容
void PrintList(Node* pHead); //打印
void PushBack(

			
		

	





	

		

			

				
					
基于C语言的单链表实现

				
			

			

				

					qq_43446131的博客
				

				

					04-04
					
					1217
					
				

			

		

		

			
				
->Gitee源代码点击这里<-
单链表是由不连续的空间组合而成的。每个空间称为单链表的一个结点。
一个结点中除了存放数据之外，还要存放下一个结点的地址，如果没有下一个结点，则存放空指针。表示其后面没有结点了

从逻辑上来看，就好像A和B链接了起来。
我们通过结构体来定义链表的结点信息
typedef int LDataType;
typedef struct LinkedList
{
	LDataType data;        //数据值
	struct LinkedList* next;

			
		

	





	

		

			

				
					
C语言实现——单链表

				
			

			

				

					学习C++的小陈同学
				

				

					11-26
					
					1023
					
				

			

		

		

			
				
本篇用C语言实现了一个最基本的单链表，逐步对每一步进行了分析和设计，捋清楚了链表的实现思路，并且附上了代码

			
		

	





	

		

			

				
					
c语言单链表实现一元多项式相加

					
最新发布

				
			

			

				

					04-21
				

			

		

		

			
				
代码实现可参考下面示例：  ``` #include  #include   typedef struct node {  int coeff; //系数  int expn; //指数  struct node *next; } Node;  Node* CreateList(); //创建链表 Node* InputPoly(); //输入一元...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值