c++ vector 自定义排序的问题

最新推荐文章于 2024-06-01 10:21:14 发布
最新推荐文章于 2024-06-01 10:21:14 发布
阅读量714 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
原文链接：https://blog.csdn.net/aastoneaa/article/details/8471722
版权

如果要自己定义STL容器的元素类最好满足STL容器对元素的要求
    必须要求：
     1、Copy构造函数
     2、赋值=操作符
     3、能够销毁对象的析构函数
    另外：
     1、可用的缺省构造函数，序列型容器必须，用于初始化元素
     2、==操作符定义，用于判断相等
     3、<操作符定义，关联型容器必须，用于缺省排序

你可在struct內加入 operator < ,就可以使struct有排序能力.
因為而你的pcd struct內沒有指針,所以不須要有copy constructor
和copy assignment, 編譯器會為你提供的, 你不須要自己做的.
當你要排序時只要寫 sort( obj.begin(), obj.end() )就可.

以上内容取自帖子：如何用std::sort对自定义结构的vector以关键字来排序-CSDN论坛

另一篇参考地址：vector元素为自定义结构体类型时如何对容器元素进行排序？_浮城大亨的专栏-CSDN博客_vector 自定义排序

以下取自帖子：stl vector排序_guang11cheng的专栏-CSDN博客_stl vector 排序

三种方式实现vector的自定义排序

方法1：重载运算符

 

  1.  
    #include <vector>
     
  2.  
    #include <algorithm>
     
  3.  
    #include <functional>
     
  5.  
    using namespace std;
     
  6.  
    struct TItem
     
  7.  
    {
     
  8.  
    int m_i32Type;
     
  9.  
    int m_i32ID;
     
  11.  
    bool operator <(const TItem& rhs) const // 升序排序时必须写的函数
     
  12.  
    {
     
  13.  
    return m_i32Type < rhs.m_i32Type;
     
  14.  
    }
     
  15.  
    bool operator >(const TItem& rhs) const // 降序排序时必须写的函数
     
  16.  
    {
     
  17.  
    return m_i32Type > rhs.m_i32Type;
     
  18.  
    }
     
  19.  
    };
     
  20.  
    int main()
     
  21.  
    {
     
  22.  
    vector<TItem> stItemVec;
     
  25.  
    TItem stItem1;
     
  26.  
    stItem1.m_i32Type = 1;
     
  27.  
    stItem1.m_i32ID = 1;
     
  29.  
    TItem stItem2;
     
  30.  
    stItem2.m_i32Type = 2;
     
  31.  
    stItem2.m_i32ID = 2;
     
  33.  
    TItem stItem3;
     
  34.  
    stItem3.m_i32Type = 3;
     
  35.  
    stItem3.m_i32ID = 3;
     
  37.  
    TItem stItem4;
     
  38.  
    stItem4.m_i32Type = 2;
     
  39.  
    stItem4.m_i32ID = 4;
     
  41.  
    stItemVec.push_back(stItem1);
     
  42.  
    stItemVec.push_back(stItem2);
     
  43.  
    stItemVec.push_back(stItem3);
     
  44.  
    stItemVec.push_back(stItem4);
     
  46.  
    // 升序排序
     
  47.  
    sort(stItemVec.begin(), stItemVec.end(), less<TItem>()); 
     
  48.  
    // 或者sort(ctn.begin(), ctn.end()); 默认情况为升序
     
  50.  
    for (size_t i = 0; i < stItemVec.size(); i++)
     
  51.  
    printf("type: %d, id: %d\n", stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
     
  53.  
    printf("--\n");
     
  55.  
    // 降序排序
     
  56.  
    sort(stItemVec.begin(), stItemVec.end(), greater<TItem>());
     
  58.  
    for (size_t i = 0; i < stItemVec.size(); i++)
     
  59.  
    printf("type: %d, id: %d\n", stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
     
  61.  
    return 0;
     
  62.  
    }
     
 

 

  方法2：全局的比较函数
 

 

 

 

  1.  
    #include <vector>
     
  2.  
    #include <algorithm>
     
  3.  
    #include <functional>
     
  6.  
    using namespace std;
     
  9.  
    struct TItem
     
  10.  
    {
     
  11.  
    int m_i32Type;
     
  12.  
    int m_i32ID;
     
  13.  
    };
     
  16.  
    bool lessmark(const TItem& stItem1, const TItem& stItem2)
     
  17.  
    {
     
  18.  
    return stItem1.m_i32Type < stItem2.m_i32Type;
     
  19.  
    }
     
  22.  
    bool greatermark(const TItem& stItem1, const TItem& stItem2)
     
  23.  
    {
     
  24.  
    return stItem1.m_i32Type > stItem2.m_i32Type;
     
  25.  
    }
     
  28.  
    int main()
     
  29.  
    {
     
  30.  
    vector<TItem> stItemVec;
     
  33.  
    TItem stItem1;
     
  34.  
    stItem1.m_i32Type = 1;
     
  35.  
    stItem1.m_i32ID = 1;
     
  38.  
    TItem stItem2;
     
  39.  
    stItem2.m_i32Type = 2;
     
  40.  
    stItem2.m_i32ID = 2;
     
  43.  
    TItem stItem3;
     
  44.  
    stItem3.m_i32Type = 3;
     
  45.  
    stItem3.m_i32ID = 3;
     
  48.  
    TItem stItem4;
     
  49.  
    stItem4.m_i32Type = 2;
     
  50.  
    stItem4.m_i32ID = 4;
     
  53.  
    stItemVec.push_back(stItem1);
     
  54.  
    stItemVec.push_back(stItem2);
     
  55.  
    stItemVec.push_back(stItem3);
     
  56.  
    stItemVec.push_back(stItem4);
     
  59.  
    sort(stItemVec.begin(), stItemVec.end(), lessmark); //升序排序
     
  62.  
    for (size_t i = 0; i < stItemVec.size(); i++)
     
  63.  
    printf("type: %d, id: %d\n", stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
     
  66.  
    printf("--\n");
     
  69.  
    sort(stItemVec.begin(), stItemVec.end(), greatermark); //降序排序
     
  72.  
    for (size_t i = 0; i < stItemVec.size(); i++)
     
  73.  
    printf("type: %d, id: %d\n", stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
     
  76.  
    return 0;
     
  77.  
    }
     
 

 

方法3：函数对象
 

 

 

 

  1.  
    #include <vector>
     
  2.  
    #include <algorithm>
     
  3.  
    #include <functional>
     
  6.  
    using namespace std;
     
  9.  
    struct TItem
     
  10.  
    {
     
  11.  
    int m_i32Type;
     
  12.  
    int m_i32ID;
     
  13.  
    };
     
  16.  
    class CompLess
     
  17.  
    {
     
  18.  
    public:
     
  19.  
    bool operator ()(const TItem& stItem1, const TItem& stItem2)
     
  20.  
    {
     
  21.  
    return stItem1.m_i32Type < stItem2.m_i32Type;
     
  22.  
    }
     
  23.  
    };
     
  26.  
    class CompGreater
     
  27.  
    {
     
  28.  
    public:
     
  29.  
    bool operator ()(const TItem& stItem1, const TItem& stItem2)
     
  30.  
    {
     
  31.  
    return stItem1.m_i32Type > stItem2.m_i32Type;
     
  32.  
    }
     
  33.  
    };
     
  36.  
    int main()
     
  37.  
    {
     
  38.  
    vector<TItem> stItemVec;
     
  41.  
    TItem stItem1;
     
  42.  
    stItem1.m_i32Type = 1;
     
  43.  
    stItem1.m_i32ID = 1;
     
  46.  
    TItem stItem2;
     
  47.  
    stItem2.m_i32Type = 2;
     
  48.  
    stItem2.m_i32ID = 2;
     
  51.  
    TItem stItem3;
     
  52.  
    stItem3.m_i32Type = 3;
     
  53.  
    stItem3.m_i32ID = 3;
     
  56.  
    TItem stItem4;
     
  57.  
    stItem4.m_i32Type = 2;
     
  58.  
    stItem4.m_i32ID = 4;
     
  61.  
    stItemVec.push_back(stItem1);
     
  62.  
    stItemVec.push_back(stItem2);
     
  63.  
    stItemVec.push_back(stItem3);
     
  64.  
    stItemVec.push_back(stItem4);
     
  67.  
    sort(stItemVec.begin(), stItemVec.end(), CompLess()); //升序排序
     
  70.  
    for (size_t i = 0; i < stItemVec.size(); i++)
     
  71.  
    printf("type: %d, id: %d\n", stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
     
  74.  
    printf("--\n");
     
  77.  
    sort(stItemVec.begin(), stItemVec.end(), CompGreater()); //降序排序
     
  80.  
    for (size_t i = 0; i < stItemVec.size(); i++)
     
  81.  
    printf("type: %d, id: %d\n", stItemVec[i].m_i32Type, stItemVec[i].m_i32ID);
     
  84.  
    return 0;
     
  85.  
    }
     
  88.  
    /*
     
  89.  
    结果如下：
     
  90.  
    type: 1, id: 1
     
  91.  
    type: 2, id: 2
     
  92.  
    type: 2, id: 4
     
  93.  
    type: 3, id: 3
     
  94.  
    --
     
  95.  
    type: 3, id: 3
     
  96.  
    type: 2, id: 2
     
  97.  
    type: 2, id: 4
     
  98.  
    type: 1, id: 1
     
  99.  
    可以看出vector的sort的稳定的。
     
  100.  
    */
     
 

问题：
 

1，示例代码中只有>和<关系处理，==关系是如何推导出来的？
 

2，排序时要移动元素，效率怎样？
 

3，如果自定义结构定义在一个类的内部，使用函数对象进行排序，这个函数对象可以作为类的成员函数吗？
 

4，在上面的例子中，vector中存放的都是结构（对象）本身，如果存放的是结构指针，该如何排序呢？此时只能通过全局的比较函数或者函数对象来做，且比较函数的参数要是指针类型的，如下：
 

（1）全局的比较函数
 

 

  1.  
    #include <vector>
     
  2.  
    #include <algorithm>
     
  3.  
    #include <functional>
     
  6.  
    using namespace std;
     
  9.  
    struct TItem
     
  10.  
    {
     
  11.  
    int m_i32Type;
     
  12.  
    int m_i32ID;
     
  13.  
    };
     
  16.  
    bool CompLess(const TItem* pstItem1, const TItem* pstItem2)
     
  17.  
    {
     
  18.  
    return pstItem1->m_i32Type < pstItem2->m_i32Type;
     
  19.  
    }
     
  22.  
    bool CompGreater(const TItem* pstItem1, const TItem* pstItem2)
     
  23.  
    {
     
  24.  
    return pstItem1->m_i32Type > pstItem2->m_i32Type;
     
  25.  
    }
     
  28.  
    int main()
     
  29.  
    {
     
  30.  
    vector<TItem*> stItemVec;
     
  33.  
    TItem stItem1;
     
  34.  
    stItem1.m_i32Type = 1;
     
  35.  
    stItem1.m_i32ID = 1;
     
  38.  
    TItem stItem2;
     
  39.  
    stItem2.m_i32Type = 2;
     
  40.  
    stItem2.m_i32ID = 2;
     
  43.  
    TItem stItem3;
     
  44.  
    stItem3.m_i32Type = 3;
     
  45.  
    stItem3.m_i32ID = 3;
     
  48.  
    TItem stItem4;
     
  49.  
    stItem4.m_i32Type = 2;
     
  50.  
    stItem4.m_i32ID = 4;
     
  53.  
    stItemVec.push_back(&stItem1);
     
  54.  
    stItemVec.push_back(&stItem2);
     
  55.  
    stItemVec.push_back(&stItem3);
     
  56.  
    stItemVec.push_back(&stItem4);
     
  59.  
    sort(stItemVec.begin(), stItemVec.end(), CompLess); //升序排序
     
  62.  
    for (size_t i = 0; i < stItemVec.size(); i++)
     
  63.  
    printf("type: %d, id: %d\n", stItemVec[i]->m_i32Type, stItemVec[i]->m_i32ID);
     
  66.  
    printf("--\n");
     
  69.  
    sort(stItemVec.begin(), stItemVec.end(), CompGreater); //降序排序
     
  72.  
    for (size_t i = 0; i < stItemVec.size(); i++)
     
  73.  
    printf("type: %d, id: %d\n", stItemVec[i]->m_i32Type, stItemVec[i]->m_i32ID);
     
  75.  
    return 0;
     
  76.  
    }
     
 

（2）函数对象
 

 

  1.  
    #include <vector>
     
  2.  
    #include <algorithm>
     
  3.  
    #include <functional>
     
  6.  
    using namespace std;
     
  9.  
    struct TItem
     
  10.  
    {
     
  11.  
    int m_i32Type;
     
  12.  
    int m_i32ID;
     
  13.  
    };
     
  16.  
    class CompLess
     
  17.  
    {
     
  18.  
    public:
     
  19.  
    bool operator ()(const TItem* pstItem1, const TItem* pstItem2)
     
  20.  
    {
     
  21.  
    return pstItem1->m_i32Type < pstItem2->m_i32Type;
     
  22.  
    }
     
  23.  
    };
     
  26.  
    class CompGreater
     
  27.  
    {
     
  28.  
    public:
     
  29.  
    bool operator ()(const TItem* pstItem1, const TItem* pstItem2)
     
  30.  
    {
     
  31.  
    return pstItem1->m_i32Type > pstItem2->m_i32Type;
     
  32.  
    }
     
  33.  
    };
     
  36.  
    int main()
     
  37.  
    {
     
  38.  
    vector<TItem*> stItemVec;
     
  41.  
    TItem stItem1;
     
  42.  
    stItem1.m_i32Type = 1;
     
  43.  
    stItem1.m_i32ID = 1;
     
  46.  
    TItem stItem2;
     
  47.  
    stItem2.m_i32Type = 2;
     
  48.  
    stItem2.m_i32ID = 2;
     
  51.  
    TItem stItem3;
     
  52.  
    stItem3.m_i32Type = 3;
     
  53.  
    stItem3.m_i32ID = 3;
     
  56.  
    TItem stItem4;
     
  57.  
    stItem4.m_i32Type = 2;
     
  58.  
    stItem4.m_i32ID = 4;
     
  61.  
    stItemVec.push_back(&stItem1);
     
  62.  
    stItemVec.push_back(&stItem2);
     
  63.  
    stItemVec.push_back(&stItem3);
     
  64.  
    stItemVec.push_back(&stItem4);
     
  67.  
    sort(stItemVec.begin(), stItemVec.end(), CompLess()); //升序排序
     
  70.  
    for (size_t i = 0; i < stItemVec.size(); i++)
     
  71.  
    printf("type: %d, id: %d\n", stItemVec[i]->m_i32Type, stItemVec[i]->m_i32ID);
     
  74.  
    printf("--\n");
     
  77.  
    sort(stItemVec.begin(), stItemVec.end(), CompGreater()); //降序排序
     
  80.  
    for (size_t i = 0; i < stItemVec.size(); i++)
     
  81.  
    printf("type: %d, id: %d\n", stItemVec[i]->m_i32Type, stItemVec[i]->m_i32ID);
     
  84.  
    return 0;
     
  85.  
    }
     
 

推荐使用函数对象。

                

        

        

    




    

      

        

            

              
                
                  Grace、
                
              
            

            

                关注
              
            

        

        

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

      

      

            

                专栏目录
          










                



	

		

			

				
					
【C++】vector数组排序

				
			

			

				

					taoxing
				

				

					05-23
					
					4万+
					
				

			

		

		

			
				
目录一.简单升序排序（1）准备（2）函数格式（3）完整代码（4）结果二.简单降序排序（1）函数格式（2）完整代码（3）结果三.自定义函数排序（1）函数格式（2）代码（3）结果

最近刷力扣的时候遇到了好多vector数组自定义排序问题，这里先来总结一下。


vector是C++的STL中一个重要的容器嘛，STL不用说也知道它的功能十分强大，所以有一些内置排序函数。下面来细说一下。

一.简单升序排序
（1）准备

vector头文件，用来引入vector数组


algorithm头文件，用来引入sort

			
		

	



                

              
                



	

		

			

				
					
C++ vector 自定义排序规则（vector＜vector＜int＞＞、vector＜pair＜int,int＞＞）

				
			

			

				

					hero_th的博客
				

				

					10-11
					
					5178
					
				

			

		

		

			
				
平时的编译器里面自己写的时候 cmp函数前面加不加static都行，但是leetcode刷题时，代码还有实现都是写在类里面的，cmp函数前面一定要加上static修饰。因此建议所有的返回类型都为static bool 类型。这里不能使用C++11中的auto关键词进行自动类型推导C++ sort函数自定义cmp函数中参数带&符号//如果第一元素相等，则比较第二元素。

			
		

	



                


  
              

                


	

		

			

				
					
c++对vector容器中的自定义对象进行排序（sort）

					
最新发布

				
			

			

				

					qq_42680785的博客
				

				

					06-01
					
					231
					
				

			

		

		

			
				
【代码】c++对vector容器中的自定义对象进行排序（sort）

			
		

	





	

		

			

				
					
vector 的自定义排序方法

				
			

			

				

					qq_31610789的博客
				

				

					08-30
					
					1823
					
				

			

		

		

			
				
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

bool compare(const pair<int, float> A, const pair<int, float> B) {
    return A.second &lt...

			
		

	



		

			
		



	

		

			

				
					
浅谈数据结构vector

				
			

			

				

					weixin_30337157的博客
				

				

					03-25
					
					209
					
				

			

		

		

			
				
vector: 又名 向量

1.C++中的一种数据结构。
2.是一个类。
3.相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的。


A.使用时,加上头文件和命名空间即可：
#include<vector>
    using namespace std;

...

			
		

	





	

		

			

				
					
C++自定义结构体排序实现

				
			

			

				

					05-30
				

			

		

		

			
				
"C++自定义结构体排序实现"  C++中的结构体排序是指对自定义结构体类型的数据进行排序操作。排序是按照某个键值进行的，例如结构体中的某个成员变量。下面我们将介绍两种实现结构体排序的方法。  一、使用重载运算符...

			
		

	





	

		

			

				
					
C++重构vector

				
			

			

				

					05-04
				

			

		

		

			
				
- **定制化操作**：根据项目需求添加特定的成员函数，比如自定义排序、查找算法等。 - **调试支持**：增加调试信息，如边界检查，以帮助在开发过程中发现潜在问题。  总之，"C++重构vector"是为了满足特定场景下的...

			
		

	





	

		

			

				
					
C++中vector可以作为map的键值实例代码

				
			

			

				

					08-30
				

			

		

		

			
				
本文介绍了如何使用vector作为map的键值实例代码，解决了C++中map容器的键值类型限制问题。该方法可以广泛应用于实际开发中，例如在项目中根据状态找到一个对应的结果时，可以使用map容器来存储状态和结果之间的映射...

			
		

	





	

		

			

				
					
C++:快速排序算法

				
			

			

				

					12-24
				

			

		

		

			
				
`std::swap`用于交换元素，`std::sort`可以用来验证自定义排序函数的效果。  7. **性能优化**：为了提高快速排序的性能，可以采用三数取中法来选择基准，即取首、尾、中间三个元素的中位数作为基准，以减少划分的不...

			
		

	





	

		

			

				
					
排序

				
			

			

				

					07-13
				

			

		

		

			
				
《C++标准库中的<vector>排序详解》  在C++编程中，容器是管理对象集合的重要工具，其中<vector>作为最常用的序列容器之一，提供了高效、灵活的数据存储和操作方式。本文将深入探讨如何对<vector>进行排序，帮助...

			
		

	





	

		

			

				
					
C++ 对vector 排序

				
			

			

				

					Black_Friend的博客
				

				

					07-16
					
					9446
					
				

			

		

		

			
				
本人也是一个C++的小白，这个就是我在参照了他们（那很多很多优秀的人）的代码后，自己整理的，嗯，这个地方我上学的时候他们ACM的就经常用，可是那时候，我是冒泡排序的忠实粉丝，就是自己非得用自己的方法把想弄得弄出来。
下面是我总结的，我发现好像是可以用的。
1、单独一个vector的排序：
bool cmp(double v1,double v2)
{
	return v1>v2
}

vector<double> vect1;
//这里要给两个vector赋值。
vect1.push_ba

			
		

	





	

		

			

				
					
c++ vector 实现自定义排序

				
			

			

				

					qq_36470475的博客
				

				

					08-30
					
					521
					
				

			

		

		

			
				
c++ vector 实现自定义排序

			
		

	





	

		

			

				
					
自定义结构体vector的排序

				
			

			

				

					Smile&搁浅
				

				

					07-29
					
					3546
					
				

			

		

		

			
				
C++中当 vector 中的数据类型为基本类型时我们调用std::sort函数很容易实现 vector中数据成员的升序和降序排序，然而当vector中的数据类型为自定义结构体类型时，我们该怎样实现升序与降序排列呢？有两种方法，下面的例子能很好的说明：
  方法1： 我们直接来看代码吧，比较简单，容易理解：
#include "stdafx.h"
#include   
#include   

			
		

	





	

		

			

				
					
关于C++中vector和set使用sort方法进行排序

				
			

			

				

					周晓松的个人主页
				

				

					06-04
					
					344
					
				

			

		

		

			
				
C++中vector和set都是非常方便的容器，
sort方法是algorithm头文件里的一个标准函数，能进行高效的排序，默认是按元素从小到大排序
将sort方法用到vector和set中能实现多种符合自己需求的排序
首先sort方法可以对静态的数组进行排序

1 #include<iostream>
2 using namespace std;
3 int main(){...

			
		

	





	

		

			

				
					
C++ vector的排序------对于结构体vector， 需要自己实现比较

				
			

			

				

					sjhfkhsf的博客
				

				

					02-26
					
					677
					
				

			

		

		

			
				
C++ vector的排序------对于结构体vector， 需要自己实现比较

			
		

	





	

		

			

				
					
C++:利用sort()对vector中的数据自定义排序

				
			

			

				

					己亥谷雨
				

				

					03-29
					
					2276
					
				

			

		

		

			
				
//假如一个文件对应一个坐标，想对文件按照坐标的x或y轴进行排序
//先把这个结构体放进vector中，利用sort()排序

struct PathIndexPair {
	Point2i point;        //保存坐标
	string path;          //保存路径
};

bool cmpy(PathIndexPair const& a, PathIndexPair const& b)
{
	return a.point.y > b.point.y;
}
.

			
		

	





	

		

			

				
					
C++对高维vector数组排序 sort()函数第三个参数自定义

				
			

			

				

					bulangman277的博客
				

				

					12-14
					
					1029
					
				

			

		

		

			
				
对于这样的二维数组我们想要按其某一列的元素的大小进行排列应该怎么解决呢？

			
		

	





	

		

			

				
					
C++ vector排序

				
			

			

				

					Ontheway的博客
				

				

					09-16
					
					986
					
				

			

		

		

			
				
#include

#include

#include 

#include 

using namespace std;




//这种排序方法，类似结构体的排序

int my_cmp(pair p1,pair  p2)

{

return p1.second > p2.second;

}

int main(int argc,char*

			
		

	





	

		

			

				
					
c++ vector 自定义排序

				
			

			

				

					08-16
				

			

		

		

			
				
你可以使用sort函数对vector进行自定义排序。以下是一个示例代码，假设你要对一个vector进行排序，按照字符串的长度从小到大排序：  ``` #include #include #include<vector> #include using namespace std;  bool ...

			
		

	



              



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

  

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

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值