一.数组

通过STL中可变长度的数组记录（<vector>）

vector<int> v(N,i);//建立可变长v数组，初始含N元素，数值为i
//PS(N,i)可以省略，数组长为0
v.push_back(a);//将a插入至v数组队尾，增加数组长
v.size();//返回数组长度
v.resize(n,m);//初始化数组，n个元素，若n>原len，全部复制为m，若n<原len，多出部分赋值m

二.栈

通过链表实现栈功能

通过STL中头文件<stack>实现栈功能

实现方式：

#include<iostream>
using namespace std;
struct Node{
    int data;
    struct Node *pNext;
};
struct Stack
{
    struct Node *pNode;//当前元素的指针,存储数据
    int size;
};
void top(struct Stack s)
{
    cout<<(s.pNode)->data;
}
void push(int data,struct Stack *s)
{
    struct Node* n=(struct Node*)malloc(sizeof(struct Node));
    n->data=data;//添加数据
    if(s->pNode==NULL)  n->pNext=NULL;//栈底指针为空，相当于n停留，s上移
    else n->pNext=s->pNode;//设置上一个结点指针
    s->pNode =n;//设置栈顶指针
    s->size ++;//计数器
}
void pop(struct Stack *s)
{
    struct Node *current = s->pNode;//获取当前结点
    if(current ->pNext !=NULL) s->pNode= current->pNext;//未到栈底，栈顶元素下移
    else s->pNode=NULL;
    free(current);//释放原栈顶元素空间；
    s->size --;
}
int empty(struct Stack s)
{
    return s.size==0;
}
int main()
{
    struct Stack mStack = {NULL, 0}; // 初始化一个栈
    push(123,&mStack);
    top(mStack);//查询栈顶元素
    pop(&mStack); // 移除栈顶的元素
    cout<<mStack.size; // 输出元素个数
    printf("isEmpty = %d\\n", empty(mStack));
    return 0;
}

使用方式：

int top,stack[MAXN];
void push(int x){//入栈
    if(top>=MAXN) cout<<"Stack overflow";
    stack[++top]=x;
}
void peek(){//返回栈顶内容
    if(top==0)
        cout<<"Stack is empty";
    return stack[top];
}
void pop(){//弹出栈顶并删除
    if(top==0)
        cout<<"Stack is empty";
    return stack[top--];
}通过STL中头文件<stack>实现栈功能
stack <int> s;//建立一个int 的栈s
s.push(a);//将a压入栈s
s.pop();//弹出s的栈顶元素
s.top();//查询s的栈顶元素
s.size();//查询s的元素个数
s.empty();//查询s是否为空

三.队列

通过链表实现队列功能

#include<iostream>
using namespace std;
struct Node{
    int data;
    struct Node *pNext;
};
Node * headQueue(){
    Node * queue=(Node*)malloc(sizeof(Node));
    queue->pNext=NULL;
    return queue;
}
Node* push(int data,Node* rear)//队尾rear后移，head位置不变
{
    Node *New=(Node*)malloc(sizeof(Node));
    New->data=data;
    New->pNext=NULL;
    rear->pNext=New;
    rear=New;
    cout<<"'"<<data<<"'"<<"is pushed"<<endl;
    return rear;
}
void pop(Node *top,Node *rear)//top中不储存数据
{
    if(top->pNext==NULL) cout<<"empty"<<endl;
    else{
        Node *p=top->pNext;//方便释放空间
        cout<<p->data<<"is popped"<<endl;
        top->pNext=p->pNext;
        if(rear==p) rear=top;
        free(p);
    }
}
void front(Node *top)//输出头节点数值
{
    cout<<"The front is"<<top->pNext->data<<endl;
}
void Rear(Node *rear)//输出尾节点数值
{
    if(rear!=NULL) cout<<"The rear is"<<rear->data<<endl;
}    
void isempty(Node *rear)//判断是否为空，直接看尾结点
{
    if(!rear) cout<<"not empty"<<endl;
    else cout<<"empty"<<endl;
}
int main()
{
    Node *top,*rear;
    rear=top=headQueue();//创建头节点
    for(int i=1;i<=5;i++)
    {
        rear = push(i,rear);
        //printf("%p  %p\\n", front, rear);
        Rear(rear);
        front(top);
    }
    //front(top);
    //Rear(rear);
    for(int i=1;i<=5;i++) 
        pop(top,rear);
}

使用方式：

int queue[MAXN],head=0,tail=0;
void push(int x){
    if(tail>=MAXN)
        cout<<"Queue overflow";
    else queue[++tail]=x;
}
void pop{//弹出队首元素
    if(head==tail)
        cout<<"Queue is empty";
    else head+=1;
}
通过STL中头文件<queue>实现队列功能
queue <int>q;//建立队列q
q.push(a);//将a插入队尾
q.pop();//将队首元素删除
q.front();//查询队首元素
q.end();//查询队尾元素
q.size();//查询队列元素数
q.empty();//查询队列是否为空

四.链表

单链表

1.类型变量说明

struct node{
    int data;
    node *next
}*p;

2.申请储存单元

p=new node;//动态申请空间

3.指针变量的赋值

指针变量名=NULL（P->data=0）

4.单链表建立、输出

struct node{
	    int data;
	    node *next;
	}*head,*p,*end;
	int main()
	{
	    int x;
	    cin>>x;//申请头节点
	    head=new node;
	    end=head;
	    while(x!=-1)
	    {
	        p=new node;
	        p->data=x;
	        p->next=NULL;
	        end->next=p;//新节点链接至前链表，end为p的直接前趋 
	        end=p;//尾指针后移   
	        cin>>x; 
	    }
	    p=head->next;//头指针无数据 
	    while(p->next!=NULL)
	    {
	        cout<<p->data<<" ";
	        p=p->next;
	    }
	    cout<<p->data;//单独输出借位 
}

查找特定节点

p=head->next;
	while(p->next！=NULL)
	{
	    if(p->data==x) 处理此项;
	    p=p->next;
	}
	取出第i节点的数据域data
	void get(node *head,int i)
	{
	    node *p;
	    int j=1;
	    p=head->next;
	    while((p!=NULL)&&(j<i))
	    {
	        p=p->next;
	        j++;
	    }
	    if((p!=NULL)&&(j<i))
	        cout<<p->data;
	    else cout<<"no exsit";
	}
	插入一个结点
	void insert(node *,int i,int x)//插入X在第i元素前
	{
	    node *p,*s;
	    int j;
	    p=head;
	    j=0;
	    while((p!=NULL)&&(j<i-1))
	    {
	        p=p->next;
	        j++;
	    }
	    if(p==NULL)
	        cout<<"no positition";
	    else
	    {
	        s=new node;
	        s->data=x;
	        s->next=p->next;
	        p->next=s;   
	    }
	}
	删除第i个结点
	void delete(node *head,int i)
	{
	    node *p,*s；
	    int j=0;p=head;
	    while((p->next!=NULL)&&(j<i-1))
	    {
	        p=p->next;
	        j++;
	    }
	    if(p->next==NULL)
	        cout<<"no position";
	    else//删除p后续结点s
	    {
	        s=p->next;
	        p->next=s->next;
	        free(s);
	    }
	}
	判断链表长
	int len(node *head)
	{
	    int n=0;
	    p=head;
	    while(p!=NULL)
	    {
	        n++;
	        p=p->next;
	    }
	    return n;
}