【0004】数据结构中的栈、堆的实践

　　数据结构中的栈——先进后出，先进先出

　　数据结构中的堆——堆的本质是一个二叉树，包括二分法查找，朗格朗日差值查找，堆排序查找极值

结构体

void main006()
{
    struct myStruct            // 结构体的意义：将多种类型的数据整合在一起
    {
        int a[10];
        int i;
    };

    struct myStruct mys = { {1,3,5,6},10 };            // 初始化数据

    printf("%d, %d 
", mys.i, mys.a[3]);            // 访问结构体内部成员的三种方式
    printf("%d 
", (&mys)->i);
    printf("%d 
", (*(&mys)).i);

    for (int j = 0; j < 10; j++)
        printf("%d ", mys.a[j]);

    system("pause");
}

栈应用

头文件

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

#define N 100

struct stack
{
    int data[N];
    int top;                // 栈顶
};


typedef struct stack Stack;        // 结构体struct stack的别名


void init(Stack *p);            // 初始化（清空栈）
int isempty(Stack *p);        // 栈是否为空
int isfull(Stack *p);            // 栈是否溢出
int getTop(Stack *p);            // 获取栈顶
void push(Stack *p, int key);    // 压栈(插入数据）
void pop(Stack *p);            // 出栈
void show(Stack *p);            // 显示栈信息

栈实体函数

#include "stack.h"

void init(Stack *p)            // 初始化（清空栈）
{
    p->top = -1;            // 代表为空
    memset(p->data, 0, sizeof(int)*N);        // 数据清零
}

int isempty(Stack *p)            // 栈是否为空
{
    if (p->top == -1)
        return 1;
    else
        return 0;
}

int isfull(Stack *p)            // 栈是否溢出
{
    if (p->top >= N)
        return 1;
    else
        return 0;
}

int getTop(Stack *p)            // 获取栈顶
{
    return p->data[p->top];
}

void push(Stack *p, int key)    // 压栈(插入数据）
{
    if (isfull(p))
        return;
    else
    {
        p->top += 1;
        p->data[p->top] = key;
    }
}

void pop(Stack *p)                // 出栈
{
    if (isempty(p))
        return;
    else
        p->top -= 1;
}

void show(Stack *p)
{
    if (isempty(p))
        return;
    else
        for (int i = 0; i <= p->top; i++)
            printf("%4d", p->data[i]);
}

void main007()
{
    int a[10] = { 1,2,3,4,5,6,7,8,9,0 };

    Stack mystack;
    init(&mystack);

    // 数据结构：先进后出（函数参数）
    for (int i = 0; i < 10; i++)
    {
        push(&mystack, a[i]);                // 先压栈
    }

    while (!isempty(&mystack))
    {
        printf("%d ", getTop(&mystack));        // 后出栈
        pop(&mystack);
    }
        
    
    system("pause");
}

void main007()
{
    int a[10] = { 1,2,3,4,5,6,7,8,9,0 };

    Stack mystack;
    init(&mystack);
    
    // 数据结构：先进先出（排队买票）
    for (int i = 0; i < 10; i++)
    {
        push(&mystack, a[i]);                // 压栈
        printf("%d ", getTop(&mystack));        // 打印   
                pop(&mystack);                    // 出栈
    }

    system("pause");
}    

递归方式实现十进制转化为二进制

void from10to2(int num)
{
    if (num == 0)
        return;
    else
    {
        from10to2(num / 2);
        printf("%d", num % 2);
    }
}

void main008()
{
    int num;
    scanf("%d", &num);

    from10to2(num);

    system("pause");
}

栈的“先进后出”方式的实现十进制转化为二进制

#define _CRT_SECURE_NO_WARNINGS
#include "stack.h"


void main009()
{
    Stack mystack;
    init(&mystack);

    int num;
    scanf("%d", &num);

    // 先进后出
    /*while (num)
    {
        push(&mystack, num % 2);            
        num /= 2;
    }

    while (!isempty(&mystack))
    {
        printf("%d", getTop(&mystack));
        pop(&mystack);
    }*/

    // 先进先出
    while (num)
    {
        push(&mystack, num % 2);            
        printf("%d", getTop(&mystack));        
        pop(&mystack);
        num /= 2;
    }

    system("pause");
}

队列应用

头文件

#include <process.h>
#include <Windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

#define N 100                                        // 队列的长度
struct queue
{
    int data[N];
    int head;
    int tail;
};

typedef struct queue Queue;

void initQ(Queue *p);                    // 初始化队列
int isemptyQ(Queue *p);
int isfullQ(Queue *p);

void enQueue(Queue *p, int key);        // 入队
int getQueue(Queue *p);                // 出队值
void deQueue(Queue *p);                // 出队
void showQueue(Queue *p);

                                

队列实体函数

#include "queue.h"


void initQ(Queue *p)
{
    p->head = p->tail = 0;
    memset(p->data, 0, sizeof(int)*N);
}

int isemptyQ(Queue *p)
{
    if (p->head == p->tail)
        return 1;
    else
        return 0;
}

int isfullQ(Queue *p)
{
    if (p->tail >= N - 1)
        return 1;
    else
        return 0;
}

void enQueue(Queue *p, int key)
{
    if (isfullQ(p))
    {
        return;
    }
    else
    {
        if (isemptyQ(p))
        {
            p->data[0] = key;
            p->tail++;
        }
        else
        {
            for (int i = p->tail; i >= 0; i--)    // 数据后移一位
            {
                p->data[i] = p->data[i - 1];
            }

            p->data[0] = key;
            p->tail++;
        }
    }
}

int getQueue(Queue *p)
{
    return p->data[p->tail - 1];
}

void deQueue(Queue *p)
{
    if (isemptyQ(p))
        return;
    else
        p->tail--;
}

void showQueue(Queue *p)
{
    for (int i = 0; i < p->tail; i++)
        printf("%4d", p->data[i]);
}

 多线程与队列的实践

#include "queue.h"

void main016()
{
    Queue myq;
    initQ(&myq);

    for (int i = 98; i < 109; i++)
    {
        enQueue(&myq, i);
        showQueue(&myq);
        putchar('
');
    }
    

    while (!isemptyQ(&myq))
    {
        printf("出队的值为：%d
", getQueue(&myq));
        deQueue(&myq);
        showQueue(&myq);
        putchar('
');
    }

    system("pause");
}


Queue myq;
void run(void *p)
{
    int *px = p;
    printf("线程编号为：%d 
", *px);
    enQueue(&myq, *px);
}

void main017()
{
    initQ(&myq);

    int a[10] = { 1,2,3,4,5,6,7,8,9,0 };
    for (int i = 0; i < 10; i++)
    {
        HANDLE hd = _beginthread(run, 0, &a[i]);    // 多核运行多线程，打印是无序的
        //WaitForSingleObject(hd,INFINITE);        // 等待一个线程结束之后，再允许下一个线程执行（有序打印）
    }


    system("pause");
    showQueue(&myq);
    system("pause");
}