文章目录
栈实现
https://www.cnblogs.com/maluning/p/7979453.html
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*定义节点结构*/
typedef struct Node{
int value;
struct Node *next;
}NODE;
/*定义栈结构*/
typedef struct Stack{
NODE *top;
NODE *tail;
}STACK;
/*初始化栈*/
static void InitStack(struct Stack *s);
/*给栈增加元素*/
static void PushStack(struct Stack *s,int value);
/*弹出栈顶元素*/
static void PopStack(struct Stack *s,int *value);
/*栈是否为空*/
static int IsEmpty(struct Stack *s);
/*遍历栈*/
static void TraverseStack(struct Stack *s);
/*定义栈清空函数*/
static void ClearStack(struct Stack *s);
int main()
{
int value = 0;
STACK stack = {NULL};
InitStack(&stack);
PushStack(&stack,10);
PushStack(&stack,20);
PopStack(&stack,&value);
PushStack(&stack,30);
PushStack(&stack,40);
PushStack(&stack,50);
TraverseStack(&stack);
ClearStack(&stack);
PopStack(&stack,&value);
return 0;
}
/*初始化栈*/
static void InitStack(struct Stack *s)
{
NODE *tmp = (NODE *)malloc(sizeof(NODE));
if (NULL == tmp){
printf("apply memory fail!!!\n");
return;
}
s->top = tmp;
s->tail = tmp;
tmp->next = NULL;
printf("init stack success!!!\n");
}
/*定义入栈函数*/
static void PushStack(struct Stack *s,int value)
{
NODE *tmp = (NODE *)malloc(sizeof(NODE));
if (NULL == tmp){
printf("apply memory fail!!!\n");
return;
}
tmp->next = s->top;
s->top = tmp;
tmp->value = value;
}
/*定义出栈函数*/
static void PopStack(struct Stack *s,int *value)
{
NODE *tmp = NULL;
if (s->tail == s->top){
printf("stack is empty!!!\n");
return;
}
tmp = s->top;
(*value) = tmp->value;
s->top = s->top->next;
free(tmp);
tmp = NULL;
return;
}
/*判断栈是否为空*/
static int IsEmpty(struct Stack *s)
{
if (s->top == s->tail){
return 0;
}else{
return 1;
}
}
/*遍历栈*/
static void TraverseStack(struct Stack *s)
{
if (!IsEmpty(s)){
printf("stack is empty!!\n");
}
NODE *tmp = s->top;
printf("value is ");
while (tmp->next){
printf("%d ",tmp->value);
tmp=tmp->next;
}
printf("\n");
return;
}
/*定义栈清空函数*/
static void ClearStack(struct Stack *s)
{
if (!IsEmpty(s)){
printf("stack is empty!!\n");
}
NODE *P = s->top;
NODE *Q = NULL;
while(P != s->tail){
Q = P;
P = P->next;
free(Q);
}
s->top = s->tail;
printf("clear success!!!\n");
}
队列实现
https://www.cnblogs.com/maluning/p/7979456.html
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct Node{
int value;
struct Node *next;
}NODE;
typedef struct Queue{
struct Node *top;
struct Node *tail;
}QUEUE;
/*定义队列初始化函数*/
void InitQueue(struct Queue *Q);
/*定义入队函数*/
void InsertQueue(struct Queue *Q,int value);
/*定义出队函数*/
void DeleteQueue(struct Queue *Q,int *value);
/*判断队列是否为空*/
int IsEmptyQueue(struct Queue *Q);
/*清空队列*/
void ClearQueue(struct Queue *Q);
/*遍历队列*/
void TraverseQueue(struct Queue *Q);
int main()
{
int value = 0;
struct Queue test = {NULL};
InitQueue(&test);
InsertQueue(&test,10);
InsertQueue(&test,20);
InsertQueue(&test,30);
DeleteQueue(&test,&value);
DeleteQueue(&test,&value);
printf("v:%d\n",value);
//ClearQueue(&test);
//DeleteQueue(&test,&value);
TraverseQueue(&test);
//printf("the top is %d\n",test.top->next->value);
}
/*定义队列初始化函数*/
void InitQueue(struct Queue *Q)
{
struct Node *tmp = NULL;
tmp = (struct Node *)malloc(sizeof(struct Queue));
if (NULL == tmp){
printf("apply memory error!!!\n");
return;
}
Q->top = Q->tail = tmp;
tmp->next = NULL;
return;
}
/*定义入队函数*/
void InsertQueue(struct Queue *Q,int value)
{
struct Node *tmp = NULL;
tmp = (struct Node *)malloc(sizeof(struct Queue));
if (NULL == tmp){
printf("apply memory error!!!\n");
return;
}
tmp->value = value;
tmp->next =NULL;
Q->tail->next = tmp;
Q->tail = tmp;
}
/*判断队列是否为空*/
int IsEmptyQueue(struct Queue *Q)
{
if (Q->top == Q->tail){
return 0;
}else{
return 1;
}
}
/*定义出队函数*/
void DeleteQueue(struct Queue *Q,int *value)
{
struct Node *tmp = NULL;
if (!IsEmptyQueue(Q)){
printf("Queue is empty!!!\n");
return;
}
tmp = Q->top->next;
Q->top->next=tmp->next;
*value = tmp->value;
if (tmp == Q->tail){
Q->tail = Q->top;
}
free(tmp);
tmp =NULL;
}
/*清空队列*/
void ClearQueue(struct Queue *Q)
{
struct Node *tmp = NULL;
struct Node *T = NULL;
T = Q->top->next;
if(T != NULL){
tmp = T;
T = T->next;
free(tmp);
}
//尾指针指向头指针
Q->tail = Q->top;
//头指针的next指向为NULL
Q->top->next = NULL;
}
/*遍历队列*/
void TraverseQueue(struct Queue *Q)
{
if (!IsEmptyQueue(Q)){
printf("Queue is empty!!!\n");
return;
}
struct Node *P = Q->top->next;
while (P){
printf("the value is %d\n",P->value);
P=P->next;
}
return;
}
堆实现(最大堆)
堆排序
https://www.cnblogs.com/Java3y/p/8639937.html
堆实现参考
https://blog.csdn.net/carl_2018/article/details/90679149
图解堆操作过程
https://blog.csdn.net/u011068702/article/details/52712634
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct Heap{
int *array;
int size;
int capacity;
}HEAP;
/*堆初始化*/
void HeapInit(struct Heap *hp,int *a,int n);
/*给堆添加数据*/
void HeapPush(struct Heap *hp,int data);
/*堆中踢出数据*/
void HeapPop(struct Heap *hp);
/*打印*/
void HeapPrint(struct Heap* hp);
/*堆排序*/
void HeapSort(struct Heap* hp);
/*取堆头*/
int HeapTop(struct Heap *hp);
/*获取堆大小*/
int HeapSize(struct Heap *hp);
/*堆判空*/
int HeapEmpty(struct Heap *hp);
/*销毁堆*/
void HeapDestory(struct Heap *hp);
int main()
{
int a[10] = { 11, 14, 9, 23, 34, 16, 24, 65, 52, 45 };
HEAP hp;
HeapInit(&hp, a, sizeof(a) / sizeof(int));
HeapPush(&hp, 70);
HeapPop(&hp);
HeapPrint(&hp);
HeapSort(&hp);
HeapPrint(&hp);
printf("\n");
printf("the top is %d\n",HeapTop(&hp));
}
void HeapPrint(struct Heap* hp)
{
int i = 0;
for (i = 0; i < hp->size; ++i)
{
printf("%d ", hp->array[i]);
}
printf("\n");
}
void Swap(int *p1,int *p2)
{
int tmp = *p1;
*p1=*p2;
*p2=tmp;
return;
}
/*建堆*/
void AdjustDown(int *a,int n,int root)
{
int parent = root;
int child = parent*2+1;
while (child < n){
/*找到孩子中大的一个*/
if ((child+1) < n && a[child+1] > a[child]){
++child;
}
/*如何孩子大于父亲,则替换*/
if (a[child] > a[parent]){
Swap(&a[child],&a[parent]);
parent = child;
child = parent*2+1;
}else{
break;
}
}
}
/*堆排序*/
void HeapSort(struct Heap* hp)
{
int end = hp->size;
int *a = hp->array;
end--;
while(end > 0){
Swap(&a[0],&a[end]);
AdjustDown(a,end,0);