数据结构第三章学习小结

1.这一章学习了两种新的结构，栈和队列，栈是后进先出的结构，队列是先进先出的结构，两种结构的特点决定了两种结构使用的场景。下面对栈和队列的一些基本操作进行展示。

（一）栈（分为顺序栈和链栈，这里是顺序栈的一些基本操作）

#include <iostream>
#include <cstring>
using namespace std;

const int MAXSIZE = 100;  //最大长度

typedef struct
{
    char data[MAXSIZE];
    int top;  //作为栈顶标志
    int stackSize;  //栈的最大容量
}SqStack;

void initStack(SqStack& s) //将栈初始化
{
    s.top = 0;
    s.stackSize = MAXSIZE;
}

void push(SqStack& s,char e)  //将元素e入栈
{
    s.data[s.top++] = e;
}

void pop(SqStack& s, char& e)  //出栈一元素至e
{
    e = s.data[--s.top];
}

bool stackEmpty(SqStack s)  //判断s是否栈空
{
    if (s.top == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

bool stackFull(SqStack s)  //判断s是否栈满
{
    if (s.top == s.stackSize)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

栈经常用于括号匹配，表达式求值。

（二）队列(分为顺序队和链队，这里是链队的一些基本操作)

typedef int QElemType;
typedef int Status;
typedef struct QNode
{
    QElemType data;     //数据域
    struct QNode* next;    //指针域 
}QNode, * QueuePtr;

typedef struct
{
    QueuePtr front;   //队头指针
    QueuePtr rear;    //队尾指针
}LinkQueue;

Status InitQueue(LinkQueue& Q)
{//构造一个空队列
    Q.front = Q.rear = new QNode;   //生成新节点作为头节点，对头和队尾指针指向此节点
    Q.front->next = NULL;          //头指针的指针域置空
    return 1;
}

Status EnQueue(LinkQueue& Q, QElemType e)
{//插入新元素e为Q的新队尾元素
    QueuePtr p;
    p = new QNode;   //为新入队元素分配节点空间，用指针p指向
    p->data = e;     //将新结点的数据域置为e
    Q.rear->next = p;
    p->next = NULL;      //将新节点插入至队尾
    Q.rear = p;         //修改队尾指针
    return 1;
}

Status DeQueue(LinkQueue& Q,QElemType &e)
{//删除Q的队头元素
    if (Q.front == Q.rear)  return 0;     //若队列空，则返回0
    QueuePtr p;
    p = Q.front->next;         //p指向队头元素
    e = p->data;               //e保存队头元素的值
    Q.front->next = p->next;     //修改头指针
    if (Q.rear == p)            //最后一个元素被删，队尾指针指向头节点
    {
        Q.rear = Q.front;
    }
    delete p;          //释放原队头元素的空间
    return 1;
}

QElemType GetHead(LinkQueue Q)
{//返回Q的队头元素，不修改队头指针
    if (Q.front != Q.rear)            //队列非空
    {
        return Q.front->next->data;          //返回队头元素的值，队头指针不变
    }
}

队列常用于舞伴配对。

2.除了这两种结构外，我们还学习了递归的使用，下面这个是递归常见的一个例子：

题目：若有10级台阶，小白每次最多能跨3级，则小白登上这10级台阶一共有多少种方法？请给出具体的分析或计算过程。

/*思路 
爬10级楼梯可以分为三种情况：

1）从9级楼梯爬1级

2）从8级楼梯爬2级

3）从7级楼梯爬3级

即 f (10) = f (9) + f (8) + f (7), 

由此可以推出 f (n) = f (n-1) + f (n-2) + f (n-3)

当 n = 1时，只有一种走法：（1）

当 n = 2时，共有两种走法：（1，1）、（2，0）

当 n = 3时，共有三种走法：（1，1，1）、（1，2，0）、（2，1，0）、（3，0，0）

所以，f (4) = f (3) + f (2) + f (1) = 4 + 2 + 1 = 7；

           f (5) = f (4) + f (3) + f (2) = 7 + 4 + 2 = 13；

           f (6) = f (5) + f (4) + f (3) = 13 + 7 + 4 = 24；

           f (7) = f (6) + f (5) + f (4) = 24 + 13 + 7 = 44；

           f (8) = f (7) + f (6) + f (5) = 44 + 24 + 13 = 81；

           f (9) = f (8) + f (7) + f (6) = 81 + 44 + 24 = 149；

           f (10) = f (9) + f (8) + f (7) = 149 + 81 + 44 = 274；
*/

#include <iostream>
int f(int n)
{
    if(n==1) return 1;
    else if(n==2) return 2;
    else if(n==3) return 4;
    else return (f(n-1)+f(n-2)+f(n-3));
}
using namespace std;
int main ()
{
    int n;
    cin >> n; 
    cout << f(n);
    return 0;
}

3.我们进行了一次小组合作打代码，开始pta一直显示运行超时，后来经过思考和修改，找到了错误在的地方，在这里放出来，希望自己和同学下次可以注意

    int m,temp=0;
    cin >> m;
    string snum;
    for(int i=0;i<m;i++)
    {
        cin>> snum;
        for(int j=temp;j<a.length;j++)
        {
            if(snum==a.cus[j].num){
                cin >> a.cus[j].integral;
                temp=j;
                break;
            }
        }
    }

这里题目规定了输入是升序的，所以每次查找时可以从上次查找的地方往后查，不需要重头开始，这样可以省下很多时间。

4.经过几周的学习，感觉自己现在可以脱离书本打一些代码了，并且懂得去思考如何降低时间复杂度。

5.希望以后的代码可以少一些错误，在打的时候就考虑到时间复杂度和空间复杂度，把已经学了的结构的基本操作记熟。