《数据结构》C语言

已于 2023-12-15 16:00:12 修改
阅读量32 收藏
点赞数
分类专栏： 《数据结构》C语言 文章标签： 数据结构 c语言 算法
于 2023-04-12 23:06:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61645176/article/details/127365159
版权

《数据结构》C语言

一. 线性表

1.顺序表

特点：逻辑上相邻，物理上也相邻，存取方便

#include<stdio.h>
#include<stdlib.h>
#define ElemType int //元素类型
#define Status int //函数类型
#define List_Size 100 // 存储空间初始量
#define List_Increase 10 // 存储空间增量
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef struct SqList {
    ElemType *elem; // 数据元素存储空间的首地址
    int length, listsize; // 线性表的当前长度和存储容量
}S;

Status Init_List(SqList &L);//构造一个空线性表
Status Destroy_List(SqList &L);//销毁线性表
Status Clear_List(SqList &L);//重置为空表
Status ListEmpty(SqList L);//表空true，否则false
Status ListLength(SqList L);//L中元素个数
Status ListInsert(SqList &L, int i, ElemType e);//在第i个位置前插入元素e
Status ListDel(SqList &L, int i, ElemType &e);//删除第i个元素，返回其值
Status GetElem(SqList L, int i, ElemType &e);//用e放回第i个元素的值
Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType));//返回第一个与e满足compare关系的元素位序


int main()
{
    SqList L;
    Init_List(L);
    for(int i = 1; i <= 5; i ++)
        ListInsert(L, 1, i);

    for(int i = 1; i <= 5; i ++)
        printf("%d ", *(L.elem + i - 1));
    return 0;
}

Status Init_List(SqList &L){
    L.elem = (ElemType*)malloc(List_Size*sizeof(ElemType));//分配空间并返回第一个字节地址
//L.elem = new ElemType[List_size];
    if(!L.elem) exit(OVERFLOW);
    L.length = 0;
    L.listsize = List_Size;
    return OK;
}

Status Destroy_List(SqList &L){
    free(L.elem);//释放内存
    L.elem = NULL;
    L.length = 0;
    L.listsize = 0;
    return OK;
}

Status Clear_List(SqList &L){
    L.length = 0;
    return OK;
}

Status List_Empty(SqList L){
    if(L.length == 0) return TRUE;
    else return FALSE;
}

Status ListLength(SqList L){
    return L.length;
}

Status ListInsert(SqList &L, int i, ElemType e){
    if(i < 1 || i > L.length + 1) return ERROR;//i不合法
    if(L.length >= L.listsize){//存储空间满，增加分配
        ElemType *newbase = (ElemType*) realloc (L.elem, (L.listsize + List_Increase)*sizeof(ElemType));
        if(!newbase) exit(OVERFLOW);
        L.elem = newbase;
        L.listsize += List_Increase;
    }

    ElemType *q;
    ElemType *p;
    q = L.elem + i - 1; //插入位置
  //q = &(L.elem[i - 1]);

    //往后移
    for(p = &(L.elem[L.length - 1]); p >= q; p --){
        *(p + 1) = *p;
    }

    *q = e;
    L.length ++;
}

Status ListDel(SqList &L, int i, ElemType &e){
    if(i < 1 || i > L.length) return ERROR;

    ElemType *q, *p;
    q = L.elem + i - 1;//删除位置
    e = *q;//删除元素的值
    p = L.elem + L.length - 1;
    for(q ++; q <= p; q ++){ //i后面的左移
        *(q - 1) = *q;
    }
    L.length --;
    return OK;
}

Status GetElem(SqList L, int i, int &e){
    if(i < L.length || i > L.length) exit(ERROR);
    e = *(L.elem + i - 1);
    return OK;
}

Status LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType)){
    int i = 1;
    ElemType *q;
    q = L.elem;
    while(i <= L.length && !compare(*q ++, e)){
        i ++;
    }
    if(i <= L.length) return i;
    else return 0;
}

2.链表

特点：逻辑上相邻，物理上不一定相邻，插删方便
（*a）.b 等价于 a->b

#include<stdio.h>
#include<stdlib.h>
#define ElemType int //元素类型
#define Status int //函数类型
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef struct LNode {
    ElemType data;  //数据域
    struct LNode *next;  //指针域
} LNode, *LinkList;

Status InitList(LinkList &L); //构造一个空的单链表
Status DestroyList(LinkList &L); //销毁顺序线性表L
Status ClearList(LinkList &L); //单链表清空
Status ListEmpty(LinkList L); //单链表判空
int ListLength(LinkList L); //求链表长度
Status GetElem(LinkList L, int i, ElemType &e); //取单链表中位序为i的元素值
int LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType,ElemType)); //定位操作，返回L中第1个与e满足关系compare()的数 据元素的位序。若未找到则返回0
Status PriorElem(LinkList L, ElemType cur_e, ElemType &pre_e); //求前驱操作
Status NextElem(LinkList L, ElemType cur_e, ElemType &next_e); //求后继操作
Status ListInsert(LinkList &L, int i, ElemType e); //在L中第i个位置之前插入新的数据元素e
Status ListDelete(LinkList L, int i, ElemType &e); //在L中删除第i个位置元素，由e返回其值
Status comp(ElemType c1,ElemType c2); //数据元素判定函数(相等为TRUE,否则为FALSE)
void display(LinkList L); //遍历

int main()
{
    LinkList L; //单链表的头指针
    InitList(L);
    for(int i = 1; i <= 5; i ++)
        ListInsert(L, 1, i);
    display(L);
    return 0;
}

Status InitList(LinkList &L)
{
    L = (LinkList)malloc(sizeof(struct LNode)); //产生头结点,并使L指向此头结点
    if(!L) // 存储分配失败
        exit(OVERFLOW);
    L -> next = NULL; // 指针域为空
    return OK;
}

Status DestroyList(LinkList &L)
{
    LinkList q;
    while(L)
    {
        q = L -> next;
        free(L);
        L = q;
    }
    return OK;
}

Status ClearList(LinkList &L)
{ // 初始条件：线性表L已存在。操作结果：将L重置为空表
    LinkList p, q;
    p = L -> next; // p指向第一个结点
    while(p) // 没到表尾
    {
        q = p -> next;
        free(p);
        p = q;
    }
    L -> next = NULL; // 头结点指针域为空
    return OK;
}

Status ListEmpty(LinkList L)
{
    if(L-> next) // 非空
        return FALSE;
    else
        return TRUE;
}

int ListLength(LinkList L){
    int n = 0;
    LinkList p = L -> next;
    while(p){
        n ++;
        p = p -> next;
    }
    return n;
}

Status ListInsert(LinkList &L, int i, ElemType e){
    LinkList p = L;
    int j = 0;
    while(p && j < i - 1){
        p = p -> next;
        j ++;
    }
    if(!p || j > i - 1) return ERROR;
    LinkList s = (LinkList) malloc (sizeof(LNode));
    s -> data = e;
    s -> next = p -> next;
    p -> next = s;
    return OK;
}

Status ListDelete(LinkList L, int i, ElemType &e)
{ /* 在带头结点的单链线性表L中，删除第i个元素,并由e返回其值 */
    int j = 0;
    LinkList p = L, q;
    while(p -> next && j < i - 1) // 寻找第i个结点,并令p指向其前趋
    {
        p = p -> next;
        j ++;
    }
    if(!p -> next || j > i-1) /* 删除位置不合理 */
        return ERROR;
    q = p -> next; /* 删除并释放结点 */
    p -> next = q -> next;
    e = q -> data;
    free(q);
    return OK;
}

void display(LinkList head)
{
    LinkList p = head->next;
    while(p != NULL)			//注意陈列打印的条件
    {
        printf("%d ", p -> data);
        p = p -> next;
    }
    return;
}

Status GetElem(LinkList L, int i, ElemType &e) /* 算法2.8 */
{
    int j = 1; // j为计数器
    LinkList p = L -> next; // p指向第一个结点
    while(p && j < i) // 顺指针向后查找,直到p指向第i个元素或p为空
    {
        p = p -> next;
        j ++;
    }
    if(!p || j > i) // 第i个元素不存在
        return ERROR;
    e = p -> data; // 取第i个元素
    return OK;
}


Status PriorElem(LinkList L, ElemType cur_e, ElemType &pre_e)
{
    // 操作结果: 若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱, 返回OK;否则操作失败,pre_e无定义,返回INFEASIBLE
    LinkList q, p = L -> next; // p指向第一个结点
    while(p -> next) // p所指结点有后继
    {
        q = p -> next; // q为p的后继
        if(q -> data == cur_e)
        {
            pre_e = p -> data;
            return OK;
        }
        p = q; //p向后移
    }
    return INFEASIBLE;
}

Status NextElem(LinkList L, ElemType cur_e, ElemType &next_e)
{
    // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，返回OK;否则操作失败，next_e无定义，返回INFEASIBLE
    LinkList p = L -> next; // p指向第一个结点
    while(p -> next) // p所指结点有后继
    {
        if(p -> data == cur_e)
        {
            next_e = p -> next -> data;
            return OK;
        }
        p = p -> next;
    }
    return INFEASIBLE;
}

int LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType)){
    int i = 0;
    LinkList p = L -> next;
    while(p){
        i ++;
        if(compare(p -> data, e)) return i;
        p = p -> next;
    }
    return ERROR;
}

Status comp(ElemType c1, ElemType c2)
{ /* 数据元素判定函数(相等为TRUE,否则为FALSE) */
    if(c1 == c2)
        return TRUE;
    else
        return FALSE;
}

二. 栈和队列

1.队列

//头节点不存数据，便于操作
#include <stdio.h>
#include<malloc.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef int ElemType;

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

typedef struct LinkQueue{
    LinkList front, rear; //对头队尾指针
}LinkQueue;


//如果不能用引用，形参用指针类型,(LinkQueue *Q), 函数中的前也要加*，下面函数中的e也一样
Status InitQueue(LinkQueue &Q){ //初始化
    Q.front = Q.rear = (LinkList) malloc(sizeof(LNode)); //强转为LinkList指针
    if(!Q.front) exit(OVERFLOW);
    Q.front -> next = NULL;
    return OK;
}

Status DestroyQueue(LinkQueue &Q){ //销毁
    while(Q.front){ //非空
        LinkList p = Q.front -> next;
        free(Q.front);
        Q.front = p;
    }
    return OK;
}

Status QueueInsert(LinkQueue &Q, ElemType e){ //入队
    LinkList p = (LinkList)malloc(sizeof(LNode));
    if(!p) exit(OVERFLOW);
    p -> data = e;
    p -> next = NULL;
    Q.rear -> next = p; //入队，把p接在后面
    Q.rear = p; //把队尾更新
    return OK;
}

Status DeQueue(LinkQueue &Q, ElemType &e){ //出队
    if(Q.front == Q.rear) return ERROR;
    LinkList p = Q.front -> next;
    e = p -> data;
    Q.front -> next = p -> next; //ne[idx] = ne[ne[idx]]那个意思;
    if(Q.rear == p) Q.rear = Q.front; //要出队的对头已经是最后一个元素了
    free(p); //c++可以delete p;
    return OK;
}

Status GetHead(LinkQueue &Q, ElemType &e){ //获取对头，不出队
    if(Q.rear == Q.front) return ERROR;
    e = Q.front -> next -> data;
    return OK;
}

int QueueLength(LinkQueue &Q){
    int len = 0;
    LinkList p;
    if(Q.front == Q.rear) return 0;
    p = Q.front -> next;
    while(p){
        len ++;
        p = p -> next;
    }
    return len;
}

Status visit(LinkQueue Q){
    if(Q.front == Q.rear) return ERROR;
    LinkList p = Q.front -> next;
    while(p){
        printf("%d ", p -> data);
        p = p -> next;
    }
    return OK;
}

int main()
{
    LinkQueue Q;
    InitQueue(Q); //形参用的指针类型的话，传入要加引用
    for(int i = 1; i <= 3; i ++) QueueInsert(Q, i);
    visit(Q);
    printf("\n");
    printf("len: %d\n", QueueLength(Q));
    int x;
    DeQueue(Q, x);
    printf("first: %d\n", x);
    return 0;
}

2.栈

在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#define ElemType int //元素类型
#define Status int //函数类型
#define Init_Size 100 // 存储空间初始量
#define Stack_Increase 10 // 存储空间增量
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef struct{
    ElemType *base, *top;
    int stacksize;
}SqStack;

Status InitStack(SqStack &S); //构造一个空栈
Status StackEmpty(SqStack S); //栈空，返回true
Status StackLength(SqStack S);
Status GetTop(SqStack S, ElemType &e); // 取栈顶，不pop
Status Push(SqStack &S, ElemType &e);
Status Pop(SqStack &S, ElemType &e);

int main()
{
    SqStack S;
    InitStack(S);
    for(int i = 1; i <= 5; i ++)
        Push(S, i);
    while(!StackEmpty(S)){
        int e;
        GetTop(S, e);
        Pop(S, e);
        printf("%d ", e);
    }
}

Status InitStack(SqStack &S){
    S.base = (ElemType *)malloc(Init_Size * sizeof(ElemType));
    if(!S.base) exit(OVERFLOW);

    S.top = S.base;
    S.stacksize = Init_Size;
    return OK;
}

Status GetTop(SqStack S, ElemType &e){
    if(S.top == S.base) return ERROR;
    e = *(S.top - 1);
    return OK;
}

Status StackEmpty(SqStack S){
    return S.base == S.top ? OK : ERROR;
}

Status StackLength(SqStack S){
    if(S.base == S.top)
        return 0;
    else
        return S.top - S.base;
}

Status Push(SqStack &S, ElemType &e){
    if(S.top - S.base >= S.stacksize){ //栈满，分配空间
        S.base = (ElemType *)realloc(S.base, (S.stacksize + Stack_Increase) * sizeof(ElemType));
        if(!S.base) exit(OVERFLOW);

        S.top = S.base + S.stacksize;
        S.stacksize += Stack_Increase;
        return OK;
    }

    *S.top ++ = e; //*S.top = e, S.top ++;
    return OK;
}

Status Pop(SqStack &S, ElemType &e){
    if(S.top == S.base) return ERROR; //栈空
    e = * --S.top; //S.top --, e = *S.top
    return OK;
}

三. 树和二叉树

1.二叉树

先序遍历构建二叉树，前中后序遍历（递归）

在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#define TRUE       1
#define FALSE      0
#define OK         1
#define ERROR      0
#define OVERFLOW   -1
#define INFEASIBLE -2
#define NULL  0
#define Status int
#define ElemType char

typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

BiTree CreatBiTree()
{
    ElemType ch;
    scanf("%c", &ch);
    BiTree T;
    if(ch == '#') T = NULL;
    else{
        T = (BiTree)malloc(sizeof(BiTNode));
        if(!T) exit(OVERFLOW);
        T -> data = ch;
        T -> lchild = CreatBiTree();
        T -> rchild = CreatBiTree();
    }
    return T; //返回根节点
}

void Pre(BiTree T){
    if(T){
        printf("%c ", T -> data);
        if(T -> lchild) Pre(T -> lchild);
        if(T -> rchild) Pre(T -> rchild);
    }
}

void Mid(BiTree T){
    if(T){
        if(T -> lchild) Mid(T -> lchild);
        printf("%c ", T -> data);
        if(T -> rchild) Mid(T -> rchild);
    }
}

void Post(BiTree T){
    if(T){
        if(T -> lchild) Post(T -> lchild);
        if(T -> rchild) Post(T -> rchild);
        printf("%c ", T -> data);
    }
}

int main()
{
    BiTree T;
    T = CreatBiTree();
    Pre(T);
    printf("\n");
    Mid(T);
    printf("\n");
    Post(T);
}

非递归遍历
——待更新——

由前中或中后创建二叉树
——待更新——

2.哈夫曼树

哈夫曼树的结点的度数为0或2，没有度为1的结点
包含n颗树的森林要经过n - 1次合并形成哈夫曼树，共产生n - 1个新节点，所以包含n个叶子结点的哈夫曼树中共有2n - 1个结点

Mhha
关注
专栏目录
数据结构（C语言）
m0_74433210的博客
11-20 78
线性表：简称表，是n个元数据元素的有序序列，线性表中的数据元素的个数称为线性表的长度。第一个元素称为表头元素，最后一个称为表尾元素。表头元素没有前驱，表尾元素没有后继。其他元素有且只有一个前驱和一个后继。抽象数据类型定义单词：IntList：输入：无；功能：线性表的初始化；输出：空的线性表；CreatList：输入：n个数据元素；功能：建立一个线性表；输出：具有n个元素的线性表；输入：无；功能：销毁线性表；输出：释放线性表的存储空间；PrintList：输入：无；
C语言数据结构
m0_60377292的博客
10-18 154
逆向工程（Reverse engineering）是一种技术过程，即对一项目标产品进行逆向分析及研究，从而演绎并得出该产品的处理流程、组织结构、功能性能规格等设计要素，以制作出功能相近但不完全一样的产品的过程。在CTF中，逆向工程一般是指软件逆向工程，即对已经编译完成的可执行文件进行分析，研究程序的行为和算法，然后以此为依据，计算出出题人想隐藏的flag。 ...
数据结构C语言版（李云清）代码
CSDNadmin00的博客
12-04 2015
数据结构代码
数据结构（C语言版）
2301_78561643的博客
05-16 3769
线性结构的特点是：在数据元素的非空有限集中，存在唯一的一个被称为“第一个”的数据元素存在唯一的一个被称为“最后一个”的数据元素除第一个外，集合中的每个元素均只有一个前驱除最后一个外，集合中的每个元素均只有一个后继线性表：最常用且最简单的一种数据结构，即一个线性表是n个数据元素的有限序列在稍复杂的线性表中，一个数据元素可以由若干个数据项组成，在这种情况下，数据元素被称为记录，含有大量记录的线性表又称为文件同一线性表中的元素必定由相同的特性，即属于同一数据对象，相邻数据元素之间存在着序偶关系。
数据结构c语言版严蔚敏第二版课后答案
shenghuodedaan的博客
03-18 1834
数据结构c语言版第二版课后答案严蔚敏 1.自学编程，难免思路阻塞，收集更新了严蔚敏,吴伟民版《数据结构-C语言版》加粗样式各章节的课本源码和配套习题集答案解析，目的是为了整理数据结构中的知识点，并与网友交流意见，集思广益，共同进步。这里是所有的源码和课后习题实现目录： 除了这些源码和答案还有数据结构 严蔚敏（c语言）第二版PDF书籍 下载地址在文章最下方： 02.本源码与解析涵盖了**《数据结构...
严蔚敏数据结构C语言版本-可运行源码-完全C语言代码实现.zip
08-17
严蔚敏数据结构C语言版本_可运行源码_完全C语言代码实现 ----- 毕业设计，课程设计，项目源码均经过助教老师测试，运行无误，欢迎下载交流 ----- 下载后请首先打开README.md文件（如有），某些链接可能需要魔法打开...
数据结构C语言版第一章课件严蔚敏_数据结构C语言_
10-03
在本主题中，我们将聚焦于严蔚敏教授的数据结构C语言版第一章课件，主要涵盖数据结构的基础知识以及C语言实现的排序算法。 一、数据结构基础 数据结构可以分为两大类：线性结构和非线性结构。线性结构包括数组、...
严蔚敏数据结构c语言版光盘文件
07-25
严蔚敏数据结构c语言版光盘文件
数据结构C语言版期末考试试题(有答案)
05-15
数据结构C语言版期末考试试题(有答案) 数据结构C语言版期末考试试题(有答案) 数据结构C语言版期末考试试题(有答案) 数据结构C语言版期末考试试题(有答案)
详解：冒泡排序
2401_83418369的博客
09-14 939
冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
【数据结构初阶】顺序结构二叉树（堆）接口实现超详解
fhvyxyci的博客
09-17 661
1树 1.1 树的概念与结构 1.2 树的相关术语 1.3 树的表示 1.4 树形结构实际运用场景 2二叉树 2.1 概念与结构 2.2 特殊的二叉树 2.2.1 满二叉树 2.2.2 完全二叉树 2.3 二叉树存储结构 2.3.1 顺序结构 2.3.2 链式结构 3实现顺序结构二叉树（小堆） 3.1 堆的概念与结构 3.2 堆的实现 3.2.1 堆的定义 3.2.2 初始化与销毁 3.2.3 交换 3.2.4 入堆与向上调整函数 3.2.5 判空与取堆顶数据与堆的大小 3.2.6 出堆与向下调整 大堆
09年408考研真题-数据结构
weixin_62182040的博客
09-17 542
15.【2009统考真题】若数据元素序列{11,12,13,7,8,9,23,4,5}是采用下列排序方法之一得到的第二趟排序后的结果，则该排序算法只能是(）。11.[2009统考真题]将森林转换为对应的二叉树，若在二叉树中，结点u 是结点v的父结点的父结点，则在原来的森林中，u 和 v 可能具有的关系是(B)。11.【2009统考真题】已知关键字序列5,8,12,19,28,20,15,22是小根堆,插入关键字3,调整好得到的小根堆是(）。B插入排序，经过插入排序之后，它的前三个元素应该是有序的，B正确。
数据结构---非线性--树
2301_80434764的博客
09-13 819
本文将详细介绍树及其变体在计算机科学中的应用及实现。首先，将概述树的基本概念、结构及其实际应用，包括树的表示方法及在各种应用场景中的重要性。接着，深入探讨二叉树的基本概念、特殊类型及其性质，并比较顺序存储和链式存储这两种主要存储结构。 在探讨二叉树的顺序结构及实现时，重点讲解堆的概念与结构，涵盖堆的向上和向下调整算法、建堆的时间复杂度以及堆的插入和删除操作，并讨论堆在排序和Top-K问题中的应用。最后，讨论二叉树的链式结构实现，包括各种遍历方式（如前序、中序、后序和层序遍历）和常见接口。
数据结构—栈
2301_80151359的博客
09-17 323
/定义栈的结构//栈的空间大小int top;//栈顶}ST;
王道408考研数据结构-线性表-第二章
qq_55882840的博客
09-17 749
2.1 线性表的定义2.1.1 线性表的定义线性表是具有相同数据类型的n(n≥0)个数据元素的有限序列，其中n为表长，当n=0 时线性表是一个空表。若用L命名线性表，则其一般表示为式中，a1是唯一的“第一个”数据元素，又称表头元素；an是唯一的“最后一个”数据元素，又 称表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直接后继(“直接前驱”和“前驱”、“直接后继”和“后继”通常被视为同义词)。
Java-数据结构-二叉树-习题(三) ￣へ￣
最新发布
2303_80388948的博客
09-17 674
OK，我们的这个关于我们的二叉树的习题三但这里就结束了，同时到这里呢，我们的数据结构 ——二叉树 也就结束了，之后呢我们进入到新的章节了，欲知后事如何，且听下回分说拜拜啦~~~我们下篇博客再见。
数据结构——栈和队列（队列的定义、顺序队列以及链式队列的基本操作）
weixin_74209413的博客
09-13 1208
队列和栈一样，也是限定只能在表的“端点”进行的线性表。队列在插入的时候，只能在表尾进行插入，在删除的时候，只能在表头进行删除。（先进先出），表尾即队尾，表头即队头。栈和队列是线性表的子集（是插入和删除位置受限的线性表）由于队列的操作具有先进先出的特性，使得队列成为程序设计中解决类似排队问题的有用工具。队列的逻辑结构与同线性表相同，仍为一对一关系。队列的存储结构有顺序队和链队，以循环顺序队列更常见。关键是掌握入队和出队操作，具体实现依顺序队或链队的不同而不同。
Java数据结构（十一）——归并排序、计数排序
xiaokuer_的博客
09-17 902
文章介绍了稳定的归并排序，同时介绍了非基于比较的一种排序方法——计数排序，但要注意其使用场景
数据结构C语言实现与理论解析
“数据结构C语言版，数据结构是计算机科学与技术的核心课程，与操作系统、编译原理等课程紧密相关，对于解决实际问题至关重要。” 在计算机科学中，数据结构是研究数据的组织方式、存储形式以及它们之间的相互关系...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值