算法（这个是新版哦）

队列

        定义：队列在逻辑上是一个线性表，队列的长度是可以变化的，但数组却不能变化，那是怎么变化的呢？他的原理是：先进先出（FIFO——出只能第一个出，进只能在末尾进，队列只能访问第一个单元，而数组却是和已随便访问任意一个单元。

1、结构及函数

queue<int> q;//他的元素是int 名称是q
q.size()//返回一个整数，表示元素中的数量
q.push(i)//往队尾添加元素有参数 
q.front()//返回队首元素
q.pop()//踢出队首元素 

 2、加元素、

bool vis[1005];//初始化
 
for(int i=0;i<n;i++){
	cin>>a;
	if(!vis[a]){
		ans++;
		q.push(a);
		if(q.size()>m){
			vis[a.front()]=false;
			q.pop();
		}
	}
}

栈

定义：后进先出（LIFO）我们是从栈顶拿，又从栈顶放；

1、结构与函数、

stack<int> s;
s.size()//返回栈里的数量、
a.push(i)//把i压到栈底 
s.top()//返回栈顶元素
s.pop()//把栈顶的元素弹出
//如果栈里面没有元素那他就会RE
s.empty()//判断是否为空
//如果是空的就返回true否则false

链表

格式与操作：

目录
队列

栈

链表

队列
队列的特点：

队列的先进先出性质（\text{FIFO}FIFO）导致队列只能访问第一个元素，改变最后一个元素；

而数组可以访问和改变任意一个元素。

更明显的区别就是队列可以自动增长，而数组不行。

队列的定义以及常用操作

#include<queue>
queue<int> q;
返回元素数量：

q.size();
往队尾添加元素：

q.push(i);
返回队首元素：

q.front();
踢出队首元素：

q.pop();
队列的应用：

bool vis[1005];

for(int i = 0; i < n; i++)
    cin >> a;
    if(!vis[a])
        ans++;
        q.push(a);
        if(q.size() > m)
            vis[q.front()] = false;
            q.pop();
栈
栈的特点：

后进先出（\text{LIFO}LIFO）。

栈的定义和操作：

stack<int> s;
在执行操作前，请注意栈的元素数量。

返回栈里的元素数量：

s.size();
把 ii 压到栈顶：

s.push(i);
返回栈顶元素：

s.top();
把栈顶元素弹出：

s.pop();
判断是否为空：

s.empty();// 如果是空的，返回 true，否则是 false。
链表
链表的特点：

在内存中可以存在任何地方，不要求连续。

每一个数据都保存了下一个数据的内存地址，通过这个地址找到下一个数据。 第一个人知道第二个人的座位号，第二个人知道第三个人的座位号……

增加数据和删除数据很容易。 再来个人可以随便坐，比如来了个人要坐到第三个位置，那他只需要把自己的位置告诉第二个人，然后问第二个人拿到原来第三个人的位置就行了。其他人都不用动。

查找数据时效率低，因为不具有随机访问性，所以访问某个位置的数据都要从第一个数据开始访问，然后根据第一个数据保存的下一个数据的地址找到第二个数据，以此类推。 要找到第三个人，必须从第一个人开始问起。

不指定大小，扩展方便。链表大小不用定义，数据随意增删。

链表的定义：

一些操作：

malloc(4)// 申请一段 4 个字节的空间
// 返回值是申请到的空间的指针

sizeof(int)// 计算某个结构需要多少字节
申请空间 & 创建指针：

Node *p = (Node *)malloc(size(Node));
初始化：

(*p).next = NULL;
（当这是一个结构体指针时，你可以用下面这种）

p->next = NULL;
p->x = 0;
p->y = 0;
// 直接访问成员
链表的操作
链表头：

Node *head;
//第一个
赋值：

Node *new_node(int x, int y)
    Node *p = (Node *)malloc(sizeof(Node));
    p->next = NULL;
    p->x = x;
    p->y = y;
    return p;
从当前指向节点跳到下一个节点：

p = p->next;
遍历链表：

int num = 0;
for(Node *p = head; p != NULL; p = p->next)
    cout << p->x << " " << p->y <<endl;
    num++;
插入节点（往 pp 的后面插入新节点）：

void insert_node(Node *p, int x, int y)
    p->next = new_node(x, y);
    q->next = p->next;
    p->next = q;
删除节点：

free()// 释放指针指向的内存

int *p = (int *)malloc(sizeof(int));
free(p);
删除某个节点后的一个节点：

void delete_node(Node *p)
    Node *q = p->next;
    p->next = p->next->next;
    free(q);
或者这种也可以：

Node *q = head;
head = head->next;
free(q);
翻转链表：

Node *reverse(Node *head){
    Node *prev = NULL;
    Node *next;
    for(Node *p = head; p != NULL; p = next){
        next = p->next;
        p->next = prev;
        prev = p;
    }
    return prev;
}

下面是某人的笔记我只是借鉴，不是抄袭

目录
队列

栈

链表

队列
队列的特点：

队列的先进先出性质（\text{FIFO}FIFO）导致队列只能访问第一个元素，改变最后一个元素；

而数组可以访问和改变任意一个元素。

更明显的区别就是队列可以自动增长，而数组不行。

队列的定义以及常用操作

#include<queue>
queue<int> q;
返回元素数量：

q.size();
往队尾添加元素：

q.push(i);
返回队首元素：

q.front();
踢出队首元素：

q.pop();
队列的应用：

bool vis[1005];

for(int i = 0; i < n; i++)
    cin >> a;
    if(!vis[a])
        ans++;
        q.push(a);
        if(q.size() > m)
            vis[q.front()] = false;
            q.pop();
栈
栈的特点：

后进先出（\text{LIFO}LIFO）。

栈的定义和操作：

stack<int> s;
在执行操作前，请注意栈的元素数量。

返回栈里的元素数量：

s.size();
把 ii 压到栈顶：

s.push(i);
返回栈顶元素：

s.top();
把栈顶元素弹出：

s.pop();
判断是否为空：

s.empty();// 如果是空的，返回 true，否则是 false。
链表
链表的特点：

在内存中可以存在任何地方，不要求连续。

每一个数据都保存了下一个数据的内存地址，通过这个地址找到下一个数据。 第一个人知道第二个人的座位号，第二个人知道第三个人的座位号……

增加数据和删除数据很容易。 再来个人可以随便坐，比如来了个人要坐到第三个位置，那他只需要把自己的位置告诉第二个人，然后问第二个人拿到原来第三个人的位置就行了。其他人都不用动。

查找数据时效率低，因为不具有随机访问性，所以访问某个位置的数据都要从第一个数据开始访问，然后根据第一个数据保存的下一个数据的地址找到第二个数据，以此类推。 要找到第三个人，必须从第一个人开始问起。

不指定大小，扩展方便。链表大小不用定义，数据随意增删。

链表的定义：

一些操作：

malloc(4)// 申请一段 4 个字节的空间
// 返回值是申请到的空间的指针

sizeof(int)// 计算某个结构需要多少字节
申请空间 & 创建指针：

Node *p = (Node *)malloc(size(Node));
初始化：

(*p).next = NULL;
（当这是一个结构体指针时，你可以用下面这种）

p->next = NULL;
p->x = 0;
p->y = 0;
// 直接访问成员
链表的操作
链表头：

Node *head;
//第一个
赋值：

Node *new_node(int x, int y)
    Node *p = (Node *)malloc(sizeof(Node));
    p->next = NULL;
    p->x = x;
    p->y = y;
    return p;
从当前指向节点跳到下一个节点：

p = p->next;
遍历链表：

int num = 0;
for(Node *p = head; p != NULL; p = p->next)
    cout << p->x << " " << p->y <<endl;
    num++;