//1.在声明的时候表示声明了一个指针变量
int *p

//2.在使用的时候，表示value内存地址的值
int value = *p;

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main() {
    struct Point p = {1, 2};
    struct Point *ptr = &p;

    // 使用 `->` 访问结构体成员
    printf("x: %d, y: %d\n", ptr->x, ptr->y);
    return 0;
}

struct Node{
  int data;
    Node* next; //结构体定义指针
}

// 实现单链表
Node* head;
head = null;

// 插入
void insert(int value)
{
    //申请新节点
  Node* newNode = new Node(value);
    newNode->next = head;
  // 更新头指针
    head = newNode; //函数名称表示链表中的第一个节点
}

// 用尾指针维护链表
struct Node{
  int a; //数据域
    Node* next; //指针域
}

Node* tail; //尾指针维护

void insert(int value){
    // 创建节点
  Node* newNode = new Node(value);

    // 如果链表是空的,尾指针指向最后一个元素
  if(tail == nullptr){
    tail = newNode;
    }else{
        // 将新节点添加到尾部
        tail ->next = newNode;
        // 更新指向尾部
        tail = newNode;
    }

}

struct Node{
  int value;
    Node* next; // 指针域
}

// 插入到指定的位置
void insert(int index,int value){
    if(index<0) return 0; // 数据不合法

    // 找到这个index前面, 先创建一个节点
    Node newNode = new Node(value);
    Node *cur = head;
    int count = 0;
    while (cur && count < index-1){
        count++;
        cur = cur->next;
    }
    // 这两条代码不能交换次序
    cur->next = newNode;
    newNode->next = cur->next; //这里的cur已经赋值了

}

// 更改指定位置的数据
void change(int index,int value)
{
    // 声明一个指针变量，获取头结点
    Noed* cur = head;
    int count = 0;

    // 遍历链表
    while(cur!=nullptr && count<index)
    {
        cur = cur->next;
        cur++;
    }
    // 更新数据
    if(cur!=nullptr) cur->data = value;
}

// 删除头结点的元素
void removeFront()
{
    if(head){
      Node* temp = head;
        head->next = head;
        free(temp); // 解放数据
    }
}

// 删除链表尾部的数据
void removeRear()
{
  // 1.链表中没有数据的情况
      if(head == nullptr && head->next == nullptr){
      // 链表为空或者只有一个节点
            if(head!=nullptr)
            {
         Node* temp = head;
                head = nullptr;
                free(temp);
            }
            return;
        }
  // 2. 链表中有数据的情况
      Node* cur = head; // 遍历的变量
      while(cur->next->next != nullptr) //遍历到前一个节点
        {
            cur = cur->next;
        }
      Node* temp = cur->next;
      cur->next = nullptr;
      free(temp);

}

// 删除中间段落的节点
void removeInside(int value,int index)
{
    //1.合法
    if(index<0) return 0;
    if(index == 0)
    {
        // 只有一个节点或者为空
        if(head){
            Node* temp = head;
            head = head->next;
            free(temp);
        }
    }
    // 2.删除中间段落的节点
    Node* cur = head;
    int count = 0;

    while(count<index-1 && cur)
    {
        cur = cur->next;
        count ++;
    }

    Node* deNode = cur->next; // 存储这个位置方便等等用free
    cur->next = deNode->next;
    free(deNode);

}

// 当然还是可以用头指针来标识这个链表的第一个数据
struct Node()
{
    int left;
    int right;
    int data;
}

// 头插法更新双链表
struct Node{
    Node* left; // 指针变量
    Node* right;
    int value;
   Node(int val):value(val),left(nullptr),right(nullptr);
}
// 1. 用头指针维护 一开始为空
  Node* head = nullptr ;
void insert(int value)
{
    // 2.创建链表节点
  Node newNode = new Node(value);

    newNode->right = head;
    // 3.如果链表不为空，更新头节点的左指针指向新节点
    if(head!=nullptr)
    {
        head->left = newNode;
    }
    // head永远指向头结点
    head = newNode;

}

// 指定位置插入数据
struct Node{
    Node* prev;
    Node* next;
    int value;
    Node(int val): value(val),left(nullptr),right(nullptr);
}

// 定义的头结点，用于找到这个首位置，那我们默认知道
Node* head =

// 双链表插入操作,链表结构在上面
void insert(int index,int value)
{
    // 1.准备
    Node* cur = head;
    int count = 0; //计数
    // 前一个位置，这个遍历过程应该是用不到这个prev
    while(cur && count<index-1)
    {
        cur = cur->next;
        count++;
    }

    Node newNode = new Node(value);
    //2. 要更新四条链子
    newNode->prev = cur;
    newNode->next = cur->next;
    // 这里newNode还没有安上来
    cur->next->prev = newNode;
    cur->next = newNode;

}

// 1.准备
int count = 0; //用于遍历
Node* cur = head;
// 节点就用上面的
void delete(int index)
{
    // 2. 找到删除点的前一个位置
    while(cur&&count<index -1)
    {
        cur = cur->next;
        count++;
    }
    // 3.承接删除的节点
    Node* temp = cur->next;
    //4. 断链，用两条覆盖
    cur->next = cur->next->next;
    cur->next->prev = cur

    free(temp);
}

#define MAXSIZE 1000

typedef struct {
  ElemType data;  // 数据
  int cur;        // 游标
} Component, StaticLinkList[MAXSIZE];

Status InitList(StaticLinkList space) {
  int i;
  for(i = 0; i < MAXSIZE - 1; i++)
    space[i].cur = i + 1; // 游标指向的是下一个的位置
  space [MAXSIZE - 1].cur = 0; // 头结点
  return OK;
}

int Malloc_SLL(StaticLinkList space) {
  int i = space[0].cur;
  if(space[0].cur) {
    space[0].cur = space[i].cur;  // 把它的下一个分量用来作为备用
    return i;
  }
}

/* 在静态链表 L 中第 i 个元素之前插入新第数据元素 */
Status ListInsert(StaticLinkList L, int i, ElemType e) {

  int j, k, l;
  k = MAXSIZE - 1;  // 数组第最后一个元素

  if (i < 1 || i > ListLength(L) + 1) {
    return ERROR;
  }

  j = Malloc_SLL(L);

  if (j) {
    L[j].data = e;
    for(l = 1; l <= i - 1; l++) {
      k = L[k].cur;
    }
    L[j].cur = L[k].cur;
    L[k],cur = j
    return OK;
  }
  return ERROR;
}

/* 删除在 L 中的第 i 个数据元素 */
Status ListDelete(StaticLinkList L, int i) {
  int j, k;

  if(i < 1 || i > ListLength(L)) {
    return ERROR;
  }

  k = MAXSIZE - 1;

  for(j = 1; j <= i - 1; j++) {
    k = L[k].cur;
  }

  j = L[k].cur;
  L[k].cur = L[j].cur;

  Free_SLL(L, j) ;
  return OK;
}

/* 将下标为 k 的空闲结点回收到备用链表 */
void Free_SLL(StaticLinklist space, int k) {
  space[k].cur = space[0].cur;
  space[0].cur = k;
}

/* 返回 L 中数据元素个数 */
int ListLength(StaticLinkList L) {
  int j = 0;
  int i = L[MAXSIZE - 1].cur;

  while (i) {
    i = L[i].cur;
    j++;
  }

  return j;
}

struct list{
    int data; //当前位置的值
    struct list* next; //下一个位置的地址
}list;

// 节点定义
struct Node{
    int data; // 数据域
    Node* next;
}

// 初始化一个循环链表
struct Node* init()
{
    struct Node* head = malloc(sizeof(struct Node));
    head->data = 0;
    head->next = head;
    return head;
}

//定义节点结构
struct Node{
    int data;
    struct Node* next;
}

//初始化构造循环链表
struct Node* init()
{
  return null;   // 尾指针为空
}

void insertAtTail(struct Node** tail,int value)
{
    // 1.创建新节点
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = value;

    //2.判别链表为空
    if(*tail == null){
        // 尾结点指向头结点
    newNode->next = newNode;
        // 尾指针只指向尾部
        *tail = newNode;
    }else{
        //3.如果不为空,指向头结点
    newNode->next = (*tail)->next;
        // 尾指针更新为新的尾部
        (*tail)->next = newNode;
        // 更新尾指针
        *tail = newNode;
    }

}

// 打印循环单链表
void display(struct Node* tail)
{
    if(tail == null){
        return 0;
    }
    // 1. 遍历链表，这里是用尾指针构造头指针，标志第一个位置
    struct Node* temp = tail->next;
    do{
        printf("%d",temp->data);
        temp = temp->next;
    }while(temp!=tail->next); //循环直到回到头结点,表示遍历结束

    printf("\n");
}

// 定义节点
struct Node{
    struct *Node next;
    struct *Node prev;
    int value;
    Node(int val): value(val),next(nullptr),prev(nullptr){}
};
// 初始化
struct Cycle{
    Node* head; // 头指针
    Node* tail; // 尾指针

    // 构造函数，初始化为空表
    Cycle():head(nullptr),tail(nullptr){}
};

// 尾插法
void append(int value)
{
    // 1. 先建立节点
    Node* newNode = new Node(value);
    // 2.head不为空
    if(!head){
        // 初始化
        head = newNode;
        tail = newNode;
        // 3. 构造循环
        head->next = head;
        head->prev = head;
    }else{
        // 4.链表不为空时,由于是双链表所以说要更新四条链
        newNode->prev = tail;
        newNode->next = head;
    // 这里的tail还是原来的链表的尾部，之后需要更新
        tail->next = newNode;
        head->prev = newNode;
        // 更新tail
        tail = newNode;
    }

}

// 链表为空插入
void insertEmptyList(int value){
  Node* newNode = new Node(value);
    head = newNode;
    tail = newNode;
    head->next = head; // 自环
    head->prev = head;
}

// 双链表中部插入
void insertAtPosition(int value,int index)
{
  //1.汇集条件
    Node* newNode = new Node(value);
    int count = 0; // 遍历计数
    Node* cur = head;

    //2.遍历 到前一个位置
    while(cur && count < index-1){
    cur = cur->next;
        index++;
    }

    //3.更换节点,加入节点是4条链
    // 先更新newNode
    newNode->next = cur->next;
    newNode->prev = cur;
    // 更新newNode的前和后
    cur->next->prev = newNode;
    cur->next = newNode;

    if(current == tail){
    tail = newNode; // 更新尾结点
    }
}

// 删除头结点
void deleteHead()
{
    // 1.判空
    if(!head){
    return; // 链表为空
    }

    // 2. 只有一个节点时
    if(head == tail){
        delete head; // 释放节点内存
        head = nullptr;
        tail = nullptr;
        return;
    }
    // 3. 承接删除的节点，只需要把头指针移后即可
    Node* temp = head;
    head = head->next;
    head->prev = tail;
    tail->next = head;

    delete temp; // 释放保持的旧节点
}

// 删除尾结点
void delete Tail()
{
    if(!head) return 0 ;

    // 1. 只有一个节点
    if(head == tail){
     delete head; // 释放节点
        head = nullptr;
        tail = nullptr;
        return;
    }
    // 2. 尾结点前移
    Node* temp = tail;
    tail = tail->prev;
    tail->next = head;
    head->prev = tail; // 头结点的前是尾结点

    // 3 .拿出的尾结点
    delete temp; // 释放尾结点内存
}

void deleteAtPosition(int index)
{
    if(!head) return;

    //1.只有一个节点的时候
    if(head == tail){
    delete head;
        head = nullptr;
        prev = nullptr;
        return;
    }
    // 2.遍历指针
    Node* cur = head;
    // 这里用for循环吧,遍历到目的地位置，这里是循环双链表特点，最后一个位置是头前面
    // 双链表就可以遍历到删除的指定位置
    for(int i = 1;i < index && cur->next != head; i++)
    {
        // 遍历
        cur = cur->next;
    }
    // 3.遍历到当前为止,删除只更新两条
    cur->prev->next = cur->next;
    cur->next->prev = cur->prev;

    free(cur); // 释放节点内存
}

typedef int ElemType;
typedef struct{
    ElemType *base; /* 数组元素基址，由InitArray分配 */
    int dim;        /* 数组维数 */
    int *bounds;    /* 数组维界基址，由InitArray分配 */
    int *constants; /* 数组映象函数常量基址，由InitArray分配 */
} Array;

#include <stdio.h>
#define N 5

int main(void) {
    int arry[N][N];  // 定义 N x N 的二维数组
    int arr[N * (N + 1) / 2 + 1] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0};

    int k;  // 用于计算索引
    int totalElements = N * (N + 1) / 2;  // 总的上三角元素个数

    // 填充二维数组
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            if (i <= j) {
                // 计算上三角元素的索引
                k = i * (2 * N - i + 1) / 2 + j - i;
                arry[i][j] = arr[k];  // 存储上三角元素
            } else {
                // 下三角元素存储常数 c
                arry[i][j] = arr[totalElements];  // 存储下三角元素
            }
        }
    }

    // 打印二维数组
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            printf("%-5d", arry[i][j]);  // 格式化输出
        }
        printf("\n");
    }

    return 0;
}

输出结果
        1    2    3    4    5
        0    6    7    8    9
        0    0    10   11   12
        0    0    0    13   14
        0    0    0    0    15

# include <stdio.h>
# define N 5

void Trans_To_Original(int arry[N][N], int * arr);
void Trans_To_Compress(int arry[N][N], int * arr);
void Show(int arry[N][N], int * arr1, int * arr2);

int main(void)
{
    // 创建一个一维数组储存已知的以行为主序压缩后所得元素
    int B[(N+1)*N/2 + 1] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0};
    int A[N][N] = {0};
    Trans_To_Original(A, B);

    // 创建一个一维数组储存以列为主序压缩所得的数据
    int C[(N+1)*N/2 + 1];
    Trans_To_Compress(A, C);

    // 将三个数组打印输出
    Show(A, B, C);

    return 0;
}

void Trans_To_Original(int arry[N][N], int * arr)
{
    int i, j, k;
    for (i = 0; i < N; ++i)
    {
        for (j = 0; j < N; ++j)
        {
            if (i <= j)
            {
                k = i*(2*N-i+1)/2 + j -i;
                arry[i][j] = arr[k];
            }
            else
            {
                k = N*(N+1)/2;
                arry[i][j] = arr[k];
            }
        }
    }

    return;
}

void Trans_To_Compress(int arry[N][N], int * arr)
{
    int i, j, k = 0;
    // 按列为主序压缩
    for (i = 0; i < N; ++i)
    {
        for (j = 0; j <= i; ++j)
        {
            arr[k++] = arry[j][i];
        }
    }
    arr[(N+1)*N/2] = 0;

    return;
}

void Show(int arry[N][N], int * arr1, int * arr2)
{
    int i, j, k;
    printf("原二维数组为：\n");
    for (i = 0; i < N; ++i)
    {
        printf("              ");
        for (j = 0; j < N; ++j)
        {
            printf("%-5d", arry[i][j]);
        }
        printf("\n");
    }
    printf("以行为主序压缩所得结果为：\n");
    for (k = 0; k < (N+1)*N/2; ++k)
    {
        printf("%-3d", arr1[k]);
    }
    printf("\n以列为主序压缩所得结果为：\n");
    for (k = 0; k < (N+1)*N/2; ++k)
    {
        printf("%-3d", arr2[k]);
    }
    printf("\n");

    return;
}

#define MAXSIZE 1000  //非零元素个数最多为1000

//三元组的定义，用于存储一个非零元素
typedef struct{
  int row,col;  //存储该非零元素的行和列
  ElementType e;  //存储该非零元素的值
} Triple;

//三元组表的定义
typedef struct{
  Triple data[MAXSIZE + 1];  //非零元素的三元组表。data[0]未用
  int m, n, len;  //原来矩阵的行数、列数、非零元素的个数
}TSMatrix;

/*十字链表的存储结构*/
typedef struct OLNode {
  int row, col;            //非零元素的行和列下标
  int vaule;
  struct OLNode* right, * down;    //非零元素所在行表、列表的后继链域
}OLNode, *OLink;

typedef struct {
  OLink* row_head, * col_head;    //行、列链表的头指针向量
  int m, n, len;            //稀疏矩阵的行数、列数、非零元素个数
}CrossList;

A=() //空表
B=(e) //只含有一个原子的广义表
C=(a,(b,c,d)) //含有一个原子和一个子表的广义表
D=(A,B,C)=((),(e),(a,(b,c,d))) //含有三个子表的广义表，且第一个表为空表
E=(a,E) //广义表 E 中有两个元素，原子 a 和它本身。这是一个递归广义表，等同于：E = (a,(a,(a,…)))。

LS=(1,(1,2,3),5), 其中表头Head(LS)为原子1，表尾为Tail(LS)=((1,2,3),5)
LS=(1), 其中表头Head(LS)为原子1，表尾为空表

// ATOM == 0: 表示原子, LIST == 1: 表示子表
typedef enum { ATOM, LIST } ElemTag;

// 广义表结点结构定义
typedef struct GLNode {
    ElemTag tag;  // 公共部分，区分原子结点和子表结点

    union { //union允许在同一内存位置存储不同数据类型
        AtomType atom;  // 原子结点的值，AtomType 是用户定义的类型
        struct {
            struct GLNode *head;  // 指向表头的指针
            struct GLNode *tail;  // 指向表尾的指针
        } ptr;  // 子表结点的指针域
    } content;  // 联合体用于保存原子或子表

} *GList;  // 广义表类型定义为指向 GLNode 结构体的指针

// ATOM == 0: 表示原子, LIST == 1: 表示子表
typedef enum { ATOM, LIST } ElemTag;

// 广义表结点结构定义
typedef struct GLNode {
    ElemTag tag;  // 公共部分，用以区分原子结点和子表结点

    union {
        AtomType atom;       // 原子结点的值域
        struct GLNode *hp;   // 表结点的表头指针
    } content;  // 联合体用于区分保存原子或表头

    struct GLNode *tp;  // 表尾指针，相当于线性链表的 next 指针
} *GList;  // 广义表类型 GList 是扩展的线性链表

int GLLength(GList g) {
    int length = 0;         // 记录广义表的长度
    g = g->content.hp;      // g 指向广义表的第一个元素

    while (g != NULL) {     // 遍历链表，直到到达末尾
        length++;           // 增加计数
        g = g->tp;         // 移动到下一个元素
    }

    return length;         // 返回广义表的长度
}

int GLDepth(GList g) {
    if (g->tag == ATOM) {
        return 0;  // 如果是原子，深度为 0
    }

    int maxDepth = 0;  // 保存当前子表的最大深度
    int currentDepth;

    g = g->content.hp;  // g 指向第一个元素
    if (g == NULL) {
        return 1;  // 空表的深度为 1
    }

    while (g != NULL) {  // 遍历广义表的所有元素
        if (g->tag == LIST) {  // 如果是子表
            currentDepth = GLDepth(g);  // 递归计算子表的深度
            if (currentDepth > maxDepth) {
                maxDepth = currentDepth;  // 更新最大深度
            }
        }
        g = g->tp;  // 移动到下一个元素
    }

    return maxDepth + 1;  // 返回深度，+1 表示当前层
}

// 用结构体模拟队列
struct Queue{
    int data; // 数据域
    int front; // 指向队首
    int rear; // 指向队尾
    int size; // 标识队列长度
}

// 初始化队列
void initQueue(Queue &q){
    q.front = 0;
    q.fear = -1;
    q.size = 0;
}

// 1. 判断队列是否为空
bool isEmpty(Queue &q){ return q.size == 0}

// 2.入队
bool enqueue(Queue &q, int value)
{
    if(isFull(q)) return false; // 队列满
    q.rear = (q.rear+1) % MAX_SIZE; // 循环数组存储
    q.data[q.rear] = value;
    q.size++;
    return true;
}

// 3.出队
bool dequeue(Queue &q,int &value)
{
    if(isEmpty(p)){ return false }
    // 队首 - 队列的队首永远指向将要出队的位置
    value = q.data[q.front];
    q.front = (q.front+1) % MAX_SIZE; // 循环队列
    q.size--;
    return true;
}


// 4.获取队首
bool peek(Queue &q,int &value)
{
  if(isEmpty(q)) return false;
  // 直接取出队首就行
    value = q.data[q.front];
    return true;
}

// 1. 队长
#define MAXSIZE 5

// 2.队内元素的结构体
typedef struct{
    int data[MAXSIZE];
    int front; // 队尾
    int front; // 对头
}QueueArray;

// 1. 节点
typedef struct QueueNode{
  int data; // 数据域
    struct QueueNode *next; // 指针域
}QueueNode;

// 2.链结构的结构体
typedef struct{
    QueueNode *front; // 队头指针
    QueueNode *rear; // 队尾指针
}QueueLink;

#define MAXSIZE 20 // 数组的最大存储空间

typedef struct {
    int array[MAXSIZE]; // 存储数组
    int length; // 当前堆长度（结点数）
} BinaryHeap;

/**
 * @description: 初始化二叉堆
 * @param {BinaryHeap} *heap 二叉堆
 * @param {int} *array 数组首地址，该数组是一个无序完全二叉树
 * @param {int} arr_length 数组长度
 * @return {*} 无
 */
void init_heap(BinaryHeap *heap, int *array, int arr_length)
{
    // array 拷贝到 heap 中
    memcpy(heap->array, array, arr_length * sizeof(int));
    // 设置堆长度
    heap->length = arr_length;
}

void adjust_for_min_heap(BinaryHeap *heap, int parent_index)
{
    // value 保存非叶子结点的值
    int value = heap->array[parent_index];
    // child_index 标识左孩子
    int child_index = parent_index * 2 + 1;
    // 最后一个结点的下标
    int last_child_index = heap->length - 1;

    // 双亲结点 parent 至少有一个孩子
    while (child_index <= last_child_index) {
        // 如果双亲结点 parent 有左孩子和右孩子
        if (child_index < last_child_index) {
            // 比较左孩子和右孩子谁小，如果右孩子小，
            if (heap->array[child_index] > heap->array[child_index + 1]) {
                // 则 child_index 标识右孩子
                child_index = child_index + 1;
            }
        }
        // 如果双亲的值大于 child 的值
        if (value > heap->array[child_index]) {
            heap->array[parent_index] = heap->array[child_index]; // 小节点上浮
            parent_index = child_index; // 更新双亲下标
            child_index = parent_index * 2 + 1; // 更新孩子下标
        } else { // 不做操作，跳出循环
            break;
        }
        // 大节点下沉
        heap->array[parent_index] = value;
    }
}

/**
 * @description: 构造最小堆
 * @param {BinaryHeap} *heap 二叉堆（无序）
 * @return {*} 无
 */
void create_min_heap(BinaryHeap *heap)
{
    // 每个非叶子结点都调整
    for (int i = (heap->length - 2) / 2; i >= 0; i--) {
        adjust_for_min_heap(heap, i);
    }
}