c++、Java常用数据结构及其使用方法

C++

---

vector

#include<iostream>
#include<vector>
using namespece std;

int main(){
    //初始化
    vector<int> vec1;
    vector<int> vec2(3);
    vector<int> vec3(3,2);
    vector<int> vec4(vec3);
    vector<int> vec5( vec3.begin(), vec3.end() );
    vector<int> b(10,1);
    vector<int> a;

    //常用操作
    a.assign(b.begin(),b.begin()+3)//    b为向量，将b的前三个元素赋值给a
    a.assign(4,2)          //a有4个元素，每个元素都为2
    a.back()              //返回a的最后一个元素
    a[i]                     //a的第i个元素
    a.front()                //a的第一个元素
    a.clear()                //清除a中的元素
    a.empty()                //判断a是否为空，空返回True,不空返回False
    a.pop_back()             //删除a的最后一个元素
    a.erase(a.begin(),a.begin()+3)  //删除
    a.push_back(8)            //在向量最后添加 8
    a.insert(a.begin(),5)        //在向量开始位置插入一个 5
    a.insert(a.begin(),3,5)        //在向量开始位置添加三个 5
    a.size()                         //向量中元素的个数
    a.capacity()                    //返回a在内存中总共可以容纳的元素个数
    a.resize(10)                //重置a的size，多则删，少则补，其值随机
    a.resize(10,2)                //重置a的size，多则删，少则补，其值补充为 2


    //vector的遍历
    vector<int> vec = new vector<int>(10,2);
    for(vector<int>::iterator it = vec.begin(); it < vec.end(); it++){
        cout<<*it;
    }

}

 

List

#include<iostream>
#include<list>
using namespece std;

//这里的list是双向的

int main(){
    //初始化
    list<int> lst1;
    list<int> lst2(3);
    list<int> lst3(3,2);
    list<int> lst4(lst3);
    list<int> lst5(lst3.begin(),lst3,end());


    //常用操作
    lst1.assign();  //
    lst1.back();
    lst1.begin() ; //第一个元素的迭代器
    lst1.end();     //末尾元素的迭代器
    lst1.rbegin() ; //指向倒数第一个元素的逆向迭代器
    lst1.rend();     //指向开头位置的逆向迭代器 
    lst1.clear();
    lst1.empty();
    lst1.erase();
    lst1.front();   //第一个元素
    lst1.insert(lst1.begin()+5,10);
    lst1.max_size();
    lst1.pop_back(); //删除最后一个元素
    lst1.pop_front(); //删除第一个元素
    lst1.push_back(); //在list的末尾添加一个元素
    lst1.push_front(); //在list的头部添加一个元素
    lst1.size();
    lst1.unique();   //删除list中的重复元素
    lst1.sort();     //给list排序

    //遍历
    for(list<int>::const_iteratoriter = lst1.begin(); iter != lst1.end(); iter++){
        cout<<*iter;
    }
    cout<<endl;
}

map

#include<iostream>
#include<map>
#include<string>
using namespace std;


int main(){

    map<int,string> mapstring;
    //插入数据的第一种方式（这里如果键不是基本数据类型需要重载运算符，因为map存储使用的是红黑                       //树，必须保证可以比较大小）
    mapstring.insert(pair<int,string>(1,"apple1"));
    mapstring.insert(pair<int,string>(2,"apple2"));
    mapstring.insert(pair<int,string>(3,"apple3"));

    //插入数据的第二种方式
    mapstring.insert(map<int,string>::value_type(4,"apple4"));
    mapstring.insert(map<int,string>::value_type(5,"apple5"));
    mapstring.insert(map<int,string>::value_type(6,"apple6"));

    //插入数据的第三种方式(如果map中已经有插入的键存在，则会覆盖它对应的值)
    mapstring[7] = "apple7";
    mapstring[8] = "apple8";
    mapstring[9] = "apple9";

    //map的遍历
    map<int,string>::iterator ite;
    for(ite = mapstring.begin(); ite!=mapstring.end(); ite++){
        cout<<ite->first<<ite->second<<endl;
    }


    //map的常用操作
    map.find(key);//返回的是迭代器，如果没有找到其值为map.end()
    map.size();  //返回map已存入数据的数量
    iterator map.erase(iterator it)  //通过一个条目删除
    iterator map.erase(iterator begin, iterator end) //通过开始和结束删除一个范围内的元素
    size_type map.erase(const Key&key);        //通过关键字删除
    map.clear();   //删除全部
    map.rbegin();
    map.rend();
    map.count(value); //返回指定元素value出现的次数

}

stack

#include<iostream>
#include<stack>
#include<string>
using namespace std;

int main(){
    stack<string> stack1;
    stack1.push("one");
    stack1.push("two");

    cout<< stack1.size()<<endl;

    cout<< stack1.top() <<endl;

    stack1.pop();
    cout<<stakc1.emtpy()==1<<endl;
    stack1.pop();
    cout<<stakc1.emtpy()==1<<endl;
}

queue

#include<iostream>
#include<queue>
#include<string>
using namespace std;

int main(){
    queue<string> queue1;
    queue1.push("one");
    queue1.push("two");

    cout<<queue1.front()<<endl;

    cout<<queue1.back()<<endl;

    queue1.pop();

    cout<<queue1.size()<<endl;

    cout<<queue1.empty()==1<<endl;//如果为空返回1，不为空返回0

}

Java

---

ArrayList

import java.util.ArrayList;

public static void main(String []args){
    ArrayList<int> arrlst = new ArrayList<>();
    arrlst.add(1);
    arrlst.add(2);
    arrlst.add(3);
    
    arrlst.addAll(arrlst_another);
    
    arrlst.remove(3);

    arrlst.removeAt(1);

    arrlst.removeRange(start_index,end_index);
    
    arrlst.insert();

    arrlst.contains(1);
}

LinkedList

import java.util.LinkedList;

//既可以做队列也可以做双端队列
public static void main(String[] args){

    LinkedList<int> lnklst =  new LinkedList<>();

    lnklst.getFirst();   //得到第一个元素
    lnklst.getLast();    //得到最后一个元素
    lnklst.removeFirst();    //移除第一个元素
    lnklst.removeLast();    //移除最后一个元素
    lnklst.addFirst();        //在最开始位置添加节点
    lnklst.addLast();        //在最后添加节点

}

stack

import java.util.Stack;


public static void main(String []args){
    Stack<Integer> st = new Stack<>();

    st.push(new Integer(3));
    System.out.println(st.peek());

    st.pop();
    st.empty();

    st.search(object);//返回对象在栈中的位置，从下标1开始
}

queue

import java.util.LinkedList;
import java.util.Queue;

//LinkedList 继承了Queue，可以直接使用LinkedList做Queue

public static void main(String []args){
    Queue<int> queue = new LinkedList<>();
    queue.offer(1);
    queue.offer(2);
    queue.offer(3);
    
    System.out.println(queue.size());
    
    int get_first_method1 = queue.element();
    
    int get_first_method2 = queue.peek();

    int get_poll = queue.poll();
}

map

import java.util.HashMap;
//java的map有很多种，此处就使用的最基本的HashMap
public static void main(String []args){
    Map<String, String> map = new HashMap<String, String>();
    map.put("key1", "value1");
    map.put("key2", "value2");


    //常用操作
    map.clear();
    map.remove(object key);
    map.put(object key, object value);
    map.putAll(Map map_other);
    map.entrySet();     //返回 Map 中所包含映射的 Set 视图。Set 中的每个元素都是一个     //Map.Entry 对象，可以使用 getKey() 和 getValue() 方法（还有一个 setValue() 方法）访问后者//的键元素和值元素
    map.keySet();    //返回 Map 中所包含键的 Set 视图。删除 Set 中的元素还将删除 Map 中相应//的映射（键和值）
    map.values();
    map.get(object key);
    map.containsKey(object key);
    map.containsValue(object value);
    map.isEmpty();
    map.size();



    //map的遍历
    //使用keySet()的遍历
    for (String key : map.keySet()) {
        System.out.println(key + " ：" + map.get(key));
    }
    
    //使用entrySet()的遍历
    for (Map.Entry<String, String> entry : map.entrySet()) {
        System.out.println(entry.getKey() + " ：" + entry.getValue());
    }

    //使用迭代器的遍历
    Iterator<String> iterator = map.keySet().iterator();
    while (iterator.hasNext()) {
        String key = iterator.next();
        System.out.println(key + "　：" + map.get(key));
    }
    
    //使用entrySet()的迭代器遍历
    Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
    while (iterator.hasNext()) {
        Map.Entry<String, String> entry = iterator.next();
        System.out.println(entry.getKey() + "　：" + entry.getValue());
    }    

}