C++和Java中STL库入门[通俗易懂]

C++和Java中STL库入门

STL简介

为什么使用STL

STL基本概念

STL使用前的初始化

C++里STL基本容器详解

Java里STL基本容器详解

STL简介

STL简称标准模版库，被容纳在C++标准程序库，包含了许多基本数据结构和基本算法，使程序员写起来得心应手。

为什么使用STL

STL基本概念

要使用STL，需要理解以下几个基本概念：
容器：是存放数据的地方，常见的容器有：链表(list) 栈(stack) 动态数组 (vector) 双端队列(deque) 队列(queue) 映射(map)
迭代器(iterator)：可以理解为C语言里的地址，而迭代器就是容器的一个指针，十分重要！！！
算法：可以对容器里的数据做一些基本操作，比如排序，找最大素等等。

STL使用前的初始化

C++：
1.需要对应的头文件，比如list就需要#include ，且没有.h，或者恶心的万能头#include 。
2.添加std命名空间（using namespace std;）不加的话后面可以自己写一堆。。。

C++里STL基本容器详解

struct cmp { 
 
 bool operator()(int a, int b) { 
 
 return a > b;
 }
 };

sort:
1.需要头文件#include；
2.复杂度为O(nlogn)，比较排序的极限了。

bool cmp(int a, int b)
 { 
 
return a > b;
 }
 int a[] = { 
 1, 2 ,3 , 4};
 sort(a, a + 4, cmp);

sort里第一个参数是数组需要排序的第一个地址，第二个参数是数组需要排序的第二个地址，都三个参数是一个自定义函数，对数组排序的函数，上面的cmp函数是使数组素从大到小排序。

sort是不稳定排序，即对于相同的值，无法保证其前后顺序
解决办法：
1、增加一个 index 变量，在值相同的使用比较 index 值的大小
2、使用 stable_sort

vector：
1.需要头文件#include
2.不定数组

vector 
  
    
    
      a, b; 
     
 a.push_back(1); // 推入一个新的值到数组最后 
 a.pop_back(); // 删除数组最后的那个值 
 a.front(); // 数组开头的值 
 a.back(); // 数组结尾的值 
 a = b; // 数组拷贝 
 a == b; // 数组是否相同 
 a[1]; // 数组中第二个值 
 
 vector 
              
                a; 
               
 a.size(); // 容器内的素个数 
 a.empty(); // 容器是否为空 
 // 除了queue和stack外通用的方法 
 a.clear(); // 清空容器内的所有素 
 a.begin(); // 容器的一个素的迭代器 
 a.end(); // 容器尾后迭代器 
 
 vector 
                       
                         v; 
                        
 vector 
                         
                           ::iterator iter // 定义迭代器 
                          
 iter = v.begin(); // 数组头“指针” 
 iter = v.end(); // 数组尾“指针”

list:
1.需要头文件#include l;
2.双向链表

list 
  
    
    
      l; 
     
 l.push_front(1); // 插入素到开头 
 l.pop_front(); // 从开头删掉素 
 l.erase(l.begin()); // 删除指定迭代器处的素 
 l.insert(l.begin(), 1); // 在指定迭代器前插入素 
 l.reverse(); // 反转整个链表

string:
1.伪字符串；
2.定义：string s;
3.只能流输入和流输出；

string a, b;
 a[1] == 'a'; // 得到某个字符
 a = b; // 字符串拷贝
 a >= b; // 字典序比较
 a[1] = b[1]; // 修改某个字符
 a += b; // 字符串拼接
 a = a + b; // 字符串拼接
 a += "123"; // 字符串拼接
 a = b + "123"; // 字符串拼接
 int len = a.lenth(); // 字符串的长度

queue：
1.需要头文件#include ；
2.先进先出（内部为链表实现）

queue 
  
    
    
      q; 
     
 q.push(1); // 将1推入队列 
 q.pop(); // 推出队列开头的素 
 q.front(); // 队列的第一个素

stack:
1.需要头文件#include ;
2.后进先出（内部为数组实现）

stack 
  
    
    
      q; 
     
 q.push(1); // 将1推入堆栈 
 q.pop(); // 推出堆栈最后的素 
 q.top(); // 堆栈的最后的素

pair:
1.需要头文件#include
2.表示一组键对（有两个变量的结构体）

pair 
  
    
    
      p; 
     
 p.first = 1; 
 p.second = "abc"; 
 p = make_pair(1, "abc"); 
 p = { 
 1, "abc"}; 
 
 pair 
            
              p[100]; 
             
 sort(p, p + 100); 
 // 默认优先first从小到大 
 // 如果first相同则second从小到大

pair与其他结构嵌套

vector 
  
    
    
      > vp; 
     
 queue 
      
        > qp; 
       
 queue 
        
          , int> > qpp;

set:
1.需要头文件#include ；
2.set保存了不可重复的素–二叉搜索树-红黑树

set 
  
    
    
      s; 
     
 s.insert(1); // 插入到集合中 
 s.erase(1); // 从集合中删除 
 s.erase(s.begin()); // 从集合中删除 
 s.count(1); // 集合中是否存在 
 s.find(1); 
 // 返回对应值的迭代器（若无则返回尾后迭代器）

·由于set是红黑树，所以满足以下内容
1、内部有序(默认从小到大)
2、没有重复值，如果出现重复值会不断被覆盖
3、几乎所有操作复杂度均为 O(logN)
4、不可以修改节点上的值
5、修改操作只能进行插入和删除两个操作

set通常作用：保证唯一性，保证数列有序

map：
1.需要头文件#include；
2.map字典（键对集合）——二叉搜索树——红黑树

map 
  
    
    
      m; 
     
 m.insert(make_pair('a', 1)); // 加入字典 
 m.insert({ 
 'a', 1}); // 加入字典 
 m.erase('a'); // 从字典中删除 
 m.count('a'); // 字典中是否存在 
 m.find('a'); 
 // 返回对应值的迭代器（若无则返回尾后迭代器）

通常称map的first素为key，second素为value
·由于map是键对红黑树，所以满足以下内容
1、set的大部分性质；
2、key不能重复，不能修改，只能删除和添加；
3、允许value重复，可以对value进行修改；
4、map是按照key进行排序的；
5、key和value一定是成对出现的；
6、map的迭代器指向的内容是一个pair；

priority_queue:
1.需要头文件#include
2.优先队列–堆

priority_queue 
  
    
    
      prq; 
     
 prq.top(); // 堆顶上的素 
 prq.pop(); // 弹出堆顶上的素 
 prq.push(1); // 推入堆

·priority_queue默认为最大堆，即堆顶的素最大
·和queue一样，priority_queue不允许访问除了堆顶素以外的任何一个素。
·priority_queue的插入和弹出操作的复杂度均为O(logN)

Java里STL基本容器详解

参考https://blog.csdn.net/_/article/details/
https://www.cnblogs.com/solvit/p/9600591.html
所有的容器都要有import类import java.util.*

import java.util.*;
 
 public class Main { 
 
 public static void main(String[] args) { 
 
 Vector 
          
            vec=new Vector<> (); 
           
 vec.add(1);//添加素 
 vec.add(4,6);//在下表为4前添加6素 
 vec.set(3, 7);//替换下表为3素值为7 
 vec.remove(0);//删除下表为1的素 
 for(int i=0;i 
                 //size获取长度 
 System.out.println(vec.get(i)); //get获取下表为i的值 
 } 
 vec.clear();//清空 
} 
 }

import java.util.*;
 
 public class Main { 
 
 public static void main(String[] args) { 
 
 ArrayList 
          
            arr=new ArrayList<>(); 
           
 arr.add(1);//添加 
 arr.add(2,6); 
 arr.size();//获取长度 
 arr.set(1, 4);//修改 
 int st=arr.remove(0);//删除 
 //arr.clear();//清空 
 //arr.get(1);//获取 
 int v=arr.indexOf(3);//获取索引 
 System.out.println(v); 
 } 
 }

import java.util.*;
 
 public class Main { 
 
 public static void main(String[] args) { 
 
 LinkedList 
          
            lin=new LinkedList<>(); 
           
 lin.addFirst(st);//在首部加 
 lin.addLast(st);//在尾 
 lin.removeFirst();//移除首素 
 lin.removeLast();//尾 
 lin.push(st);//压入栈 
 lin.pop();//弹出栈 
 } 
 }

import java.util.*;
 
 public class Main { 
 
public static void main(String[] args) { 
 
 HashSet 
          
            hashset=new HashSet<>(); 
           
 hashset.add(4);//添加 
 hashset.remove(2); //找到值2删除 
 System.out.println(hashset); 
 
} 
 }

HashMap:

import java.util.*;
 
 public class Main { 
 
public static void main(String[] args) { 
 
 HashMap 
          
            map=new HashMap<>(); 
           
 map.put(1, 1); //添加素 
 map.put(1, 2); //替换 
 map.remove(4); 
 System.out.println(map.get(1)); 
 System.out.println(map.size()); 
 System.out.println(map); 
 map.clear(); 
} 
 }

只做入门参考。

今天的文章 C++和Java中STL库入门[通俗易懂]分享到此就结束了，感谢您的阅读。

C++和Java中STL库入门[通俗易懂]

C++和Java中STL库入门

STL简介

为什么使用STL

STL基本概念

STL使用前的初始化

C++里STL基本容器详解

Java里STL基本容器详解

相关推荐