## 各种基本算法实现小结（二）—— 堆 栈

（均已测试通过）

==============================================================

```#include <stdio.h>
char stack[512];
int top=0;
void push(char c)
{
stack[top]=c;
top++;
}
char pop()
{
top--;
return stack[top];
}
int is_empty()
{
return 0==top;
}
void main()
{
push('1');
push('2');
push('3');
push('4');
push('5');
while(!is_empty())
putchar(pop());
putchar('/n');
getch();
}```

====================================================

```#include <stdio.h>
#include <malloc.h>
/* typedef int DataType; */
#define DataType int
#define MAX 1024
typedef struct
{
DataType data[MAX];
int top;
}stack, *pstack;
pstack *init_stack()
{
pstack ps;
ps=(pstack)malloc(sizeof(stack));
if(!ps)
{
printf("Error. fail malloc.../n");
return NULL;
}
ps->top=-1;
return ps;
}
int empty_stack(pstack ps)
{
if(-1 == ps->top)
return 1;
else
return 0;
}
int push(pstack ps, DataType data)
{
if(ps->top == MAX-1)
{
printf("Stack is full.../n");
return 0;
}
ps->top++;
ps->data[ps->top]=data;
return 1;
}
int pop(pstack ps, DataType *data)
{
if(empty_stack(ps))
{
printf("Stack is empty.../n");
return 0;
}
*data=ps->data[ps->top];
ps->top--;
return 1;
}
DataType top_stack(pstack ps)
{
if(empty_stack(ps))
{
printf("Stack is empty.../n");
return 0;
}
return ps->data[ps->top];
}
void display(pstack ps)
{
int i;
if(empty_stack(ps))
{
printf("Stack is empty.../n");
return;
}
printf("printf the items of stack.../n");
for(i=ps->top;i>-1;i--)
printf("%4d", ps->data[i]);
printf("/n/n");
}
void main()
{
int i, num, data, *pdata;
pstack ps;
ps=init_stack();
printf("Enter stack num:");
scanf("%d", &num);
for(i=0;i<num;i++)
{
scanf("%d", &data);
push(ps, data);
}
display(ps);
printf("Top is %d/n/n", top_stack(ps));
for(i=0;i<num;i++)
{
pop(ps, pdata);
printf("%3d", *pdata);
}
printf("/n/n");
display(ps);
getch();
}
```

====================================================

```#include <stdio.h>
#include <malloc.h>
typedef char DataType;
struct _node
{
DataType data;
struct _node *next;
};
typedef struct _node node, *pstack;
pstack init_stack()
{
pstack ps;
ps=(pstack)malloc(sizeof(node));
if(NULL == ps)
{
printf("Error. malloc is fail.../n");
return NULL;
}
ps->data=-1;  /* base of stack: data=-1 and next=NULL */
ps->next=NULL;
return ps;
}
pstack push(pstack ps, DataType data)
{
pstack ptop;
ptop=(pstack)malloc(sizeof(node));
if(NULL == ptop)
{
printf("Error. malloc is fail.../n");
return NULL;
}
ptop->data=data;
ptop->next=ps;   /* insert new item */
ps=ptop;         /* move top */
return ps;
}
pstack pop(pstack ps, DataType *data)
{
if(ps->next == NULL)
{
printf("stack is empty.../n");
return NULL;
}
*data=ps->data;
ps=ps->next;
return ps;
}
DataType top_stack(pstack ps)
{
if(ps->next == NULL)  /* if empty */
{
printf("stack is empty.../n");
return -1;
}
return ps->data;
}
int len_stack(pstack ps)
{
int len=0;
pstack ptop=ps;
while(ptop->next)
{
len++;
ptop=ptop->next;
}
return len;
}
void display(pstack ps)
{
pstack ptop;
ptop=ps;
while(ptop->next != NULL)
{
printf("%4c", ptop->data);
ptop=ptop->next;
}
printf("/n/n");
}
void main()
{
pstack ps;
DataType *data=(DataType *)malloc(sizeof(DataType));
ps=init_stack();
ps=push(ps, 'a');
ps=push(ps, 'b');
ps=push(ps, 'c');
ps=push(ps, 'd');
ps=push(ps, 'e');
display(ps);
printf("len of stack is: %d/n/n", len_stack(ps));
printf("top of stack is: %c/n/n", top_stack(ps));
ps=pop(ps, data);
printf("pop %c/n",*data);
display(ps);
ps=pop(ps, data);
printf("pop %c/n",*data);
display(ps);
getch();
}```

========================================================

```#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
struct _node
{
int data;
struct _node *next;
};
typedef struct _node node, *pnode;
{
pnode front;
pnode rear;
};
{
lq.front=lq.rear=(pnode)malloc(sizeof(node));
if(NULL == lq.front)
{
printf("Error. malloc is fail.../n");
exit(1);
}
lq.rear->data=lq.front->data=-1;
lq.rear->next=lq.front->next=NULL;
return lq;
}
{
if(lq.front == lq.rear)
return 1;
else
return 0;
}
{
pnode pq;
pq=(pnode)malloc(sizeof(node));
if(pq == NULL)
{
printf("Error. malloc is fail.../n");
exit(1);
}
pq->data=data;
pq->next=lq.rear->next;
lq.rear->next=pq;
lq.rear=lq.rear->next;
return lq;
}
{
if(empty_queue(lq))
{
printf("queue is empty.../n");
exit(1);
}
*data=lq.front->data;
lq.front=lq.front->next;
return lq;
}
{
int len=0;
while(lq.front)
{
len++;
lq.front=lq.front->next;
}
return len;
}
{
p=lq;
if(empty_queue(lq))
{
printf("queue is empty.../n");
return;
}
while(p.front->next)
{
printf("%4d", p.front->data);
p.front=p.front->next;
}
printf("%4d/n/n", p.front->data);
}
void main()
{
int *data = (int *)malloc(sizeof(int));
lq=init_queue();
lq=insert_item(lq, 1);
lq=insert_item(lq, 2);
lq=insert_item(lq, 3);
lq=insert_item(lq, 4);
lq=insert_item(lq, 5);
display(lq);
printf("len of queue is: %d/n/n", len_queue(lq));
lq=delete_item(lq, data);
printf("delete %d/n", *data);
display(lq);
lq=delete_item(lq, data);
printf("delete %d/n", *data);
display(lq);
getch();
}```