算法导论第十章笔记

栈和队列

1.栈和队列都是动态集合。不同的是栈实现的是后进先出，而队列实现的是先进先出。形象一点的例子栈就像盘子堆，你放盘子只能放在最上面，那盘子也只能先拿最上面的，相当于插入元素在集合最后，删除元素是最后进入的元素。而队列就如排队的队伍，新来的要排在最后完事的是第一个走，相当于插入元素在集合最后，删除元素为集合的开头。
栈基本函数伪代码

队列基本函数伪代码

c++程序使用栈和队列

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

int main()
{
    stack<int>S;
    queue<int>Q;
    int n,x;
    while(cin>>n)
    {
        if(n%2==1)
            S.push(n);
        else
            Q.push(n);
    }
    while (!S.empty())
    {
        x=S.top();
        S.pop();
        cout<<x<<" ";
    }
    cout<<endl;
    while (!Q.empty())
    {
        x=Q.front();
        Q.pop();
        cout<<x<<" ";
    }
    return 0;
}

双向链表

这里的代码是实现算法导论上双向链表的建立，插入节点，删除节点的操作。双向链表中每个节点储存一个数据和两个指针分别指向该节点的前一个节点和后一个节点。这里要提出带哨兵的双向链表，也就是把链表最后一个节点的next指向从空改为第一个节点，第一个节点的prev指向空改为最后一个节点，这样会使链表删除节点插入节点等操作省略一些判断。

#nclude <iostream>
using namespace std;
struct node
{
    int data;
    node*prev;
    node*next;
};
node* createlist()
{
    node*head=new node;
    head->data=0;
    head->next=nullptr;
    head->prev=nullptr;
    return head;
}
void listinsert(node*&l,int m)
{
    node*x=new node;
    node*p=l;
    x->data=m;
    x->next=p;
    if(l!=nullptr)
        p->prev=x;
    l=x;
    x->prev=nullptr;

}
void listdelete(node*l,node*x)
{
    if(x->prev!=nullptr)
        x->prev->next=x->next;
    else
        l=x->next;
    if (x->next!=nullptr)
        x->next->prev=x->prev;
}
void Destory (node*l)
{
    while(l)
    {
        node *p=l->next;
        delete l;
        l=p;
    }
    return;
}
int main()
{
    int n,m,z;
    node *p=createlist();
    cin>>n;
    for (int i=0;i<n;i++)
    {
        cin>>m;
        listinsert(p,m);
    }
    cout<<"输入删除第几个";
        cin>>z;
        node*q=p;
    for(int k=1;k<z;k++)
        q=q->next;
    listdelete(p,q);
    for (int j=0;j<n-1;j++)
    {
        cout<<p->data<<" ";
        p=p->next;
    }
    cin>>z;
    for(int k=0;k<z;k++)

    Destory(p);
    return 0;
}

有根树

有根树最常见的是二叉树，当然还有其他树，树通过孩子与父亲节点所连接。
这里强调下无法确定有多少孩子的一种情况，左孩子有兄弟表示法。