AI 助理
备案控制台
开发者社区 云计算 文章 正文

数据结构 2 第二章 线性结构 代码实现

2023-11-24 121
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 数据结构 2 第二章 线性结构 代码实现

头文件

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>//malloc函数头文件
#include <time.h>
#include <string.h>
#include <limits.h>
#include <ctype.h>
#include <math.h>
# include <stdio.h>

一、单链表


1.单链表

线性表：1.有限的序列 2.序列中的每一个元素都有唯一的前驱和后继，除了开头和结尾的两个节点。


链表：内存是不连续的，元素会各自被分配一块内存，内存和内存之间用指针进行相连。


顺序表和链表的区别是内存的连续与否


data域 | next指针域 ——> data域 | next指针域 ——> data域 | next指针域 ——> NULL


2.单链表的操作

1.增加 ：1>头插法 2>尾插法

1>插入——> data域 | next指针域 ——> data域 | next指针域 ——> data域 | next指针域 ——> NULL

2>data域 | next指针域 ——> data域 | next指针域 ——> data域 | next指针域 ——> 插入——>NULL

2.删除：用前一个节点的指针直接指向对应节点的后一个节点的前驱，只操作一个指针。

为了使操作方便，在操作中添加一个头节点。头节点并不实际存储，只保存链表中的元素个数。


代码实现


1.定义一个结构体

typedef struct Node {//定义一个结构体
  int data;
  struct Node* next;
}Node;

2.初始化一个链表 

Node* initList() {//初始化一个链表
  Node* list = (Node*)malloc(sizeof(Node));
  list->data = 0;
  list->next = NULL;
  return list;
}

3.头插法

void headInsert(Node* list,int data){//头插法
  Node* node = (Node*)malloc(sizeof(Node));
  node->data = data;
  node->next = list->next;
  list->next = node;
  list->data++;//代表当前链表之中插入元素
}

4.尾插法

void tailInsert(Node* list, int data){//尾插法
  Node* head = list;
  Node* node = (Node*)malloc(sizeof(Node));
  node->data = data;
  node->next = NULL;
  list = list->next;
  while (list->next) {
    list = list->next;
  }
  list->next = node;
  head->data++;
}

5.删除操作

void Delete(Node* list, int data){//删除
  Node* head = list;
  Node* pre = list;
  Node* current = list->next;
  list = list->next;
  while (current)
  {
    if (current->data == data)
    {
      pre->next = current->next;
      free(current);
      break;
    }
    pre = current;
    current = current->next;
  }
  list->data--;
}

6.遍历打印操作

void printList(Node* list) {//遍历操作
  list = list->next;
  while (list)
  {
    printf("%d ", list->data);
    list = list->next;
  }
  printf("\n");
}

7.代码实现

typedef struct Node {//定义一个结构体
  int data;
  struct Node* next;
}Node;
Node* initList() {//初始化一个链表
  Node* list = (Node*)malloc(sizeof(Node));
  list->data = 0;
  list->next = NULL;
  return list;
}
void headInsert(Node* list,int data){//头插法
  Node* node = (Node*)malloc(sizeof(Node));
  node->data = data;
  node->next = list->next;
  list->next = node;
  list->data++;//代表当前链表之中插入元素
}
void tailInsert(Node* list, int data){//尾插法
  Node* head = list;
  Node* node = (Node*)malloc(sizeof(Node));
  node->data = data;
  node->next = NULL;
  list = list->next;
  while (list->next) {
    list = list->next;
  }
  list->next = node;
  head->data++;
}
void Delete(Node* list, int data){//删除
  Node* head = list;
  Node* pre = list;
  Node* current = list->next;
  list = list->next;
  while (current)
  {
    if (current->data == data)
    {
      pre->next = current->next;
      free(current);
      break;
    }
    pre = current;
    current = current->next;
  }
  list->data--;
}
void printList(Node* list) {//遍历操作
  list = list->next;
  while (list)
  {
    printf("%d ", list->data);
    list = list->next;
  }
  printf("\n");
}
int main()
{
  Node* list = initList();
  headInsert(list, 1);
  headInsert(list, 2);
  headInsert(list, 3);
  headInsert(list, 4);
  headInsert(list, 5);
  tailInsert(list, 6);
  tailInsert(list, 7);
  tailInsert(list, 8);
  tailInsert(list, 9);
  tailInsert(list, 10);
  printList(list);
  Delete(list, 5);
  printList(list);
  Delete(list, 10);
  printList(list);
  Delete(list, 6);
  printList(list);
  return 0;
}


8.结果



二、单循环链表

1..单循环链表

data|next——>data|next——>data|next——>头节点

1.初始化链表

2.增加节点（头插法、尾插法）

3.删除节点

4.遍历链表

代码实现

1.定义一个结构体

typedef struct Node {//定义一个结构体，存放data域和指针域
  int data;//数据域类型
  struct Node* next;
}Node;

2. 初始化链表

Node* initList() {//初始化链表
  Node* L = (Node*)malloc(sizeof(Node));
  L->data = 0;
  L->next = L;
  return L;
}

3.头插法

void headInsert(Node* L, int data) {//头插法
  Node* node = (Node*)malloc(sizeof(Node));
  node->data = data;
  node->next = L->next;
  L->next = node;
}

4尾插法

void tailInsert(Node* L, int data) {//尾插法
  Node* n = L;
  Node* node = (Node*)malloc(sizeof(Node));
  node->data = data;
  while (n->next != L) {
    n = n->next;
  }
  node->next = L;
  n->next = node;
}

5.删除操作

int Delete(Node* L, int data)//删除
{
  Node* preNode = L;
  Node* node = L->next;
  while (node != L)
  {
    if (node->data == data) {
      preNode->next = node->next;
      free(node);
      return TRUE;
    }
    preNode = node;
    node = node->next;
  }
  return FALSE;
}

6.遍历链表打印

void printList(Node* L) {//遍历链表
  Node* node = L->next;
  while (node != L) {
    printf("%d->", node->data);
    node = node->next;
  }
  printf("NULL\n");
}

7.代码实现

#define TRUE 1
#define FALSE 0
typedef struct Node {//定义一个结构体，存放data域和指针域
  int data;//数据域类型
  struct Node* next;
}Node;
Node* initList() {//初始化链表
  Node* L = (Node*)malloc(sizeof(Node));
  L->data = 0;
  L->next = L;
  return L;
}
void headInsert(Node* L, int data) {//头插法
  Node* node = (Node*)malloc(sizeof(Node));
  node->data = data;
  node->next = L->next;
  L->next = node;
}
void tailInsert(Node* L, int data) {//尾插法
  Node* n = L;
  Node* node = (Node*)malloc(sizeof(Node));
  node->data = data;
  while (n->next != L) {
    n = n->next;
  }
  node->next = L;
  n->next = node;
}
int Delete(Node* L, int data)//删除
{
  Node* preNode = L;
  Node* node = L->next;
  while (node != L)
  {
    if (node->data == data) {
      preNode->next = node->next;
      free(node);
      return TRUE;
    }
    preNode = node;
    node = node->next;
  }
  return FALSE;
}
void printList(Node* L) {//遍历链表
  Node* node = L->next;
  while (node != L) {
    printf("%d->", node->data);
    node = node->next;
  }
  printf("NULL\n");
}
int main()
{
  Node* L = initList();
  headInsert(L, 1);
  headInsert(L, 2);
  headInsert(L, 3);
  headInsert(L, 4);
  headInsert(L, 5);
  tailInsert(L, 6);
  tailInsert(L, 7);
  tailInsert(L, 8);
  tailInsert(L, 9);
  tailInsert(L, 10);
  printList(L);
  Delete(L, 4);
  Delete(L, 5);
  printList(L);
  return 0;
}

8.结果

三、双链表

1.双链表

pre指针|data域|next指针<——>pre|data|next<——>pre|data|next

与单链表相比多一个指针域

2.双链表的操作：

1.初始化链表

2.插入节点（头插法、尾插法）

3.删除结点

4.遍历链表

代码实现

1.数据结构的定义

typedef struct Node {//数据结构的定义
  int data;//data域
  struct Node* pre;//pre指针
  struct Node* next;//next指针
}Node;

2. 初始化链表

Node* initList() {//初始化链表
  Node* L = (Node*)malloc(sizeof(Node));//新建指针变量并开辟空间 返回一个Node*类型指针
  L->data = 0;//头节点data域初始化为0
  L->pre = NULL;//头指针为NULL
  L->next = NULL;//next指针为NULL
  return

3. 头插法

void headInsert(Node* L, int data) {//头插法
  Node* node = (Node*)malloc(sizeof(Node));//新建一个结点并为他开辟空间
  node->data = data;
  if (L->data == 0)
  {
    node->next = L->next;
    node->pre = L;
    L->next = node;
  }
  else {
    node->pre = L;//node指向的pre指向头节点
    node->next = L->next;
    L->next->pre = node;
    L->next = node;
    L->data++;
  }
}

4.尾插法

void tailInsert(Node* L,int data) //尾插法
{
  Node* node = L;
  Node* n = (Node*)malloc(sizeof(Node));
  n->data = data;
  while (node->next) {
    node = node->next;
  }
  n->next = node->next;
  node->next = n;
  n->pre = node;
  L->data++;
}

5.删除操作

int Delete(Node* L, int data) //删除
{
  Node* node = L->next;
  while (node) 
  {
    if (node->data == data)
    {
      node->pre->next = node->next;
      node->next->pre = node->pre;
      free(node);
      return TRUE;
    }
    node = node->next;
  }
  return FALSE;
}

6.遍历链表打印

void printList(Node* L)//遍历
{
  Node* node = L->next;
  while (node) {
    printf("%d -> ", node->data);
    node = node->next;
  }
  printf("NULL\n");
}

7.代码实现

#define TRUE 1
#define FALSE 0
typedef struct Node {//数据结构的定义
  int data;//data域
  struct Node* pre;//pre指针
  struct Node* next;//next指针
}Node;
Node* initList() {//初始化链表
  Node* L = (Node*)malloc(sizeof(Node));//新建指针变量并开辟空间 返回一个Node*类型指针
  L->data = 0;//头节点data域初始化为0
  L->pre = NULL;//头指针为NULL
  L->next = NULL;//next指针为NULL
  return L;//返回L
}
void headInsert(Node* L, int data) {//头插法
  Node* node = (Node*)malloc(sizeof(Node));//新建一个结点并为他开辟空间
  node->data = data;
  if (L->data == 0)
  {
    node->next = L->next;
    node->pre = L;
    L->next = node;
  }
  else {
    node->pre = L;//node指向的pre指向头节点
    node->next = L->next;
    L->next->pre = node;
    L->next = node;
    L->data++;
  }
}
void tailInsert(Node* L,int data) //尾插法
{
  Node* node = L;
  Node* n = (Node*)malloc(sizeof(Node));
  n->data = data;
  while (node->next) {
    node = node->next;
  }
  n->next = node->next;
  node->next = n;
  n->pre = node;
  L->data++;
}
int Delete(Node* L, int data) //删除
{
  Node* node = L->next;
  while (node) 
  {
    if (node->data == data)
    {
      node->pre->next = node->next;
      node->next->pre = node->pre;
      free(node);
      return TRUE;
    }
    node = node->next;
  }
  return FALSE;
}
void printList(Node* L)//遍历
{
  Node* node = L->next;
  while (node) {
    printf("%d -> ", node->data);
    node = node->next;
  }
  printf("NULL\n");
}
int main()
{
  Node* L = initList();
  headInsert(L, 1);
  headInsert(L, 2);
  headInsert(L, 3);
  headInsert(L, 4);
  printList(L);
  //4 -> 3 -> 2 -> 1 -> NULL
  tailInsert(L, 5);
  tailInsert(L, 6);
  tailInsert(L, 7);
  tailInsert(L, 8);
  printList(L);
  //4 -> 3 -> 2 -> 1 -> 5 -> 6 -> 7 -> 8 -> NULL
  Delete(L, 2);
  Delete(L, 4);
  printList(L);
  //1 -> 5 -> 6 -> 7 -> 8->NULL
}


8.结果


四、双循环链表


1.双循环链表

pre前指针|data域|next后指针<——>pre|data|next<——>pre|data|next

最后一个节点的next指针和头节点的pre指针相互指向对方，其他节点与双链表相同。

功能：

1.初始化链表

2.插入节点（头插法、尾插法）

3.删除结点

4.遍历链表

代码实现

1.定义一个结构体链表数据节点

typedef struct Node//定义一个结构体类型
{
  int data;
  struct Node* pre;
  struct Node* next;
}Node;

2.初始化链表 

Node* initList()//初始化链表
{
  Node* L = (Node*)malloc(sizeof(Node));
  L->data = 0;
  L->next = L;
  L->pre = L;
  return L;
}

3.头插法

void headInsert(Node* L,int data)//头插法
{
  Node* node = (Node*)malloc(sizeof(Node));
  node->data = data;
  if (L->data == 0)
  {//链表为空
    node->pre = L;
    node->next = L->next;
    L->next = node;
    L->pre = node;
    L->data++;
  }
  else {
    //链表不为空
    node->next = L->next;
    node->pre = L;
    L->next->pre = node;
    L->next = node;
    L->data++;
  }
}

4.尾插法 

void tailInsert(Node* L,int data)//尾插法
{
  Node* node = L;
  while (node->next != L)
  {
    node = node->next;
  }
  Node* n = (Node*)malloc(sizeof(Node));
  n->data = data;
  n->pre = node;
  n->next = L;
  L->pre = n;
  node->next = n;
  L->data++;
}

5.删除操作

int Delete(Node* L, int data)//删除
{
  Node* node = L->next;
  while (node != L)
  {
    if (node->data == data)
    {
      node->pre->next = node->next;
      node->next->pre = node->pre;
      free(node);
      L->data--;
      return 1;
    }
    node = node->next;
  }
  return 0;
}

6.遍历链表打印

void printList(Node* L)//遍历
{
  Node* node = L->next;
  while (node != L) {
    printf("%d -> ", node->data);
    node = node->next;
  }
  printf("NULL\n");
}

7.代码实现

typedef struct Node//定义一个结构体类型
{
  int data;
  struct Node* pre;
  struct Node* next;
}Node;
Node* initList()//初始化链表
{
  Node* L = (Node*)malloc(sizeof(Node));
  L->data = 0;
  L->next = L;
  L->pre = L;
  return L;
}
void headInsert(Node* L,int data)//头插法
{
  Node* node = (Node*)malloc(sizeof(Node));
  node->data = data;
  if (L->data == 0)
  {//链表为空
    node->pre = L;
    node->next = L->next;
    L->next = node;
    L->pre = node;
    L->data++;
  }
  else {
    //链表不为空
    node->next = L->next;
    node->pre = L;
    L->next->pre = node;
    L->next = node;
    L->data++;
  }
}
void tailInsert(Node* L,int data)//尾插法
{
  Node* node = L;
  while (node->next != L)
  {
    node = node->next;
  }
  Node* n = (Node*)malloc(sizeof(Node));
  n->data = data;
  n->pre = node;
  n->next = L;
  L->pre = n;
  node->next = n;
  L->data++;
}
int Delete(Node* L, int data)//删除
{
  Node* node = L->next;
  while (node != L)
  {
    if (node->data == data)
    {
      node->pre->next = node->next;
      node->next->pre = node->pre;
      free(node);
      L->data--;
      return 1;
    }
    node = node->next;
  }
  return 0;
}
void printList(Node* L)//遍历
{
  Node* node = L->next;
  while (node != L) {
    printf("%d -> ", node->data);
    node = node->next;
  }
  printf("NULL\n");
}
int main()
{
  Node* L = initList();
  headInsert(L, 1);
  headInsert(L, 2);
  headInsert(L, 3);
  headInsert(L, 4);
  printList(L);
  //4 -> 3 -> 2 -> 1 -> NULL
  tailInsert(L, 5);
  tailInsert(L, 6);
  tailInsert(L, 7);
  tailInsert(L, 8);
  printList(L);
  //4 -> 3 -> 2 -> 1 -> 5 -> 6 -> 7 -> 8 -> NULL
  Delete(L, 2);
  Delete(L, 4);
  printList(L);
  //3 -> 1 -> 5 -> 6 -> 7 -> 8 -> NULL
}

8.运行结果

五、栈

1.栈

存放：1->2->3 取出:3->2->1   先进后出

应用场景：1.表达式的值 2.解决一些递归问题 3.计算进制转换

栈是一种特殊的线性表，它只能在一端进行存取操作，所以存取的元素有先进后出的特点。

栈的总体特点：先进后出

2.实现的功能：

初始化栈

出栈

入栈

判断栈空

代码实现

1.结构体定义数据结点

typedef struct Node //结构体创建节点
{
  int data;//data域
  struct Node* next;//next指针
}Node;

2.初始化栈

Node* initStack()//初始化栈
{
  Node* S = (Node*)malloc(sizeof(Node));//新建一个节点
  S->data = 0;
  S->next = NULL;
  return S;//返回S
}

3.出栈 

int isEmpty(Node* S)//出栈功能前的判断栈空功能
{
  if (S->data == 0 || S->next == NULL)//栈空
  {
    return 1;
  }
  else {
    return 0;
  }
}
int getTop(Node* S)//出栈 传入头指针
{
  if (isEmpty(S))
  {
    return -1;
  }
  else
  {
    return S->next->data;//不为空的话 S指向第一个节点的data域
  }
}

4.

六、队

1.队

一种先进先出的特殊线性表，只允许在一端进行存取，在头出，在尾进

2.实现的功能：

1.初始化队

2.出队

3.入队 （尾插法）

代码实现

1.结构体定义数据节点

typedef struct Node //定义数据节点结构体
{
  int data;//数据域data
  struct Node* next;//next指针
}Node;

2.初始化队列

Node* initQueue() //初始化队列
{
  Node* Q = (Node*)malloc(sizeof(Node));//新建指针变量
  Q->data = 0;
  Q->next = NULL;
  return Q;
}

3. 入队操作 尾插法

void enQueue(Node* Q, int data)//入队操作 尾插法
{
  Node* q = Q;//传入头指针
  Node* node = (Node*)malloc(sizeof(Node));
  node->data = data;
  for (int i = 0; i < Q->data; i++)//循环遍历队列找到最后一个节点
  {
    q = q->next;
  }
  node->next = q->next;
  q->next = node;
  Q->data++;//!!!!
}

4.出队操作，删除队列中第一个结点

int isEmpty(Node* Q)//判空
{
  if (Q->data == 0 || Q->next == NULL)
  {
    return 1;
  }
  else
  {
    return 0;
  }
}
int deQueue(Node* Q) //出队操作 删除队列中的第一个节点
{
  if (isEmpty(Q))//判空操作
  {
    return -1;
  }
  else
  {
    Node* node = Q->next;
    int data = node->data;
    Q->next = node->next;
    free(node);
    return data;
  }
}

5.遍历队列打印

void printQueue(Node* Q)//遍历队列打印
{
  Node* node = Q->next;//传入第一个节点
  while (node)
  {
    printf("%d -> ", node->data);
    node = node->next;
  }
  printf("NULL\n");
}

6.代码实现

typedef struct Node //定义数据节点结构体
{
  int data;//数据域data
  struct Node* next;//next指针
}Node;
Node* initQueue() //初始化队列
{
  Node* Q = (Node*)malloc(sizeof(Node));//新建指针变量
  Q->data = 0;
  Q->next = NULL;
  return Q;
}
void enQueue(Node* Q, int data)//入队操作 尾插法
{
  Node* q = Q;//传入头指针
  Node* node = (Node*)malloc(sizeof(Node));
  node->data = data;
  for (int i = 0; i < Q->data; i++)//循环遍历队列找到最后一个节点
  {
    q = q->next;
  }
  node->next = q->next;
  q->next = node;
  Q->data++;//!!!!
}
int isEmpty(Node* Q)//判空
{
  if (Q->data == 0 || Q->next == NULL)
  {
    return 1;
  }
  else
  {
    return 0;
  }
}
int deQueue(Node* Q) //出队操作 删除队列中的第一个节点
{
  if (isEmpty(Q))//判空操作
  {
    return -1;
  }
  else
  {
    Node* node = Q->next;
    int data = node->data;
    Q->next = node->next;
    free(node);
    return data;
  }
}
void printQueue(Node* Q)//遍历队列打印
{
  Node* node = Q->next;//传入第一个节点
  while (node)
  {
    printf("%d -> ", node->data);
    node = node->next;
  }
  printf("NULL\n");
}
int main()
{
  Node* Q = initQueue();
  enQueue(Q, 1);
  enQueue(Q, 2);
  enQueue(Q, 3);
  enQueue(Q, 4);
  printQueue(Q);//1 -> 2 -> 3 -> 4 -> NULL
  int data = deQueue(Q);
  printf("data=%d\n", data);//data=1
  printQueue(Q);//2 -> 3 -> 4 -> NULL
  data = deQueue(Q);
  printQueue(Q);//3 -> 4 -> NULL
  data = deQueue(Q);
  printQueue(Q);//4 -> NULL
  data = deQueue(Q);
  printf("data=%d\n", data);//data=4
  printQueue(Q);//NULL
  return 0;
}

7.运行结果



七、循环队列

队列组成一周 需要两个指针指向队列的队首与队尾 当插入一个元素后，队尾指针后移一项，

如何判断队列是空/满：

1.在实际操作中，牺牲掉队列一个空间来判断队列是满/空

2.判断逻辑如下：

  1>队空的话，头指针等于尾指针：front==rear

    2>队满的话：rear+1%MAXSIZE==front;

实现的功能：

 1.初始化队列

 2.入队

 3.出队

 4.遍历循环队列

代码实现

1.定义队列结构体

#define MAXSIZE 5
typedef struct Queue//定义队列结构体
{
  int front;//front指针
  int rear;//rear指针
  int data[MAXSIZE];//data域
}Queue;

2.初始化队列 

Queue* initQueue()//初始化队列
{
  Queue* Q = (Queue*)malloc(sizeof(Queue));
  Q->front = Q->rear = 0;
  return Q;
}

3.判满/空操作

int isFull(Queue* Q)//判满操作
{
  if ((Q->rear + 1) % MAXSIZE == Q->front)
  {
    return 1;
  }
  else {
    return 0;
  }
}
int isEmpty(Queue* Q)//判空操作
{
  if (Q->front == Q->rear)
  {
    return 1;
  }
  else {
    return 0;
  }
}

4.入队操作

int enQueue(Queue* Q, int data)//插入函数 入队操作
{
  if (isFull(Q))
  {
    return 0;
  }
  else {
    Q->data[Q->rear] = data;
    Q->rear = (Q->rear + 1) % MAXSIZE;
    return 1;
  }
}

5。出队操作

int deQueue(Queue* Q)//出队操作
{
  if (isEmpty(Q))
  {
    return -1;
  }
  else {
    int data = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return data;
  }
}

6，遍历队列打印

void printQueue(Queue* Q)//遍历队列打印
{
  //要知道队列当前有多少个元素
  int length = (Q->rear - Q->front + MAXSIZE) % MAXSIZE;
  int index = Q->front;
  for (int i = 0; i < length; i++)
  {
    printf("%d -> ", Q->data[index]);
    index = (index + 1) % MAXSIZE;
  }
  printf("NULL\n");
}

7.代码实现

#define MAXSIZE 5
typedef struct Queue//定义队列结构体
{
  int front;//front指针
  int rear;//rear指针
  int data[MAXSIZE];//data域
}Queue;
Queue* initQueue()//初始化队列
{
  Queue* Q = (Queue*)malloc(sizeof(Queue));
  Q->front = Q->rear = 0;
  return Q;
}
int isFull(Queue* Q)//判满操作
{
  if ((Q->rear + 1) % MAXSIZE == Q->front)
  {
    return 1;
  }
  else {
    return 0;
  }
}
int isEmpty(Queue* Q)//判空操作
{
  if (Q->front == Q->rear)
  {
    return 1;
  }
  else {
    return 0;
  }
}
int enQueue(Queue* Q, int data)//插入函数 入队操作
{
  if (isFull(Q))
  {
    return 0;
  }
  else {
    Q->data[Q->rear] = data;
    Q->rear = (Q->rear + 1) % MAXSIZE;
    return 1;
  }
}
int deQueue(Queue* Q)//出队操作
{
  if (isEmpty(Q))
  {
    return -1;
  }
  else {
    int data = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return data;
  }
}
void printQueue(Queue* Q)//遍历队列打印
{
  //要知道队列当前有多少个元素
  int length = (Q->rear - Q->front + MAXSIZE) % MAXSIZE;
  int index = Q->front;
  for (int i = 0; i < length; i++)
  {
    printf("%d -> ", Q->data[index]);
    index = (index + 1) % MAXSIZE;
  }
  printf("NULL\n");
}
int main()
{
  Queue* Q = initQueue();
  enQueue(Q, 1);
  enQueue(Q, 2);
  enQueue(Q, 3);
  enQueue(Q, 4);
  printQueue(Q);//1 -> 2 -> 3 -> 4 -> NULL
  deQueue(Q);
  printQueue(Q);//2 -> 3 -> 4 -> NULL
  return 0;
}

8.运行结果


文章标签：
存储
关键词：
数据结构代码
数据结构代码实现
数据结构线性结构
数据结构线性结构代码实现
L_cl
目录
相关文章
东方睿赢
|
1月前
|
算法 开发者 计算机视觉
燃爆全场！Python并查集：数据结构界的网红，让你的代码炫酷无比！
在编程的世界里，总有一些数据结构以其独特的魅力和高效的性能脱颖而出，成为众多开发者追捧的“网红”。今天，我们要介绍的这位明星，就是Python中的并查集（Union-Find）——它不仅在解决特定问题上大放异彩，更以其优雅的设计和强大的功能，让你的代码炫酷无比，燃爆全场！
东方睿赢
36 0
东方睿赢
|
4月前
|
算法 安全 大数据
揭秘！Python堆与优先队列：数据结构的秘密武器，让你的代码秒变高效战士！
【7月更文挑战第8天】Python的heapq模块和queue.PriorityQueue提供堆与优先队列功能，助你提升算法效率。堆用于快速找大数据集的第K大元素，如示例所示，时间复杂度O(n log k)。PriorityQueue在多线程中智能调度任务，如模拟下载管理器，按优先级处理任务。掌握这些工具，让代码运行更高效！
东方睿赢
71 1
东方睿赢
|
24天前
|
存储 Java 开发者
Java中的Map接口提供了一种优雅的方式来管理数据结构，使代码更加清晰、高效
【10月更文挑战第19天】在软件开发中，随着项目复杂度的增加，数据结构的组织和管理变得至关重要。Java中的Map接口提供了一种优雅的方式来管理数据结构，使代码更加清晰、高效。本文通过在线购物平台的案例，展示了Map在商品管理、用户管理和订单管理中的具体应用，帮助开发者告别混乱，提升代码质量。
东方睿赢
26 1
Dylaniou
|
1月前
|
存储 算法 索引
HashMap底层数据结构及其增put删remove查get方法的代码实现原理
HashMap 是基于数组 + 链表 + 红黑树实现的高效键值对存储结构。默认初始容量为16，负载因子为0.75。当存储元素超过容量 * 负载因子时，会进行扩容。HashMap 使用哈希算法计算键的索引位置，通过链表或红黑树解决哈希冲突，确保高效存取。插入、获取和删除操作的时间复杂度接近 O(1)。
Dylaniou
29 0
Codelinghu
|
1月前
05（数据结构考研）树相关操作代码
05（数据结构考研）树相关操作代码
Codelinghu
27 0
Codelinghu
|
1月前
|
算法
04（数据结构考研）串相关操作代码
04（数据结构考研）串相关操作代码
Codelinghu
18 0
Codelinghu
|
1月前
03（数据结构考研）队列相关操作代码
03（数据结构考研）队列相关操作代码
Codelinghu
39 0
Codelinghu
|
1月前
02（数据结构考研）栈相关操作代码
02（数据结构考研）栈相关操作代码
Codelinghu
12 0
Codelinghu
|
1月前
01（数据结构考研）线性表相关操作代码
01（数据结构考研）线性表相关操作代码
Codelinghu
59 0
dream_ready
|
1月前
|
算法 Java 测试技术
数据结构 —— Java自定义代码实现顺序表，包含测试用例以及ArrayList的使用以及相关算法题
文章详细介绍了如何用Java自定义实现一个顺序表类，包括插入、删除、获取数据元素、求数据个数等功能，并对顺序表进行了测试，最后还提及了Java中自带的顺序表实现类ArrayList。
dream_ready
19 0

热门文章

最新文章

  • 1
    我花了一夜用数据结构给女朋友写个H5走迷宫游戏
  • 2
    数据结构学习笔记【持续更新】
  • 3
    基于OHCI的USB主机 —— OHCI（自定义数据结构）
  • 4
    【数据结构与算法】一篇文章彻底搞懂二分查找（思路图解+代码优化）两种实现方式，递归与非递归
  • 5
    学数据结构，只需要基本的编程体验
  • 6
    数据结构（2）：栈的原理和实现
  • 7
    【数据结构7】查找
  • 8
    算法导论第十四章 数据结构的扩张
  • 9
    R语言学习笔记（一）数据结构
  • 10
    Smaller And Smarter Python数据结构：自己动手实现栈
  • 1
    `geopandas`是一个开源项目，它为Python提供了地理空间数据处理的能力。它基于`pandas`库，并扩展了其对地理空间数据（如点、线、多边形等）的支持。`GeoDataFrame`是`geopandas`中的核心数据结构，它类似于`pandas`的`DataFrame`，但包含了一个额外的地理列（通常是`geometry`列），用于存储地理空间数据。
    69
  • 2
    “解锁Python高级数据结构新姿势：图的表示与遍历，让你的算法思维跃升新高度
    40
  • 3
    Redis数据结构—跳跃表 skiplist 实现源码分析
    62
  • 4
    逆袭之路！用 Python 玩转图的 DFS 与 BFS，让数据结构难题无处遁形
    65
  • 5
    Python中的列表（List）和元组（Tuple）是两种重要的数据结构
    53
  • 6
    【数据结构OJ题】链表分割
    32
  • 7
    【数据结构常见七大排序（三）上】—交换排序篇【冒泡排序】And【快速排序】
    45
  • 8
    【数据结构常见七大排序（二）】—选择排序篇【直接选择排序】And【堆排序】
    33
  • 9
    【数据结构常见七大排序（一）】—插入排序篇【直接插入排序】And【希尔排序】
    45
  • 10
    【数据结构OJ题】链表的回文结构
    39

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法

    • 相关电子书

    更多
  • 如何使用Tair增强数据结构构建丰富在线实时场景
  • Apache Flink 流式应用中状态的数据结构定义升级
  • 图解算法小抄
    • 下一篇
    阿里云OSS设置跨域访问