线性结构

一、数组

#include <stdio.h>
#include <malloc.h>   // 动态分配内存
#include <stdlib.h>   // exit退出
#include <stdbool.h>  // bool类型

struct Arr {
    int *pBase;
    int len;
    int cnt;
};

void InitArray(struct Arr *pArr, int length);

bool ShowArray(struct Arr *pArr);

bool AppendEle2Array(struct Arr *pArr, int val);

bool InsertEle2Array(struct Arr *pArr, int pos, int val);

bool DeleteArrayEle(struct Arr *pArr, int pos, int *pVal);

bool ArrayFull(struct Arr *pArr);

void InversionArray(struct Arr *pArr);

void SortArray(struct Arr *pArr);

int main() {

    struct Arr arr;
    int val;

    InitArray(&arr, 8);
    AppendEle2Array(&arr, 1);
    AppendEle2Array(&arr, 2);
    AppendEle2Array(&arr, 3);
    AppendEle2Array(&arr, 4);
    InsertEle2Array(&arr, 3, 99);
    AppendEle2Array(&arr, 5);
    AppendEle2Array(&arr, 6);
    DeleteArrayEle(&arr, 4, &val);
    AppendEle2Array(&arr, 7);
    InversionArray(&arr);
    SortArray(&arr);
    ShowArray(&arr);
    return 0;
}

// 初始化数组
void InitArray(struct Arr *pArr, int length) {
    pArr->pBase = (int *) malloc(sizeof(int) * length);
    if (pArr->pBase == NULL) {
        printf("动态内存分配失败！\n");
        exit(-1);
    } else {
        pArr->len = length;
        pArr->cnt = 0;
    }
}

// 给数组添加元素
bool AppendEle2Array(struct Arr *pArr, int val) {
    if (ArrayFull(pArr)) {
        return false;
    } else {
        pArr->pBase[pArr->cnt] = val;
        (pArr->cnt)++;
        return true;
    }
}


// 判断数组是否满了
bool ArrayFull(struct Arr *pArr) {
    if (pArr->cnt == pArr->len) {
        return true;
    } else {
        return false;
    }
}

// 判断数组是否为空
bool ArrayEmpty(struct Arr *pArr) {
    if (pArr->cnt == 0) {
        return true;
    } else {
        return false;
    }
}

// 展示数组
bool ShowArray(struct Arr *pArr) {
    if (ArrayEmpty(pArr)) {
        return false;
    } else {
        for (int i = 0; i < pArr->cnt; i++) {
            printf("%d,", pArr->pBase[i]);
        }
    }
    return true;
}

// 插入元素到数组中
bool InsertEle2Array(struct Arr *pArr, int pos, int val) {
    if (ArrayFull(pArr)) {
        return false;
    }
    if (pos < 1 || pos > pArr->cnt + 1) {
        return false;
    }
    for (int i = pArr->cnt - 1; i >= pos - 1; --i) {
        pArr->pBase[i + 1] = pArr->pBase[i];
    }
    pArr->pBase[pos - 1] = val;
    (pArr->cnt)++;
    return true;
}

// 删除数组元素
bool DeleteArrayEle(struct Arr *pArr, int pos, int *pVal) {
    if (ArrayEmpty(pArr)) {
        return false;
    }
    if (pos < 1 || pos > pArr->cnt + 1) {
        return false;
    }
    *pVal = pArr->pBase[pos - 1];
    for (int i = pos; i < pArr->cnt; i++) {
        pArr->pBase[i - 1] = pArr->pBase[i];
    }
    (pArr->cnt)--;
    return true;
}

// 翻转数组
void InversionArray(struct Arr *pArr) {
    int i = 0;
    int j = pArr->cnt - 1;
    int t;
    while (i < j) {
        t = pArr->pBase[j];
        pArr->pBase[j] = pArr->pBase[i];
        pArr->pBase[i] = t;
        i++;
        j--;
    }
}

// 数组排序
void SortArray(struct Arr *pArr) {
    int i, j, k;
    for (i = 0; i < pArr->cnt; i++) {
        for (j = i + 1; j < pArr->cnt; j++) {
            if (pArr->pBase[i] > pArr->pBase[j]) {
                k = pArr->pBase[i];
                pArr->pBase[i] = pArr->pBase[j];
                pArr->pBase[j] = k;
            }
        }
    }
}

二、链表

#include <stdio.h>
#include <malloc.h> // 动态分配内存
#include <stdlib.h> // exit
#include <stdbool.h> // bool类型

typedef struct Node {
    int data; // 数据域
    struct Node *pNext; // 指针域
} NODE, *PNODE;  // NODE 相当于 struct Node, PNODE等价于 struct Node *

// 函数申明
// 创建链表
PNODE CreatList(void);

// 遍历链表
void TraverseList(PNODE pHead);
// 向链表中插入元素
bool InsertEle2List(PNODE pHead, int pos, int val);
// 删除链表中的元素
bool DeleteListEle(PNODE pHead, int pos, int *pVal);

// 链表的长度
int LengthList(PNODE pHead);

//链表排序
void SortList(PNODE pHead);
// 链表是否为空
bool EmptyList(PNODE pHead);

int main() {
    PNODE pHead = NULL;  //等价于 struct Node * pHead = NULL;
    int val;
    pHead = CreatList();

    InsertEle2List(pHead, 3, 99);
    if (DeleteListEle(pHead, 4, &val)) {
        printf("删除的元素是 %d\n", val);
    } else {
        printf("删除失败，删除的元素不存在！\n");
    }
    int len = LengthList(pHead);
    printf("链表的长度为%d \n", len);
    SortList(pHead);
    if (EmptyList(pHead)) {
        printf("链表为空!\n");
    }

    TraverseList(pHead);

    return 0;
}

// 创建链表
PNODE CreatList(void) {
    int len; // 用来存放有效节点的个数
    int i;
    int val; // 用来临时存放输入的节点的值

    // 分配了一个不存放有效数据的头结点
    PNODE pHead = (PNODE) malloc(sizeof(NODE));
    if (NULL == pHead) {
        printf("动态分配内存失败!\n");
        exit(-1);
    }
    PNODE pTail = pHead;
    pTail->pNext = NULL;
    printf("请输入需要生成的链表节点的个数：len=");
    scanf("%d", &len);
    for (i = 0; i < len; i++) {
        printf("请输入第%d个节点的值", i + 1);
        scanf("%d", &val);
        PNODE pNew = (PNODE) malloc(sizeof(NODE));
        if (pNew == NULL) {
            printf("动态分配内存失败！");
            exit(-1);
        }
        pNew->data = val;
        pTail->pNext = pNew;
        pNew->pNext = NULL;
        pTail = pNew;
    }
    return pHead;
}

// 遍历链表
void TraverseList(PNODE pHead) {

    PNODE p = pHead->pNext;
    while (NULL != p) {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("\n");
    return;
}

// 插入数据到链表中
bool InsertEle2List(PNODE pHead, int pos, int val) {
    int i = 0;
    PNODE p = pHead;
    while (NULL != p && i < pos - 1) {
        p = p->pNext;
        ++i;
    }
    if (i > pos - 1 || NULL == p) {
        return false;
    }
    //如果程序能执行到这一行说明p已经指向了第pos-1个结点,但第pos-1个节点是否存在无所谓
    //分配新的结点
    PNODE pNew = (PNODE) malloc(sizeof(NODE));
    if (NULL == pNew) {
        printf("动态分配内存失败！");
        exit(-1);
    }
    pNew->data = val;
    // 将新的节点存入p的后面
    PNODE q = p->pNext;
    p->pNext = pNew;
    pNew->pNext = q;
    return true;
}

// 删除元素
bool DeleteListEle(PNODE pHead, int pos, int *pVal) {
    int i = 0;
    PNODE p = pHead;
    while (NULL != p->pNext && i < pos - 1) {
        p = p->pNext;
        i++;
    }
    if (i > pos - 1 || NULL == p->pNext) {
        return false;
    }
    // 程序执行到此处，说明 p 已经指向了第 pos-1 个节点，并且第 pos个节点是存在的
    PNODE q = p->pNext;
    *pVal = q->data;

    // 删除p节点后面的节点
    p->pNext = p->pNext->pNext;
    // 释放q所指向的节点所占的内存
    free(q);
    q = NULL;
    return true;
}

// 链表的长度
int LengthList(PNODE pHead) {
    PNODE p = pHead->pNext;
    int len = 0;
    while (p != NULL) {
        ++len;
        p = p->pNext;
    }
    return len;
}

// 链表排序
void SortList(PNODE pHead) {
    int i, j, t;
    int len = LengthList(pHead);
    PNODE p, q;
    for (i = 0, p = pHead->pNext; i < len - 1; i++, p = p->pNext) {
        for (j = i + 1, q = p->pNext; j < len; j++, q = q->pNext) {
            if (p->data > q->data) {
                t = p->data;
                p->data = q->data;
                q->data = t;
            }
        }
    }
}

// 链表是否为空
bool EmptyList(PNODE pHead) {
    if (NULL == pHead->pNext)
        return true;
    else
        return false;
}