语言基础

部分结构

TreeNode二叉树

public class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
    
    //构造函数
    TreeNode(int val){
        this.val=val;
        this.left=null;
        this.right=null;
    } 
} 

使用方法

//新建二叉树节点 
TreeNode node1=new TreeNode(2);
TreeNode node2=new TreeNode(4);
TreeNode node3=new TreeNode(6);
//修改节点的值 
node1.val=10;
//连接节点 
node1.left=node2;
node1.right=node3;

ListNode单链表

class ListNode{
    int val;
    ListNode next;
    
    ListNode(int val){
        this.val=x;
        this.next=null;
    }
} 

使用方法

//新建单链表节点 
ListNode node1=new ListNode(1);
ListNode node2=new ListNode(3);
ListNode node3=new ListNode(5);
//修改节点的值 
node1.val=9;
//连接节点
node2.next=node3;
node1.next=node2; 

 

 

 

语言基础

C++

函数参数默认是传值的，所以如果使用数组子类的容器作为参数，一般会加上&符号表示传引用

1.动态数组类型vector

int n=7,m=8;
vector<int>nums;

vector<int>nums(n);

vector<int>nums{1,3,5};

//初始化一个大小为n的数组，值全为2 
vector<int> nums(n,2);

//初始化一个大小为m*n的bool型数组，初始值全为true 
vector<vector<bool>> dp(m,vector<bool>(n,true)); 

成员函数

//判断数组是否为空 
bool empty()

//返回数组的元素个数 
size_type size();

//返回数组最后一个元素的引用
reference back();

//在数组尾部插入一个元素val
void push_back(const value_type & val);

//删除数组尾部的那个元素
void pop_back(); 

//数组尾部插入和删除元素
nums.push_back(20);
cout<<nums.size();
nums.pop_back(20);
cout<<nums.size();

2.字符串string

string s="abc";
size_t size();
bool empty();
void push_back(char c);
void pop_back();
//返回从索引pos开始，长度为len的子字符串
string substr(size_t pos,size_t len);

3.哈希表unordered_map

//初始化一个key为int，value为int的哈希表 
unordered_map<int,int> mapping;
//初始化一个key为string，value为int数组的哈希表 
unordered_map<string,vector<int>> mapping ;

哈希表的值可以是任意类型的，但不能是任意类型的键，一般用int或者string

返回哈希表的键值对个数

size_type size();

返回哈希表是否为空

bool empty();

//返回哈希表中key出现的次数，因为不会有重复的键，所以只可能返回0或1

//可以用于判断键key是否存在于哈希表中

size_type count(const key_type& key);

unordered_map常见用法

vector<int> nums{1,1,3,4,5,3,6};
unordered_map<int,int> counter;
for(int num:nuns){
    counter[num]++;
}
for(auto& it:counter){
    int key=it.first;
    int val=it.second;
    count<<key<<":"<<val<<endl;
}

4.哈希集合unorder_set

unordered_set<string> visited;
//返回哈希表的键值对个数
size_type size();
//向集合插入一个元素key
pair<iterator,bool> insert(const key_type& key);

5.对列queue

//初始化一个存储int的对列
queue<int> q;
//初始化一个存储string的对列
queue<string> q;
//返回队列是否为空
bool empty();
//返回队列中元素的个数
size_type size();
//将元素加入队尾
void push(const value_type& val);
//返回队头元素的引用
value_type& front();
//删除队头元素
void pop();

6.堆栈stack

初始化方法

//初始化一个存储int的堆栈
stack<int> stk;
//初始化一个存储string的堆栈
stack<string> stk;
//返回堆栈是否为空
bool empty();
//返回堆栈中元素的个数
size_type size();
//在栈顶添加元素
void push(const value_type& val);
//返回栈顶元素的引用
vcalue_type& top();
//删除栈顶元素
void pop();

 

Java

1.数组

初始化方法

int m=5,n=10;
//初始化一个大小为10的int数组，默认值为0
int[] nums=new int[n];
//初始化一个m*n的二位bool数组
boolean[][]visited=new boolean[m][n];

用索引下标访问其中的元素

if(nums.length==0){
  return 0;
}
for(int i=0;i<nums.length;i++){
  //访问nums[i]
}

2.字符串String

Java处理字符串比较麻烦，因为它不支持用[]直接访问其中的字符，而且不能直接修改，要转化成char[]类型之后才能修改

String s1="hello world";
//获取s1[2]中的字符
char c=s1.charAt(2);

char[] chars=s1.toCharArray();
char[1]='a';
String s2=new String(chars);
System.out.println(s2);

//用equals方法判断字符串是否相同
if(s1.equals(s2)){
  //s1和s2相同
}else{
  //s1和s2不同
}

//字符串拼接
String s3=s1+"!";
//输出hello world
System.out.println(s3);

Java的字符串不能直接修改，要用toCharArray转换成char[]类型的数组后进行修改然后转换回String类型

虽然字符串支持+进行拼接，但是效率不高，不建议在for循环中使用。如果需要频繁拼接，使用StringBuilder

StringBuilder sb=new StringBuilder();
for(char c='a';c<'f';c++){
  sb.append(c);
}
//append直出拼接字符，字符串，数字
sb.append('g').append("hij").append(123)
String res=sb.toString();
//输出abcdefghij123
System.out.println(res);

3.动态数组ArrayList

//初始化一个存储String的动态数组
ArrayList<String> nums=new ArrayList<>

//判断数组是否为空
boolean isEmpty()

//返回数组中元素个数
int size();

//返回索引index的元素
E get(int index)

//在数组微博添加元素e
Boolean add(ElemType e)

4.双链表LinkedList

底层用数组实现，而LinkedList底层使用双链表实现的

//初始化一个存储int类型数据的双链表
LinkedList<Integer> nums=new LinkedList<>();
//初始化一个存储String类型数据的双链表
LinkedList<String> strings = new LinkedList<>();
//判断链表是否为空
boolean isEmpty()
//返回链表中元素的个数
int size()

LinkedList更多实用头部和尾部元素的操作，因为底层数据结构为链表，所以直接操作头尾部元素效率高

5.哈希表HashMap

初始化

//整数映射道字符串的哈希表
HashMap<Integer, String> map = new HashMap<>();
//字符串映射到数组的哈希表
HashMap<String,int[]> map = new HashMap<>();
//判断哈希表中是否存在key
boolean containsKey(Object key)
//获得键key对应的值，若key不存在则返回null
ValueType get(Object key)
//将key和value键值对存入哈希表
ValueType put(KeyValue key,ValueType value)
//如果key存在，删除key并返回对应的值
ValueType remove(Object key)

6.哈希集合HashSet

初始化方法

//新建存储一个String类型的哈希集合
Set<String> set=new HashSet<>();
//如果e不存在就会添加到哈希集合
boolean add(ElemType e)
//判断元素o是否存在于哈希集合
boolean contains(Object o)
//如果元素o存在则删除元素
boolean remove(Object o)

7.队列Queue

与之前的数据结构不同，Queue是一个接口Interface，因此它的初始化方法比较特别

//新建一个存储String的对列
Queue<String> q=new LinkedList<>();
//判断队列是否为空
boolean isEmpty();
//返回队列中元素的个数
int size();
//返回队头的元素
ElemType peek();
//删除并返回队头的元素
ElemType poll();
//将元素e掺入队尾
boolean offer(ElemType e);

8.堆栈

初始化方法：
Stack<Integer> s=new Stack<>();
//判断堆栈是否为空
boolean isEmpty();
//返回堆栈中元素是的个数
int size();
//将元素压入栈顶
ElemType push(ElemType item)
//返回栈顶元素
ElemType peek()
//删除并返回栈顶元素
ElemType pop()