Java C++常用STL容器归纳总结

小露狂粉

于 2024-05-11 20:29:41 发布

阅读量989

点赞数 22

分类专栏：笔试题(有时间刷刷) 文章标签： java c++ 开发语言

本文链接：https://blog.csdn.net/qq_53165278/article/details/138729007

版权

笔试题(有时间刷刷) 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

C++篇章

之前的算法组一直都是c++选手，记得比较深刻一点，所以就先写C++吧

VECTOR容器:于我而言其实就是数组但是多了两个有用的操作(1)写好了一些可以直接使用的函数例如翻转、删除等功能(2)指定的存储类型比数组多可以存储算法题中常用的pair、map等类型

vecror v; 在写算法过程过一般直接初始化操作我用的比较少(省略默认初始化赋值)，一下是个人常用的一些操作。

//插入操作
v.push_back();

//清空操作
v.clear(); /

//求长度操作
int len=v.size();
v.empty();//判断是否为空

//删除字符串操作
v.pop_back(); // 删除向量末尾的元素
v.erase(v.begin() + n); // 删除索引为n的元素

//翻转函数
v.reverse(v.begin(),v.end());

//查找函数 用的较少
auto it = find(v.begin(), v.end(), target);
if (it != v.end()) {
    cout << distance(v.begin(), it) << endl;
}

//自定义排序函数 lambda表达式
sort(v.begin(), v.end(), [](int a, int b) {
        return a > b; // 左升序 右降序
    });

MAP键值对:同vector ，key和value可以是很多其他类型的值，用的比较常见;

map<E,E> m; 需要注意的就是键值具有唯一性，再次出现会覆盖初始值。

//map中使用较多1，存储  2，遍历  3，排序 4，查找

//存储
m[E]=E;

//查找
auto it = m.find(n); // 查找key为n的元素
if (it != m.end()) {
    cout<<it->second<<endl;//输出value值
}

//删除
m.erase(n); // 删除键为n的元素
m.erase(m.begin()); // 删除映射中的第一个元素

//遍历
for(auto k:m) {
    cout<<k.first<<' '<<k.second<<endl;
}

//排序 默认按照key值升序排序
//在声明的时候添加:greater<int>  就变成降序排序
map<E,E,greater<E>> //默认按照key降序排序

//自定义排序主要用于按照value进行排序的情况
bool cmp(const pair<int, string>& a, const pair<int, string>& b) {// 自定义比较函数，用于比较map的value
    return a.second < b.second; // 按照value的字典序排序
}

vector<pair<E, E>> v(m.begin(), m.end());//直接把map当作pair类型存到vector中，key->first  value-seond

sort(v.begin(),v.end,cmp);//现在直接输出v即可
/*简易测试代码
    m[0]="1";
    m[2]="11";
    m[1]="22";
    vector<PII> v(m.begin(),m.end());
    sort(v.begin(),v.end(),cmp);
    for(auto k:v) cout<<k.first<<' '; //输出的是key 
    输出:0 2 1  正常输出应该是默认升序0 1 2
*/

QUEUE队列: 这里只讲解最基本的队列先进先出(优先队列自己去了解)

queue q; 由于比较简单使用的时候可以直接使用数组模拟一个队列(按照原理自行实现)
```
//入队
q.push(n);
    
//获取对头
q.front();
q.back();//获取队尾

//对头出队
q.pop();

//大小
q.size();
q.empty();//非空判断
```
**STACK栈:**唯一特性先进后出(使用的较少，几乎只有满足这一性质的时候才会使用到考研逻辑性出栈入栈顺序常见题型表达式求值)

stack s; 同理，由于比较简单使用的时候可以直接使用数组模拟一个栈(按照原理自行实现)
```
//入栈
s.push();

//访问
s.top();
s.pop(); //出栈

//大小
s.size();
s.empty();//非空判断
```

Java篇章(其实我觉得黑马的基础课讲的还是很清楚的有时间的可以自己去看看了解一下)

个人觉得java写算法真的是太麻烦了可能我刚转还有很多东西理解不到位吧

ArrayList

ArrayList是一个可调整大小的数组列表，提供了比标准数组更多的灵活性。它允许包含重复的元素，并且可以根据需要自动调整其大小。

List list = new ArrayList();

// 添加元素
list.add(n);
list.add(index, n);// 在指定位置插入元素
list.set(index,n);// 更新元素
// 获取元素
list.get(index);

// 删除元素
list.remove(n);
list.remove(index);// 删除指定位置的元素

// 检查元素是否存在
list.contains(n); 

// 获取ArrayList的大小
list.size();

// 清空ArrayList
list.clear();

// 遍历ArrayList
for (int n : list) {
    System.out.println(n);
}

// 使用迭代器遍历
Iterator<Interger> iterator = list.iterator();
while (iterator.hasNext()) {
    int n = iterator.next();
    System.out.println(n);
}

LinkedList(使用较少)

LinkedList是一个双向链表实现，它提供了额外的插入和删除操作，但随机访问性能不如ArrayList。

import java.util.LinkedList;
// 创建一个空的LinkedList
LinkedList<String> list = new LinkedList<String>();
// 添加元素到列表末尾
list.add("Apple");
// 添加元素到列表开头
list.addFirst("Banana");
// 在指定位置插入元素
list.add(1, "Cherry");
// 获取第一个元素
String first = list.getFirst();
// 获取最后一个元素
String last = list.getLast();
// 删除第一个元素
String removedFirst = list.removeFirst();
// 删除最后一个元素
String removedLast = list.removeLast();
// 删除指定位置的元素
String removed = list.remove(1);
// 检查元素是否存在
boolean contains = list.contains("Cherry");
// 获取LinkedList的大小
int size = list.size();
// 清空LinkedList
list.clear();
// 遍历LinkedList
for (String fruit : list) {
    System.out.println(fruit);
}

HashMap

HashMap是基于哈希表的Map接口的实现，它提供了所有可选的映射操作，并允许使用null值和null键。

Map<String, Integer> map = new HashMap<String, Integer>();

// 添加键值对
map.put(n, m);

// 获取值
map.get(n);

// 检查键是否存在
map.containsKey(n);//如果有值就用原来的值  没有赋新值(记不得那个操作了)
map.containsKey(n) ? map.put(n,map.get(n)+x) : m;  //三元运算符实现

// 删除键值对
map.remove(n);
map.clear();// 清空HashMap

// 获取HashMap的大小
map.size();

// 遍历HashMap的键
for (String key : map.keySet()) {
    System.out.println("Key: " + key + ", Value: " + map.get(key));
}

// 遍历HashMap的条目
for (HashMap.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}

HashSet

HashSet是一个不包含重复元素的集合，它基于HashMap实现，因此它不允许包含重复的元素。

HashSet set = new HashSet();

// 添加元素
set.add(n);

// 删除元素
set.remove(n);

// 检查元素是否存在
boolean contains = set.contains(n);

// 获取HashSet的大小
int size = set.size();

// 清空HashSet
set.clear();

// 遍历HashSet
for (String fruit : set) {
    System.out.println(fruit);
}

Stack

在Java中，Stack 是一个后进先出（LIFO）的数据结构，它是通过扩展 Vector 类来实现的。Stack 提供了几个基本操作，包括 push（压栈）、pop（出栈）、peek（查看栈顶元素）和 search（搜索元素）。

Stack stack = new Stack<>();

// 压栈操作
stack.push(1);

// 出栈操作
int top = stack.pop(); // 移除并返回栈顶元素

// 查看栈顶元素（不出栈）
int peek = stack.peek();

// 搜索元素，返回元素在栈中的位置（距离栈顶的距离）
int index = stack.search(n);

// 获取Stack的大小
int size = stack.size();

// 检查Stack是否为空
boolean isEmpty = stack.isEmpty();

// 清空Stack
stack.clear();

// 遍历Stack
while (!stack.isEmpty()) {
    System.out.println(stack.pop());
}

// 使用迭代器遍历
Iterator<Integer> iterator = stack.iterator();
while (iterator.hasNext()) {
    Integer element = iterator.next();
    System.out.println(element);
}

Queue

在Java中，Queue 是一个先进先出（FIFO）的数据结构，它通过接口来实现，常用的实现类有 LinkedList 和 PriorityQueue。Queue 提供了几个基本操作，包括 offer（入队）、poll（出队）、peek（查看队头元素）和 element（获取队头元素）。

Queue queue = new LinkedList<>();

// 入队操作
queue.offer(1);

// 出队操作
int head = queue.poll(); // 移除并返回队头元素

// 查看队头元素（不出队）
int peek = queue.peek();

// 获取队头元素（如果队列为空，则抛出NoSuchElementException）
int element = queue.element();

// 获取Queue的大小
queue.size();

// 检查Queue是否为空
queue.isEmpty();

// 清空Queue
queue.clear();

// 遍历Queue
while (!queue.isEmpty()) {
    System.out.println(queue.poll());
}

// 使用迭代器遍历
Iterator<Integer> iterator = queue.iterator();
while (iterator.hasNext()) {
    Integer element = iterator.next();
    System.out.println(element);
}

在实际编程中，Stack 和 Queue 是非常有用的数据结构，它们在解决各种算法问题时提供了不同的视角和操作方式。例如，Stack 通常用于解决涉及递归、深度优先搜索（DFS）或回溯的问题，而 Queue 则适用于广度优先搜索（BFS）或需要按照顺序处理元素的场合。

这些容器在Java编程中非常常用，提供了丰富的操作集合的方法。在实际编程中，选择合适的容器取决于具体的需求和场景。

小露狂粉

关注

22
点赞
踩
29

收藏

觉得还不错? 一键收藏
3
评论
Java C++常用STL容器归纳总结

在实际编程中，选择合适的容器取决于具体的需求和场景。LinkedList是一个双向链表实现，它提供了额外的插入和删除操作，但随机访问性能不如ArrayList。HashMap是基于哈希表的Map接口的实现，它提供了所有可选的映射操作，并允许使用null值和null键。HashSet是一个不包含重复元素的集合，它基于HashMap实现，因此它不允许包含重复的元素。是非常有用的数据结构，它们在解决各种算法问题时提供了不同的视角和操作方式。是一个先进先出（FIFO）的数据结构，它通过接口来实现，常用的实现类有。
复制链接

扫一扫