c语言提高学习笔记——03-c提高10day_数据结构

在学习c语言提高-数据结构总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

03-c提高10day_数据结构

目录：
一、队列(Queue)
1、队列基本概念
2、队列的链式存储
练习1：队列的链式存储
二、树和二叉树
1、树的基本概念
2、二叉树基本概念
3、二叉树的遍历
练习1：二叉树递归遍历（先序遍历）
练习2：二叉树的高度和叶子节点数目
练习3：二叉树的拷贝和释放
练习4：二叉树的非递归遍历
三、插入排序
练习1：插入排序

一、队列(Queue)

1、队列基本概念

队列是一种特殊的受限制的线性表。

队列（queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出的（Firs- In First Out)的线性表，简称FIFO，允许插入的一端为队尾，允许删除的一端为队头，队列不允许在中间部位进行操作！假设队列是q=(a1，a2...…,an)，那么al就是队头元素，而an是队尾元素，这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后。如下图：

不支持遍历，不支持随机存取。

2、队列的链式存储

练习1：队列的链式存储

队列的链式存储.c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Person
{
    struct QueueNode node;
    char name[64];
    int age;
};

void test()
{
    //初始化队列
    LinkQueue queue = Init_LinkQueue();
    
    //创建数据
    struct Person p1 = { NULL, "aaa", 10};
    struct Person p2 = { NULL, "bbb", 20};
    struct Person p3 = { NULL, "ccc", 30};
    struct Person p4 = { NULL, "ddd", 40};
    struct Person p5 = { NULL, "eee", 50};
    struct Person p6 = { NULL, "fff", 60};
    
    //插入队列
    Push_LinkQueue(queue, &p1);
    Push_LinkQueue(queue, &p2);
    Push_LinkQueue(queue, &p3);
    Push_LinkQueue(queue, &p4);
    Push_LinkQueue(queue, &p5);
    Push_LinkQueue(queue, &p6);
    
    struct Person* pBack = (struct Person*)Back_LinkQueue(queue);
    printf("队尾元素：%s %d
", pBack->name, pBack->age);
    
    while(Size_LinkQueue(queue) > 0)
    {
        //获得队头元素
        struct Person* person = (struct Person*)Front_LinkQueue(queue);
        //打印队头元素
        printf("Name:%s Age:%d
", person->name, person->age);
        //弹出队头元素
        Pop_LinkQueue(queue);
    }
    
    //销毁队列
    Destroy_LinkQueue(queue);
    
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

LinkQueue.h

#pragma once

#include<stdlib.h>

//链表结点的数据类型
struct QueueNode
{
    struct QueueNode* next;
};

//链表数据类型
struct LQueue
{
    struct QueueNode header;//头结点
    int size;
    struct Queue* rear;//尾指针，始终指向链表的最后一个结点
};

typedef void* LinkQueue;

#ifdef __cpluscplus
extern "C"{
#endif



    //初始化
    LinkQueue Init_LinkQueue();
    //入队
    void Push_LinkQueue(LinkQueue queue, void* data);
    //出队
    void Pop_LinkQueue(LinkQueue queue);
    //获得队头元素
    void* Front_LinkQueue(LinkQueue queue);
    //获得队尾元素
    void* Back_LinkQueue(LinkQueue queue);
    //大小
    int Size_LinkQueue(LinkQueue queue);
    //销毁队列
    void Destroy_LinkQueue(LinkQueue queue);

#ifdef __cpluscplus
}
#endif

LinkQueue.c

#include"LinkQueue"

//初始化
LinkQueue Init_LinkQueue()
{
    struct LQueue* queue = malloc(sizeof(struct LQueue));
    if(NULL == queue)
    {
        return NULL;
    }
    
    queue->header.next = NULL;
    queue->size = 0;
    queue->rear = &(queue->header);
    
    return queue;
}
//入队
void Push_LinkQueue(LinkQueue queue, void* data)
{
    if(NULL == queue)
    {
        return;
    }
    if(NULL == data)
    {
        return;
    }    
    struct LQueue* q = (struct LQueue*)queue;
    struct QueueNode* n = (struct QueueNode*)data;
    
    q->rear->next = n;
    n->next = NULL;
    //更新尾指针
    q->rear = n;
    
    q->size++;
}
//出队
void Pop_LinkQueue(LinkQueue queue)
{
    if(NULL == queue)
    {
        return;
    }
    
    struct LQueue* q = (struct LQueue*)queue;
    
    if(q->size == 0)
    {
        return;
    }
    
    if(q->size == 1)
    {
        q->header.next = NULL;
        q->rear = &(q->header);
        q->size--;
        
        return;
    }
    
    
    struct QueueNode* pFirstNode = q->header.next;
    
    q->header.next = pFirstNode->next;
    
    q->size--;
    
}
//获得队头元素
void* Front_LinkQueue(LinkQueue queue)
{
    if(NULL == queue)
    {
        return NULL;
    }

    struct LQueue* q = (struct LQueue*)queue;
    
    return q->header.next;
}
//获得队尾元素
void* Back_LinkQueue(LinkQueue queue)
{
    if(NULL == queue)
    {
        return NULL;
    }

    struct LQueue* q = (struct LQueue*)queue;
    
    return q->rear;    
}
//大小
int Size_LinkQueue(LinkQueue queue)
{
    if(NULL == queue)
    {
        return -1;
    }

    struct LQueue* q = (struct LQueue*)queue;
    
    return q->size;        
}
//销毁队列
void Destroy_LinkQueue(LinkQueue queue)
{
    if(NULL == queue)
    {
        return;
    }
    free(queue);
    queue = NULL;
}

二、树和二叉树

1、树的基本概念

>树的定义：
由一个或多个（n20)结点组成的有限集合T，有且仅有一个结点称为根(root），当n>1时，其余的结点分为m（m≥0）个互不相交的有限集合T1，T2….Tm。每个集合本身又是一颗树，被称作这个根的子树。

>树的结构特点
■非线性结构，有一个直接前驱，但可能有多个直接后继（1:n）
■树的定义具有递归性，树中还有树。
■树可以为空，即节点个数为0。

>若干术语
■根→即根结点（没有前驱）
■叶子→即终端结点（没有后继）
■森林→指m棵不相交的树的集合（例如删除A后的子树个数）
■有序树→结点各子树从左至右有序，不能互换（左为第一）
■无序树→结点各子树可互换位置。
■双亲→即上层的那个结点（直接前驱）parent
■孩子→即下层结点的子树(直接后继）child
■兄弟→同一双亲下的同层结点（孩子之间互称兄弟）sibling
■堂兄弟→即双亲位于同一层的结点（但并非同一双亲）cousin
■祖先→即从根到该结点所经分支的所有结点
■子孙→即该结点下层子树中的任一结点

■结点→即树的数据元素
■结的度→结点挂接的子树数（有几个直接后继就是几度）
■结点的层次→从根到该结点的层数（根结点算第一层）
■终端结点→即度为0的结点，即叶子
■分支结点→除树根以外的结点（也称为内部结点）
■树的度→所有结点度中的最大值（Max（各结点的度]）
■树的深度（或高度）→指所有结点中最大的层数（Max（各结点的层次））

2、二叉树基本概念

>定义：
n(n>=0)个结点的有限集合，由一个根结点以及两棵互不相交的、分别称为左子树和右子树的二叉树组成，

>逻辑结构：
一对二（1：2）

>基本特征：
■每个结点最多只有两棵子树（不存在度大于2的结点）；
■左子树和右子树次序不能顺倒（有序树）。

>二叉树性质
■性质1：在二叉树的第i层上至多有2^(i-1)个结点（i>0）
■性质2：深度为k的二叉树至多有2^(k) - 1 个结点（k>0）
■性质3：对于任何一棵二又树，若度为2的结点数有n2个，则叶子数（n0）必定为n2+1（即n0=n2+1）

3、二叉树的遍历

>遍历用途
它是树结构插入、删除、修改、查找和排序运算的前提，是二又树一切运算的基础和核心。

>遍历方法
牢记一种约定，对每个结点的查看都是“先左后右”。
限定先左后右，树的遍历有三种实现方案：

DLR       　　　　　　 LDR     　　　　   LRD

先（根）序遍历    中（根）序遍历   后（根）序遍历

■DLR-先序遍历，即先根再左再右
■LDR-中序遍历，即先左再根再右
■LRD-后序遍历，即先左再右再根

注：“先、中、后”的意思是指访问的结点D是先于子树出现还是后于子树出现。
从递归的角度看，这三种算法是完全相同的，或者说这三种遍历算法的访问路径是相同的，只是访问结点的时机不同。

练习1：二叉树递归遍历（先序遍历）

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>


struct BiNode
{
    char ch;
    struct BiNode* lchild;
    struct BiNode* rchild;
};

//二叉树递归遍历（先序遍历）
void recursion(struct BiNode* root)
{
    if(NULL == root)
    {
        return;
    }
    
    printf("%c ", root->ch);
    //递归遍历左子树
    recursion(root->lchild);
    //递归遍历右子树
    recursion(root->rchild);
}

void test()
{
    struct BiNode nodeA = { 'A', NULL, NULL};
    struct BiNode nodeB = { 'B', NULL, NULL};
    struct BiNode nodeC = { 'C', NULL, NULL};
    struct BiNode nodeD = { 'D', NULL, NULL};
    struct BiNode nodeE = { 'E', NULL, NULL};
    struct BiNode nodeF = { 'F', NULL, NULL};
    struct BiNode nodeG = { 'G', NULL, NULL};
    struct BiNode nodeH = { 'H', NULL, NULL};
    
    nodeA.lchild = &nodeB;
    nodeA.rchild = &nodeF;
    
    nodeB.rchild = &nodeF;
    
    nodeC.lchild = &nodeD;
    nodeC.rchild = &nodeE;
    
    nodeF.rchild = &nodeG;
    
    nodeG.lchild = &nodeH;
    
    recursion(&nodeA);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

练习2：二叉树的高度和叶子节点数目

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>


struct BiNode
{
    char ch;
    struct BiNode* lchild;
    struct BiNode* rchild;
};

//int num = 0;全局变量比较浪费空间
//求二叉树的叶子结点数目（先序遍历）
void cuculateLeafNum(struct BiNode* root, int* p)
{
    if(NULL == root)
    {
        return;
    }
    
    if(root->lchild && root->rchild == NULL)
    {
        (*p)++;
    }
    cuculateLeafNum(root->lchild, p);
    cuculateLeafNum(root->rchild, p);
}

int getTreeHeight(struct BiNode* root)
{
    if(NULL == root)
    {
        return 0;
    }    
    
    //求树的左子树高度
    int lheight = getTreeHeight(root->lchild);
    //求树的右子树高度
    int rheight = getTreeHeight(root->lchild);
    
    int height = lheight > rheight ? lheight + 1 : rheight + 1;
    
    return height;
}

void test()
{
    struct BiNode nodeA = { 'A', NULL, NULL};
    struct BiNode nodeB = { 'B', NULL, NULL};
    struct BiNode nodeC = { 'C', NULL, NULL};
    struct BiNode nodeD = { 'D', NULL, NULL};
    struct BiNode nodeE = { 'E', NULL, NULL};
    struct BiNode nodeF = { 'F', NULL, NULL};
    struct BiNode nodeG = { 'G', NULL, NULL};
    struct BiNode nodeH = { 'H', NULL, NULL};
    
    nodeA.lchild = &nodeB;
    nodeA.rchild = &nodeF;
    
    nodeB.rchild = &nodeF;
    
    nodeC.lchild = &nodeD;
    nodeC.rchild = &nodeE;
    
    nodeF.rchild = &nodeG;
    
    nodeG.lchild = &nodeH;
    
    //1.求二叉树的叶子结点数目
    int num = 0;
    cuculateLeafNum(&nodeA, &num);
    printf("叶子结点数目：%d
", num);
    
    //2.求二叉树的高度
    int height = getTreeHeight(&nodeA);
    printf("树的高度：%d
", height);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

练习3：二叉树的拷贝和释放

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>


struct BiNode
{
    char ch;
    struct BiNode* lchild;
    struct BiNode* rchild;
};

//int num = 0;全局变量比较浪费空间
//求二叉树的叶子结点数目（先序遍历）
void cuculateLeafNum(struct BiNode* root, int* p)
{
    if(NULL == root)
    {
        return;
    }
    
    if(root->lchild && root->rchild == NULL)
    {
        (*p)++;
    }
    cuculateLeafNum(root->lchild, p);
    cuculateLeafNum(root->rchild, p);
}

int getTreeHeight(struct BiNode* root)
{
    if(NULL == root)
    {
        return 0;
    }    
    
    //求树的左子树高度
    int lheight = getTreeHeight(root->lchild);
    //求树的右子树高度
    int rheight = getTreeHeight(root->lchild);
    
    int height = lheight > rheight ? lheight + 1 : rheight + 1;
    
    return height;
}
//拷贝
struct BiNode* copyBiTree(struct BiNode* root)
{
    if(NULL == root)
    {
        return NULL;
    }
    
    //先拷贝左子树
    struct BiNode* lchild = copyBiTree(root->lchild);
    //拷贝右子树
    struct BiNode* rchild = copyBiTree(root->rchild);
    
    struct BiNode* newnode = malloc(sizeof(struct BiNode));
    newnode->lchild = lchild;
    newnode->rchild = rchild;
    newnode->ch = root->ch;
    
    return newnode;
}

//释放（后序遍历）
void freeSpace(struct BiNode* root)
{
    if(NULL == root)
    {
        return;
    }    
    
    //释放左子树内存
    freeSpace(root->lchild);
    //释放右子树
    freeSpace(root->rchild);
    
    printf("%c 被释放！
", root->ch);
    free(root);
}

void showBiTree(struct BiNode* root)
{
    if(NULL == root)
    {
        return;
    }

    printf("%c ", root->ch);
    showBiTree(root->lchild);
    showBiTree(root->rchild);
}

void test()
{
    struct BiNode nodeA = { 'A', NULL, NULL};
    struct BiNode nodeB = { 'B', NULL, NULL};
    struct BiNode nodeC = { 'C', NULL, NULL};
    struct BiNode nodeD = { 'D', NULL, NULL};
    struct BiNode nodeE = { 'E', NULL, NULL};
    struct BiNode nodeF = { 'F', NULL, NULL};
    struct BiNode nodeG = { 'G', NULL, NULL};
    struct BiNode nodeH = { 'H', NULL, NULL};
    
    nodeA.lchild = &nodeB;
    nodeA.rchild = &nodeF;
    
    nodeB.rchild = &nodeF;
    
    nodeC.lchild = &nodeD;
    nodeC.rchild = &nodeE;
    
    nodeF.rchild = &nodeG;
    
    nodeG.lchild = &nodeH;
    
    //1.求二叉树的叶子结点数目
    int num = 0;
    cuculateLeafNum(&nodeA, &num);
    printf("叶子结点数目：%d
", num);
    
    //2.求二叉树的高度
    int height = getTreeHeight(&nodeA);
    printf("树的高度：%d
", height);
    
    //3.拷贝二叉树
    struct BiNode* root = copyBiTree(&nodeA);
    showBiTree(root);
    printf("
");
    showBiTree(&nodeA);
    
    //释放（自己开辟的内存）
    freeSpace(root);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

练习4：二叉树的非递归遍历

思路：需要用到栈

模型分析图如下：

代码如下：

二叉树的非递归遍历.c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stdbool.h>
#include"SeqStack.h"

struct BiNode
{
    char ch;
    struct BiNode* lchild;
    struct BiNode* rchild;
};



struct Info
{
    struct BiNode* node;
    bool flag;
};

struct Info* createInfo(struct BiNode* node, bool flag)
{
    struct Info* info = malloc(sizeof(struct Info));
    info->flag = flag;
    info->node = node;
    
    return info;
}

//非递归遍历
void nonRecursion(struct BiNode* root)
{
    //初始化栈
    SeqStack stack = Init_SeqStack();
    //先把根结点压入栈中
    Push_SeqStack(stack, createInfo(root, false));
    
    while(Size_SeqStack(stack) > 0)
    {
        //获得栈顶元素
        struct Info* info = (struct Info*)Top_SeqStack(stack);
        //弹出栈顶元素
        Pop_SeqStack(stack);
        
        if(info->flag)
        {
            printf("%c ", info->node->ch);
            free(info);
            continue;
        }
        
        //将右子树压入栈中
        if(info->node->rchild != NULL)
        {
            Push_SeqStack(stack, createInfo(info->node->rchild, false));
        }
        //将左子树压入栈中
        if(info->node->lchild != NULL)
        {
            Push_SeqStack(stack, createInfo(info->node->lchild, false));
        }
        
        //将根结点入栈
        info->flag = true;
        Push_SeqStack(stack, info);
    }
    
    //销毁栈
    Destroy_SeqStack(stack);
}

void test()
{
    struct BiNode nodeA = { 'A', NULL, NULL};
    struct BiNode nodeB = { 'B', NULL, NULL};
    struct BiNode nodeC = { 'C', NULL, NULL};
    struct BiNode nodeD = { 'D', NULL, NULL};
    struct BiNode nodeE = { 'E', NULL, NULL};
    struct BiNode nodeF = { 'F', NULL, NULL};
    struct BiNode nodeG = { 'G', NULL, NULL};
    struct BiNode nodeH = { 'H', NULL, NULL};
    
    nodeA.lchild = &nodeB;
    nodeA.rchild = &nodeF;
    
    nodeB.rchild = &nodeF;
    
    nodeC.lchild = &nodeD;
    nodeC.rchild = &nodeE;
    
    nodeF.rchild = &nodeG;
    
    nodeG.lchild = &nodeH;
    
    nonRecursion(&nodeA);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

SeqStack.c和SeqStack.h和栈的顺序存储相同——https://www.cnblogs.com/Alliswell-WP/p/C_ImprovedLearning_09.html

SeqStack.h

#pragma once

#include<stdlib.h>
#include<string.h>//memset

#ifdef __cplusplus
extern "C"{
#endif    


#define MAX 1024

    //顺序栈数据结构
    struct SStack
    {
        void* data[MAX];//存放数据的数组
        int size;//栈中元素的个数
    }
    
    //数组高下标的位置当做栈顶，因为不需要移动数组中的元素在插入和删除中
    
    //初始化
    SeqStack Init_SeqStack();
    //入栈
    void Push_SeqStack(SeqStack stack, void* data);
    //出栈
    void Pop_SeqStack(SeqStack stack);
    //获得栈顶元素
    void* Top_SeqStack(SeqStack stack);
    //获得栈的大小
    int Size_SeqStack(SeqStack stack);
    //销毁栈
    void Destroy_SeqStack(SeqStack stack);

#ifdef __cplusplus
}
#endif

SeqStack.c

#include"SeqStack.h"

//初始化
SeqStack Init_SeqStack()
{
    struct SStack* stack = malloc(sizeof(struct SStack));
    if(NULL == stack)
    {
        return NULL;
    }
    
    memset(stack, 0, sizeof(struct SStack));
    stack->size = 0;
    
    return stack;
}
//入栈
void Push_SeqStack(SeqStack stack, void* data)
{
    if(NULL == stack)
    {
        return;
    }
    if(NULL == data)
    {
        return;
    }    
    
    struct SStack* s = (struct SStack*)stack;
    
    s->data[s->size] = data;
    s->size++;
}
//出栈
void Pop_SeqStack(SeqStack stack)
{
    if(NULL == stack)
    {
        return;
    }
    struct SStack* s = (struct SStack*)stack;
    
    if(s->size == 0)
    {
        return;
    }
    
    s->data[s->size-1] = NULL;//此句可有可无，有数据会把这块内存覆盖
    s->size--;
}
//获得栈顶元素
void* Top_SeqStack(SeqStack stack)
{
    if(NULL == stack)
    {
        return NULL;
    }

    struct SStack* s = (struct SStack*)stack;
    
    if(s->size == 0)
    {
        return NULL;
    }
    
    return s->data[s->size-1];
}
//获得栈的大小
int Size_SeqStack(SeqStack stack)
{
    if(NULL == stack)
    {
        return -1;
    }

    struct SStack* s = (struct SStack*)stack;
    return s->size;
}
//销毁栈
void Destroy_SeqStack(SeqStack stack)
{
    if(NULL == stack)
    {
        return;
    }
    free(stack);
        
}

三、插入排序

练习1：插入排序

分析如下：

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

//打印
void printArray(int arr[], int len)
{
    for(int i = 0; i < len; ++i)
    {
        printf("%d ", arr[i]);
    }
    printf("
");
}

//插入排序
void InsertSort(int arr[], int len)
{
    for(int i = 1; i < len; ++i)
    {
        if(arr[i] < arr[i - 1])
        {
            int temp = arr[i];
            int j = i - 1
            for(; j >= 0; temp < arr[j]; j--)
            {
                arr[j + 1] = arr[j];
            }
            
            arr[j + 1] = temp;
        }
    }
    
}

void test()
{
    int arr[] = {5, 3, 9, 2, 1, 3};
    int len = sizeof(arr) / sizeof(int);
    printArray(arr, len);
    InsertSort(arr, len);
    printArray(arr, len);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

在学习c语言提高-数据结构总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。