数据结构与算法5

堆栈应用

表达式求值

后缀

从左到右读入后缀表达式的各项(运算符或数)
1.运算数:入栈
2.运算符:从堆栈中弹出适当数量的运算数，计算并结果入栈
3.堆栈顶上的元素就是表达式的结果值

中缀

转化为后缀
数:直接输出;
左括号:压入堆栈;
右括号:将栈顶的运算符弹出并输出，直到遇到左括号（出栈，不输出)
运算符:若优先级大于栈顶运算符，把它压栈;
若优先级小于等于栈顶运算符时，将栈顶运算符弹出并输出;再比较新的栈顶运算符，直到该运算符大于栈顶运算符优先级为止，然后将该运算符压栈:
处理完毕，则把堆栈中存留的运算符一并输出。

队列

队列及顺序存储实现

什么是队列

队列(Queue):具有一定操作约束的线性表
插入和删除操作:只能在一端插入,在另一端删除。
数据插入:入队列(AddQ)
数据删除:出队列(DeleteQ)先来先服务
先进先出

队列的顺序存储实现

队列的顺序存储结构通常由一个一维数组和一个记录队列头元素位置的变量front以及一个记录队列尾元素位置的变量rear组成。

#define MaxSize<存数据元素的最大个数>
struct Qkode {
ElementType Data[ MaxSize jint rear;
int front;
};
typedef struct QNode *Queue;

插入一个元素rear+1，删除一个元素front+1
只放n-1个

//入队列
void AddQ( Queue PtrQ,ElementType item)
{
	if ( (PtrQ->rear+1) % MaxSize == PtrQ->front ) { //+1取余
		printf("队列满");
		return;
)
	PtrQ->rear=(PtrQ->rear+1)%MaxSize;			//+1取余
	PtrQ->Data[PtrQ->rear]= item;         												
}

//出队列
ElementType DeleteQ ( Queue PtrQ)
if ( PtrQ->front == PtrQ->rear ) {
	printf("队列空");
	return ERROR;
	}else {
	PtrQ->front = (PtrQ->front+1)% MaxSize; //+1取余
	return PtrQ->Data[PtrQ->front];
  }
}

+1取余体现顺序存储的循环使用

队列链式存储实现

struct Node{
ElementType Data;struct Node *Next;};
struct QNode{/链队列结构*/
struct Node *rear;/*指向队尾结点*/struct Node *front;/*指向队头结点*/};
typedef struct QNode *Queue;Queue PtrQ;

出队操作

Element Type Delete ( Queue PtrQ)
{struct Node *FrontCell;
 ElementType FrontElem;
 if (PtrQ->front == NULL) {
		printf(“队列空”);
		return ERROR;
}
FrontCell = PtrQ->front;
if (PtrQ->front == PtrQ->rear)/*若队列只有一个元素*/
	PtrQ->front = PtrQ->rear = NULL;/*删除后队列置为空*/
else
	PtrQ->front = PtrQ->front->Next;
	FrontElem = FrontCell->Data;
	free( FrontCell );
/*释放被删除结点空间*/
 return FrontElem;
}

顺序存储相关代码

typedef int Position;
struct QNode {
    ElementType *Data;     /* 存储元素的数组 */
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
typedef struct QNode *Queue;

Queue CreateQueue( int MaxSize )
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MaxSize;
    return Q;
}

bool IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}

bool AddQ( Queue Q, ElementType X )
{
    if ( IsFull(Q) ) {
        printf("队列满");
        return false;
    }
    else {
        Q->Rear = (Q->Rear+1)%Q->MaxSize;
        Q->Data[Q->Rear] = X;
        return true;
    }
}

bool IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}

ElementType DeleteQ( Queue Q )
{
    if ( IsEmpty(Q) ) { 
        printf("队列空");
        return ERROR;
    }
    else  {
        Q->Front =(Q->Front+1)%Q->MaxSize;
        return  Q->Data[Q->Front];
    }
}

链式存储相关代码

typedef struct Node *PtrToNode;
struct Node { /* 队列中的结点 */
    ElementType Data;
    PtrToNode Next;
};
typedef PtrToNode Position;

struct QNode {
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
typedef struct QNode *Queue;

bool IsEmpty( Queue Q )
{
    return ( Q->Front == NULL);
}

ElementType DeleteQ( Queue Q )
{
    Position FrontCell; 
    ElementType FrontElem;
    
    if  ( IsEmpty(Q) ) {
        printf("队列空");
        return ERROR;
    }
    else {
        FrontCell = Q->Front;
        if ( Q->Front == Q->Rear ) /* 若队列只有一个元素 */
            Q->Front = Q->Rear = NULL; /* 删除后队列置为空 */
        else                     
            Q->Front = Q->Front->Next;
        FrontElem = FrontCell->Data;

        free( FrontCell );  /* 释放被删除结点空间  */
        return  FrontElem;
    }
}