广工AnyView数据结构-2

/****
【题目】试写一算法，实现顺序栈的判空操作
StackEmpty_Sq(SqStack S)。
顺序栈的类型定义为：
typedef struct {
ElemType *elem; // 存储空间的基址
int top; // 栈顶元素的下一个位置，简称栈顶位标
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack; // 顺序栈
*/

Status StackEmpty_Sq(SqStack S)
/* 对顺序栈S判空。                      */ 
/* 若S是空栈，则返回TRUE；否则返回FALSE */
{
    if(S.top==0)
        return TRUE;
    else
        return FALSE;
}

---

/****
【题目】试写一算法，实现顺序栈的取栈顶元素操作
GetTop_Sq(SqStack S, ElemType &e)。
顺序栈的类型定义为：
typedef struct {
ElemType *elem; // 存储空间的基址
int top; // 栈顶元素的下一个位置，简称栈顶位标
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack; // 顺序栈
*/

Status GetTop_Sq(SqStack S, ElemType &e) 
/* 取顺序栈S的栈顶元素到e，并返回OK； */ 
/* 若失败，则返回ERROR。              */
{
     if(S.top==0)
        return ERROR;
     e=S.elem[--S.top];
     return OK;
}

/****
【题目】若顺序栈的类型重新定义如下。试编写算法，
构建初始容量和扩容增量分别为size和inc的空顺序栈S。
typedef struct {
ElemType *elem; // 存储空间的基址
ElemType *top; // 栈顶元素的下一个位置
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack2;
*/

Status InitStack_Sq2(SqStack2 &S, int size, int inc)
/* 构建初始容量和扩容增量分别为size和inc的空顺序栈S。*/ 
/* 若成功，则返回OK；否则返回ERROR。                 */
{
    S.elem=(ElemType*)malloc(S.size*sizeof(ElemType));
    if(S.elem==NULL)   //构建失败 
        return ERROR;
    if(size<0||inc<0)     //参数错误
        return ERROR;
    S.size=size;
    S.increment=inc;
    S.top=S.elem;
    return OK;           
}

---

/****
【题目】若顺序栈的类型重新定义如下。试编写算法，
实现顺序栈的判空操作。
typedef struct {
ElemType *elem; // 存储空间的基址
ElemType *top; // 栈顶元素的下一个位置
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack2;
*/

Status StackEmpty_Sq2(SqStack2 S)
/* 对顺序栈S判空。                      */ 
/* 若S是空栈，则返回TRUE；否则返回FALSE */
{
    if(S.top==S.elem)
        return TRUE;
    else
        return FALSE;
}

/****
【题目】若顺序栈的类型重新定义如下。试编写算法，
实现顺序栈的入栈操作。
typedef struct {
ElemType *elem; // 存储空间的基址
ElemType *top; // 栈顶元素的下一个位置
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack2;
*/

Status Push_Sq2(SqStack2 &S, ElemType e)
/* 若顺序栈S是满的，则扩容，若失败则返回ERROR。*/
/* 将e压入S，返回OK。                          */
{
    if(S.size==S.increment)  //顺序栈已满
        S.elem=(ElemType*)realloc(S.elem,(S.size+S.increment)*sizeof(ElemType));
    if(S.elem==NULL)    //顺序栈扩容失败
        return ERROR;
    *S.top++=e;
    S.size=S.size+S.increment;
    return OK;
}

---

/****
【题目】若顺序栈的类型重新定义如下。试编写算法，
实现顺序栈的出栈操作。
typedef struct {
ElemType *elem; // 存储空间的基址
ElemType *top; // 栈顶元素的下一个位置
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack2;
*/

Status Pop_Sq2(SqStack2 &S, ElemType &e) 
/* 若顺序栈S是空的，则返回ERROR；    */ 
/* 否则将S的栈顶元素出栈到e，返回OK。*/
{
    if(S.top==S.elem)   //顺序栈为空  
        return ERROR;
    e=*(--S.top);
    return OK;
}

---

/****
【题目】试写一算法，借助辅助栈，复制顺序栈S1得到S2。
顺序栈的类型定义为：
typedef struct {
ElemType *elem; // 存储空间的基址
int top; // 栈顶元素的下一个位置，简称栈顶位标
int size; // 当前分配的存储容量
int increment; // 扩容时，增加的存储容量
} SqStack; // 顺序栈
可调用顺序栈接口中下列函数：
Status InitStack_Sq(SqStack &S, int size, int inc); // 初始化顺序栈S
Status DestroyStack_Sq(SqStack &S); // 销毁顺序栈S
Status StackEmpty_Sq(SqStack S); // 栈S判空，若空则返回TRUE，否则FALSE
Status Push_Sq(SqStack &S, ElemType e); // 将元素e压入栈S
Status Pop_Sq(SqStack &S, ElemType &e); // 栈S的栈顶元素出栈到e
*/
解题思路：栈是先进后出的，因此借用S3，需要用来两次倒序，第一次倒序插入S3，再将S3倒序插入S2，即所有元素正序，即完成复制顺序栈操作。

Status CopyStack_Sq(SqStack S1, SqStack &S2) 
/* 借助辅助栈，复制顺序栈S1得到S2。    */ 
/* 若复制成功，则返回TRUE；否则FALSE。 */
{
     SqStack S3;
     int e;
     InitStack_Sq(S2,S1.size,S1.increment);
     InitStack_Sq(S3,S1.size,S1.increment);
     while(StackEmpty_Sq(S1)!=TRUE){ //先将S1元素倒序插入S3
       Pop_Sq(S1,e);
       Push_Sq(S3,e);
       }
     if(S3.elem==NULL)    //S1倒序插入S3失败
        return ERROR;
     while(StackEmpty_Sq(S3)!=TRUE){