dsa-c/cpp 数组/链表/栈/队列

已于 2023-02-05 17:03:16 修改
阅读量409 收藏
点赞数
分类专栏： 算法与和数据结构 文章标签： c语言 数据结构 算法
于 2022-11-09 22:24:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_fengzifei/article/details/127779369
版权

dsa基础-c/cpp 数组/链表/栈/队列

1. 线性表

顺序表

模板

// 静态数组
#define MaxSize 10
typedef struct{
    ElemType data[MaxSize]; //ElemType表示任意数据类型 
    int length;
}SqList;

例子

// 静态分配
#include <stdio.h>

#define MaxSize 10
typedef struct
{
    int data[MaxSize];
    int length;
}SqList;

void InitList(SqList *L)
{
    for (int i=0;i<MaxSize;i++)
    {
        L->data[i]=0;
    }
    L->length=0;
}

int main()
{
    SqList L; //等价于Struct L
    InitList(&L);

    for (int i=0;i<MaxSize;i++)
    {
       printf("%d\t",L.data[i]);
    }
    printf("\n%d\n",L.length);
    return 0;
}

//动态分配
#define InitSize 10
typedef struct 
{
    int *data; //动态分配
    int MaxSize;
    int length;
}SeqList;

void InitList(SeqList *L)
{
    L->data=(int*)malloc(InitSize*sizeof(int));
    L->length=0;
    L->MaxSize=InitSize;
}

void IncreaseSize(SeqList *L,int len)
{
    printf("%p\n",L->data); //00000000006916A0
    int *p=L->data;
    printf("%p\n",p); //00000000006916A0
    L->data=(int*)malloc((L->MaxSize+len)*sizeof(int)); //0000000000691700 ,就把L->data当做一个指针就行了
    printf("%p\n",L->data);
    for (int i=0;i<L->length;i++)
    {
        L->data[i]=p[i];
    }
    L->MaxSize+=len;
    free(p);
}

int main()
{
    SeqList L;
    InitList(&L);
    // for (int i=0;i<InitSize;i++)
    // {
    //    printf("%d\t",L.data[i]);
    // }
    // printf("\n%d\n",L.length);
    IncreaseSize(&L,5);
    return 0;
}

插入/删除

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MaxSize 10

typedef struct
{
    int data[MaxSize];
    int length;
} SqList;

void InitList(SqList *L)
{
    for (int i = 0; i < MaxSize; i++)
    {
        L->data[i] = 0;
        // printf("%d\t",L->data[i]);
    }
    // printf("\n");
    L->length = 0;
}

// void ListInsert(SqList *L,int i,int e)
// {
//     for (int j=L->length;j>=i;j--)
//     {
//         L->data[j]=L->data[j-1];
//     }
//     L->data[i-1]=e;
//     L->length++;
// }

// version 2
// c99支持bool #include <stdbool.h>
bool ListInsert(SqList *L, int i, int e)
{
    if (i < 1 || i > L->length + 1 || L->length >= MaxSize)
        return false;

    for (int j = L->length; j >= i; j--)
    {
        L->data[j] = L->data[j - 1];
    }
    L->data[i - 1] = e;
    L->length++;

    return true;
}

bool ListDelete(SqList *L, int i, int *p)
{
    if (i > L->length)
        return false;
    *p = L->data[i - 1];

    int end=L->length-1;

    for (int j = i; j < L->length; j++)
    {
        L->data[j - 1] = L->data[j];
    }
    L->length--;

    L->data[end]=0; // 避免尾部冗余

    return true;
}

int main()
{
    SqList L;

    InitList(&L);

    // some insert code...
    for (int i = 1; i < 8; i++)
    {
        ListInsert(&L, i, i);
    }

    bool flag_insert = true;
    flag_insert = ListInsert(&L, 1, 13);


    if (!flag_insert)
    {
        printf("【error】:insert failed\n");
        return 0;
    }
    else
    {

        for (int i = 0; i < MaxSize; i++)
        {
            printf("%d\t", L.data[i]);
        }
        printf("\n");
    }


    // 返回删除的元素
    int e = -1;
    bool flag_del = true;
    flag_del = ListDelete(&L, 3, &e);

    if (!flag_del)
    {
        printf("【error】:delete failed\n");
        return 0;
    }
    else
    {
        printf("delete item: %d\n", e);
        for (int i = 0; i < MaxSize; i++)
        {
            printf("%d\t", L.data[i]);
        }
        printf("\n");
    }

    return 0;
}

查找

  • 按位查找

静态分配

#define MaxSize 10
typedef struct
{
	int data[MaxSize];
}SqList;

// 指针传递
int GetItem(SqList *L,int i)
{
	return L->data[i-1];
}

// version 2
// 引用传递
int GetItem(SqList &L,int i)
{
	return L.data[i-1]
}

动态分配

#define MaxSize 10
typedef struct
{
	int *data;
}SqList;

// 指针传递
int GetItem(SqList *L,int i)
{
	return L->data[i-1];
}

void InitList(SeqList *L)
{
    L->data=(int*)malloc(InitSize*sizeof(int));
}
  • 按值查找
// 利用for 循环判定

链表

单链表

模板

struct Node
{
    dataType data;
    struct Node *next; // 用于指向下一个节点
};

struct Node *p=(struct Node *)malloc(sizeof(struct Node));

free(p)

编码思想

typedef struct Node
{
    dataType data;
    struct Node *next; // 用于指向下一个节点
}NODE,*LinkList;
// typedef struct Node NODE;
// typedef struct Node *LinkList; 

// 下面其实是一样的，不过看起来更优雅
NODE * 表示一个节点，一个指向一个节点的指针
LinkList 表示一个链表


// 一个模板
NODE * GetNode(LinkList L,int i)
{
	int j=1; // 从1开始 不是从0开始
	NODE *p=L->next;

	if (i==0) 
		return L;
	
	if (i<1)
		return NULL;
	
	while (p!=NULL && j<i)
	{
		p=p->next;
		j++;
	}
	return p;
}

例子 - 不带头结点

typedef struct LNode
{
    int data;
    struct LNode *next; // 用于指向下一个节点
}LNode,*LinkList; 
// typedef struct LNode NODE;
// typedef struct LNode *LinkList; 

// 下面其实是一样的，不过看起来更优雅
// LNODE * 表示一个节点，一个指向一个节点的指针
// LinkList 表示一个链表

bool InitList(LinkList &L) // 引用传递
{
    L=NULL; //struct LNode* ，这个必须是指针引用，否则，就不对
    return true;
}

bool Empty(LinkList L) // 此时因为不涉及修改，则可以不使用指针引用
{
    if (L==NULL) 
        return true;
    else 
        return false;
}

int main()
{

    LinkList L; // 相当于指针引用
    InitList(L);

    return 0;
}

例子 - 带头结点 – 推荐使用带头结点的

typedef struct LNode
{
    int data;
    struct LNode *next; // 用于指向下一个节点
}LNode,*LinkList; 
// typedef struct LNode NODE;
// typedef struct LNode *LinkList ; 
 
// 下面其实是一样的，不过看起来更优雅
// LNODE * 表示一个节点，一个指向一个节点的指针
// LinkList 表示一个链表

bool InitList(LinkList &L) // 引用传递
{
    // 分配一个头节点
    L=(LNode *)malloc(sizeof(LNode));
    if (L==NULL)
        return false;
    
    L->next=NULL; // 头结点在初始化是，next指向null

    return true;
}

bool Empty(LinkList L) // 此时因为不涉及修改，则可以不使用指针引用
{
    if (L->next==NULL)  // 注意与不带头结点的区别
        return true;
    else 
        return false;
}

int main()
{
    LinkList L; // 相当于指针引用
    InitList(L);

    return 0;
}
插入删除
  • 带头结点

bool ListInsert(LinkList &L,int idx,int value); 注意j和越界插入

#include <iostream>
#include <cstdlib>

using namespace std;

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

bool InitList(LinkList &L)
{
    L=(LNode *)malloc(sizeof(LNode));

    if (L==NULL)
    {
        return false;
    }
    L->next=NULL;
    return true;
}

bool Empty(LinkList L)
{
    if (L->next==NULL)
    {
        return true;
    }
    else
    {
        return false;
    }
}


// 按位序插入节点
bool ListInsert(LinkList &L,int idx,int value)
{
    if (idx<1) // idx表示位序，从1开始
        return false;

    LNode *p; // 创建一个节点指针
    int j=0; // 当前p指向的是第j个节点
    p=L; // L是别名，p指向了L； 一开始L指向头节点，注意头节点是第0个节点

    // 遍历，找到第idx-1 也就是要插入的节点的前一个节点 idx是位序
    while (p!=NULL && j<idx-1)
    {
        p=p->next;
        j++;
    }

    /* version 1*/
    // if (p==NULL) // 如果找到最后一个节点
    // {
    //     return false;
    // }

    // // 分配空间
    // LNode *node=(LNode *)malloc(sizeof(LNode));

    // // 插入
    // node->data=value;
    // node->next=p->next;
    // p->next=node;

    // return true;

    /*version 2*/
    return InsertNextNode(p,value);

}

// 指定节点的插入 - 后插
bool InsertNextNode(LNode *pnode,int value)
{
    if (pnode==NULL)
    {
        return false;
    }
    
    LNode *node=(LNode *)malloc(sizeof(LNode));

    node->data=value;
    node->next=pnode->next;
    pnode->next=node;

    return true;

}


// 按位序删除节点
bool ListDelete(LinkList &L,int idx,int &value_return)
{
    if (idx<1)
    {
        return false;
    }

    LNode *pnode;
    int j=0;
    while (pnode!=NULL && j<idx-1)
    {
        pnode=pnode->next;
        j++;
    }

    if (pnode==NULL) // 如果找到最后一个节点
    {
        return false;
    }

    if (pnode->next==NULL) 
    {
        return false;
    }

    /*version 1*/
    // pnode->next=pnode->next->next;
    // value_return=pnode->next->data;
    // free(pnode->next);
    
    /*version 2*/
    LNode *pnext=pnode->next;
    value_return=pnext->data;
    pnode->next=pnext->next;
    free(pnext); // 注意，因为是malloc得来的要释放！！！ 且free释放的是分配的内存

    return true;

}

// 删除指定节点
//采用后继赋值的操作（翻转覆盖） ！！！
// 但是对于删除最后一个节点是存在问题的
bool DeleteNode(LNode *pnode)
{
    if (pnode==NULL)
    {
        return false;
    }

    LNode *pnext=pnode->next;
    pnode->data=pnode->next->data; // pnode->data=pnext->data
    pnode->next=pnext->next;
    free(pnext);
    return true;
}

int main()
{
    // struct LNode * L
    LinkList L;

    // struct LNode * &L=L; 形参L是实参L的别名
    InitList(L);

    ListInsert(L,1,1);

    return 0;
}
  • 不带头结点
#include <iostream>
#include <cstdlib>

using namespace std;

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

bool InitList(LinkList &L)
{
    L=NULL;
    return true;
}

bool Empty(LinkList L)
{
    if (L==NULL)
    {
        return true;
    }
    else
    {
        return false;
    }
}


bool ListInsert(LinkList &L,int idx,int value)
{
    if (idx<1) // idx表示位序，从1开始
        return false;

    // 初始节点
    if (idx==1)
    {
        LNode *firstNode=(LNode *)malloc(sizeof(LNode));
        firstNode->data=value;
        firstNode->next=L;
        L=firstNode;
        return true;
    }

    LNode *p; // 创建一个节点指针
    int j=1; // 当前p指向的是第j个节点
    p=L; // L是别名，p指向了L； 一开始L指向头节点，注意头节点是第0个节点

    // 遍历，找到第idx-1 也就是要插入的节点的前一个节点 idx是位序
    while (p!=NULL && j<idx-1)
    {
        p=p->next;
        j++;
    }

    if (p==NULL)
    {
        return false;
    }

    // 分配空间
    LNode *node=(LNode *)malloc(sizeof(LNode));

    // 插入
    node->data=value;
    node->next=p->next;
    p->next=node;

    return true;

}

int main()
{
    // struct LNode * L
    LinkList L;

    // struct LNode * &L=L; 形参L是实参L的别名
    InitList(L);

    ListInsert(L,1,1);

    return 0;
}
查找
  • 按位查找（带头结点）
LNode *GetItem(LinkList L,int idx)
{
    if (idx<0)
    {
        return NULL;
    }

    LNode *pnode;
    int j=0;
    pnode=L;
    
    while (pnode!=NULL && j<idx)
    {
        pnode=pnode->next;
        j++;
    }

    return pnode;
}

// 按位序插入节点
bool ListInsert(LinkList &L,int idx,int value)
{
    if (idx<1) // idx表示位序，从1开始
        return false;

	LNode *p=GetItem(L,idx-1);

    /* version 1*/
    // if (p==NULL) // 如果找到最后一个节点
    // {
    //     return false;
    // }

    // // 分配空间
    // LNode *node=(LNode *)malloc(sizeof(LNode));

    // // 插入
    // node->data=value;
    // node->next=p->next;
    // p->next=node;

    // return true;

    /*version 2*/
    return InsertNextNode(p,value);

}

// 指定节点的插入 - 后插
bool InsertNextNode(LNode *pnode,int value)
{
    if (pnode==NULL)
    {
        return false;
    }
    
    LNode *node=(LNode *)malloc(sizeof(LNode));

    node->data=value;
    node->next=pnode->next;
    pnode->next=node;

    return true;

}

LNode *GetItem(LinkList L,int idx)
{
    if (idx<0)
    {
        return NULL;
    }

    LNode *pnode;
    int j=0;
    pnode=L;
    
    while (pnode!=NULL && j<idx)
    {
        pnode=pnode->next;
        j++;
    }

    return pnode;
}
尾插法建立 – 很重要！！！
  • 普通方法

时间复杂度O(n)

#include <iostream>
using namespace std;

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

bool InitList(LinkList &L);
LNode * getNode(LinkList L,int idx);
bool ListInsert(LinkList &L,int idx,int value);
bool InsertNextNode(LNode *p,int value);

bool InitList(LinkList &L)
{
    L=(LNode *)malloc(sizeof(LNode));

    if (L==NULL)
    {
        return false;
    }

    L->next=NULL;
    return true;
}

bool ListInsert(LinkList &L,int idx,int value)
{
    if (L==NULL || idx<1)
    {
        return false;
    }

    // 按位查找找到前一个节点
    LNode *pre_node=getNode(L,idx-1);

    // 插入节点
    // if (!InsertNextNode(pre_node,value))
    // {
    //     return false;
    // }

    // return true;


    return InsertNextNode(pre_node,value);
}



LNode * getNode(LinkList L,int idx)
{
    if (idx<0)
    {
        return NULL;
    }

    LNode *p=L;
    int j=0;
    while (p!=NULL && j<idx)
    {
        p=p->next;
        j++;
    }

    return p;
}

bool InsertNextNode(LNode *p,int value)
{
    if (p==NULL)
    {
        return false;
    }

    // 分配一个新的节点
    LNode *new_node=(LNode *)malloc(sizeof(LNode));

    if (new_node==NULL)
    {
        return false;
    }

    new_node->data=value;
    if (p->next==NULL)
    {
        cout<<"NULL"<<endl;
    }
    else
    {
        cout<<"not NULL"<<endl;
    }
    
    new_node->next=p->next;
    p->next=new_node;

    return true;

}

int main()
{
    LinkList L;
    InitList(L); // 指针引用 ，头结点的值没有

    int insert_length=10;
    int j=0; // value
    int idx=1; // index
    while (j<insert_length)
    {
        ListInsert(L,idx,j);
        j++;
        idx++;
    }

    LNode *p=L->next; // 头结点的值没有
    while (p!=NULL)
    {
        cout<<p->data<<endl;
        p=p->next;
    }

    return 0;
}
  • 进阶方法
LinkList List_TailInsert(LinkList &L)
{
    int insert_length=10;
    int j=0; // value
    int idx=0; // index
    LNode *p=L;

    while (j<insert_length)
    {   
        LNode *new_node=(LNode *)malloc(sizeof(LNode));
        
        new_node->data=j;
        new_node->next=NULL;

        p->next=new_node; // 先对 L 添加一个节点
        p=new_node; // 再更新指针
        j++;
        idx++;
    }

    return L;
}
  • 进阶方法2
// 指定节点的插入 - 后插
bool InsertNextNode(LNode *pnode,int value)
{
    if (pnode==NULL)
    {
        return false;
    }
    
    LNode *node=(LNode *)malloc(sizeof(LNode));

    node->data=value;
    node->next=pnode->next;
    pnode->next=node;

    return true;

}

int main()
{
    // struct LNode * L
    LinkList L;

    // struct LNode * &L=L; 形参L是实参L的别名
    InitList(L);

    // ListInsert(L,1,1);
    
    /* == 插入 version 1 == */
    // int insert_length=10;
    // int j=0; // value
    // int idx=1; // index
    // while (j<insert_length)
    // {
    //     ListInsert(L,idx,j);
    //     j++;
    //     idx++;
    // }

    /* == 插入 version 2 == */
    // List_TailInsert(L); // 不返回也行

    /* == 插入 version 3 == */
    int insert_length=10;
    int value=0;
    int idx=1;
    LNode *p=L;
    while (idx<=insert_length)
    {
        if (InsertNextNode(p,value))
        {
            value++;
            idx++;
            p=p->next;
        }
        else
            break;
    }

    // LNode *p=L->next; // 头结点的值没有
    p=L->next; // 头结点的值没有
    while (p!=NULL)
    {
        cout<<p->data<<endl;
        p=p->next;
    }

    return 0;
}
头插法建立 – 很重要！！！

链表的逆序

双链表

模板

typedef struct DNode
{
    int data;
    struct DNode *prior; // 前驱结点
    struct DNode *next; // 后继节点
}DNode,*DLinkList;

带头结点

#include <iostream>
using namespace std;

typedef struct DNode
{
    int data;
    struct DNode *prior; // 前驱结点
    struct DNode *next; // 后继节点
}DNode,*DLinkList;

// 初始化
bool InitDLinkList(DLinkList &L)
{
    // 创建一个头结点
    L=(DNode*)malloc(sizeof(DNode));

    if (L==NULL)
    {
        return false;
    }

    L->prior=NULL;
    L->next=NULL;

    return true;
}


int main()
{
    DLinkList L;
    InitDLinkList(L);

    return 0;
}

遍历伪代码

    后序遍历
    DNode *p=L;
    while (p!=NULL)
    {
        cout<<p->data<<endl;
        p=p->next;
    }

    前向遍历 ？？？ 尾结点
    DNode *p=L;
    while (p->prior!=NULL) // 
    {
        cout<<p->data<<endl;
        p=p->prior;
    }
插入删除
#include <iostream>
using namespace std;

typedef struct DNode
{
    int data;
    struct DNode *prior; // 前驱结点
    struct DNode *next; // 后继节点
}DNode,*DLinkList;

bool InitDLinkList(DLinkList &L);
bool Empty(const DLinkList L);
bool DListInsert(DLinkList &L,int idx,int value);
bool InsertNextDNode_node(DNode *p,DNode *s);
bool InsertNextDNode(DNode *p,int value);
bool  DeleteNextDNode_node(DNode *p);
bool  DListDelete(DNode *p);

// 初始化
bool InitDLinkList(DLinkList &L)
{
    // 创建一个头结点
    L=(DNode*)malloc(sizeof(DNode));

    if (L==NULL)
    {
        return false;
    }

    L->prior=NULL;
    L->next=NULL;

    return true;
}

bool Empty(const DLinkList L)
{
    if (L->next==NULL)
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool DListInsert(DLinkList &L,int idx,int value)
{
    if (idx<1)
    {
        return false;
    }

    DNode *p=L;
    int j=0;

    // 后序遍历
    while (p!=NULL && j<idx-1) // 找到前一个节点
    {
        p=p->next;
        j++;
    }
    
    if (p==NULL)
    {
        return false;
    }

    /* version 1*/
    // DNode *new_node=(DNode *)malloc(sizeof(DNode));
    // new_node->data=value;
    // new_node->next=p->next;
    // if (p->next != NULL)
    // {
    //     p->next->prior=new_node;
    // }

    // new_node->prior=p;
    // p->next=new_node;

    /* version 2 后序插入*/
    InsertNextDNode(p,value);

    return true;
}

// p节点之后插入s节点 -- 例子
bool InsertNextDNode_node(DNode *p,DNode *s)
{
    if (p==NULL || s==NULL) // 判断节点的合法性
    {
        return false;
    }
    // 断后
    s->next=p->next;
    if (p->next != NULL) // 判断p是否为最后一个节点，这个很重要
    {
        p->next->prior=s;
    }

    // 接前
    s->prior=p;
    p->next=s;
    
    return true;
}

bool InsertNextDNode(DNode *p,int value)
{
    if (p==NULL)
    {
        return false;
    }

    DNode *new_node=(DNode *)malloc(sizeof(DNode));
    new_node->data=value;
    new_node->next=p->next;
    if (p->next != NULL)
    {
        p->next->prior=new_node;
    }

    new_node->prior=p;
    p->next=new_node;

    return true;
}

// 删除p节点的后继节点
bool  DeleteNextDNode_node(DNode *p)
{
    if (p==NULL)
    {
        return false;
    }

    DNode *q=p->next;
    if (q==NULL) // 要么错误，要么p就是最后一个节点，没有后继节点
    {
        return false;
    }

    p->next=q->next;
    if (q->next!=NULL) // q是最后一个节点，没有后继节点
    {
        q->next->prior=p;
    }

    free(q); // 因为原始这个是通过malloc开辟的内存
    return true;
}

// bool  DListDelete(DLinkList &L,int idx,int &value_return)
// {
//     // 第一个节点和最后一个节点！！！
// }



int main()
{
    DLinkList L;
    InitDLinkList(L);

    /* == 插入 version 1 O(n^2) == */
    // int insert_length=11;
    // int value=0; // value
    // int idx=1; // index
    // while (idx<=insert_length)
    // {
    //     DListInsert(L,idx,value);
    //     value++;
    //     idx++;
    // }

    /* == 插入 version 3 O(n) == */
    int insert_length=11;
    int value=0; // value
    int idx=1; // index
    DNode *p=L;
    while (idx<=insert_length)
    {
        if (InsertNextDNode(p,value))
        {
            p=p->next;
            value++;
            idx++;
        }
        else
            break;
    }

    // DNode *p=L->next; // 插入 version 1
    p=L->next; // 插入 version 3
    while (p!=NULL)
    {
        cout<<p->data<<endl;
        p=p->next;
    }
    
    return 0;
}

循环链表

  • 循环单链表
  • 循环双链表
循环单链表

最后一个节点的next指向头结点

初始化时，头结点指向自己
链表为空：头结点是否指向自己

#include <iostream>
using namespace std;

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

// 初始化
bool InitList(LinkList &L)
{
    L=(LNode *)malloc(sizeof(LNode));

    if (L==NULL)
    {
        return false;
    }

    L->next=L; // 指向自己
    return true;
}

bool Empty(const LinkList L)
{
    if (L->next==L) // 判断头结点的next是否指向自己
    {
        return true;
    }
    else
    {
        return false;
    }
    
}

// 判断节点p是否是循环单链表的表尾结点
// 某一结点的下一个节点是头结点
bool isTail(LinkList L,LNode *p)
{
    if (p->next==L)
    {
        return true;
    }
    else
    {
        return false;
    }
    
}


int main()
{
    return 0;
}

静态链表 – 没细看

模板

#define MAXSIZE 10

struct Node
{
    int data;
    int next; // 下一个元素的数组下表
};


int main()
{
    struct Node arr[MAXSIZE]; // 数组
    return 0;
}

编码思想

#define MAXSIZE 10

typedef struct
{
    int data;
    int next; // 下一个元素的数组下表
}SLinkList[MAXSIZE];


int main()
{
    // struct Node arr[MAXSIZE]; // 数组
    SLinkList arr;
    return 0;
}

栈

模板

#define MaxSize 10
typedef struct stack
{
    int data[MaxSize]; // 静态分配
    int top; // 栈顶指针
}SqStack; // sq表示顺序

顺序栈

例子

静态存储

#include <iostream>
using namespace std;

#define MaxSize 10
typedef struct stack
{
    int data[MaxSize]; // 静态分配
    int top; // 栈顶指针
}SqStack; // sq表示顺序


void InitStack(SqStack &s)
{
    s.top=-1;
}

bool StackEmpty(const SqStack &s)
{
    if (s.top==-1)
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool Push(SqStack &s,int val)
{
    if (s.top==MaxSize-1) // 栈满
    {
        return false;
    }

    s.top++; // 栈顶+1
    s.data[s.top]=val; // 赋值  s.datap[++s.top]=val;
    return true;

}

bool Pop(SqStack &s,int &return_val)
{
    if (s.top==-1)
    {
        return false;
    }

    return_val=s.data[s.top]; // s.data[s.top--]
    s.top--;
    return true;
}

bool getTop(const SqStack &s,int return_val)
{ 
    if (s.top==-1)
    {
        return false;
    }

    return_val=s.data[s.top];
    return true;
}

int main()
{

    SqStack s;
    InitStack(s); // 初始化 

    // 赋值
    for (int i=0;i<MaxSize;i++)
    {
        Push(s,i);
    }

    int val=0;
    for (int i=0;i<MaxSize;i++)
    {
        if (Pop(s,val))
        {
            cout<<val<<endl;
        }
    }

    return 0;
}

链式栈

#include <iostream>
using namespace std;

#define MaxSize 10

typedef struct LinkStackNode
{
    int data;
    struct LinkStackNode *next;
} LSNode, *LinkStack;

bool initStack(LinkStack &LS)
{
    LS = (LSNode *)malloc(sizeof(LSNode));

    if (LS == NULL)
    {
        return false;
    }

    LS->next = NULL;
    return true;
}

bool StackEmpty(const LinkStack LS)
{
    if (LS->next == NULL)
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool Push(LinkStack &LS, int val)
{
    if (LS == NULL)
    {
        return false;
    }

    LSNode *lsNode = (LSNode *)malloc(sizeof(LSNode));

    if (lsNode == NULL)
    {
        return false;
    }

    // 利用头插法
    LSNode *head = LS;
    lsNode->data = val;
    lsNode->next = head->next;
    head->next = lsNode;
    
    return true;
}

bool Pop(LinkStack &LS, int &return_val)
{
    if (LS == NULL || StackEmpty(LS))
    {
        return false;
    }

    LSNode *head = LS;
    
    /* verison1 */
    // return_val=head->next->data;
    
    // if (head->next->next == NULL)
    // {
    //     head->next = NULL;
    // }
    // else
    // {
    //     head->next=head->next->next;
    // }

    /* version2 */ // -- 推荐这种写法
    LSNode *pnode=head->next;
    return_val=pnode->data;
    head->next=pnode->next;
    free(pnode);

    return true;
}

bool getTop(const LinkStack LS,int return_val)
{
    if (LS == NULL || StackEmpty(LS))
    {
        return false;
    }

    LSNode *head = LS;
    return_val=head->next->data;
    return true;
}


int main()
{

    LinkStack LS;
    initStack(LS);

    // 赋值
    for (int i=0;i<MaxSize;i++)
    {
        Push(LS,i);
    }

    int val=0;
    for (int i=0;i<MaxSize;i++)
    {
        if (Pop(LS,val))
        {
            cout<<val<<endl;
        }
    }

    return 0;
}

队列

顺序循环队列

利用数组实现

第一种实现方法

在某些情况下会浪费一个存储空间
在这里插入图片描述

#include <iostream>
using namespace std;

#define MaxSize 10
typedef struct queue
{
    int data[MaxSize];
    int front; // 队头，指向队头元素; 注意：出队后，队头指针向后移动
    int rear;  // 队尾，指向队尾元素的后一个元素（下一个待插入的元素）
} SqQueue;

void InitQueue(SqQueue &q)
{
    q.front = 0;
    q.rear = 0; // 队尾指向0
}

bool QueueEmpty(const SqQueue &q) // const SqQueue q 没有意义，因为本来就是深拷贝
{
    if (q.front == q.rear)
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool EnQueue(SqQueue &q, int val)
{
    if ((q.rear + 1) % MaxSize == q.front) // 这句很重要！！！队列满的条件：队尾指针的再下一个位置是队头
    {
        return false;
    }
    q.data[q.rear] = val;
    q.rear = (q.rear + 1) % MaxSize; // 这句很重要！！！画图思考
    return true;
}

bool DeQueue(SqQueue &q, int &return_val)
{
    if (q.rear == q.front) // 判断是否为空
    {
        return false;
    }

    return_val = q.data[q.front];
    q.front = (q.front + 1) % MaxSize;

    return true;
}

bool getHead(const SqQueue &q, int &return_val)
{
    if (q.rear == q.front)
    {
        return false;
    }
    return_val = q.data[q.front];
    return true;
}

size_t getLength(const SqQueue &q)
{
    return (q.rear + MaxSize - q.front) % MaxSize; // 记住！！！
}

int main()
{
    SqQueue q;
    InitQueue(q);

    for (int i=0;i<MaxSize;i++)
    {
        EnQueue(q,i);
    }

    int val=0;
    for (int i=0;i<MaxSize;i++)
    {
        if (DeQueue(q,val))
        {
            cout<<val<<endl;
        }
    }

    return 0;
}

第二种实现方法

链表队列

利用链表实现

例子1

#include <iostream>
using namespace std;

#define MaxSize 10

// 定义节点
typedef struct linkQueueNode
{
    int data;
    struct linkQueueNode* next;
}LQNode;

// 队头、队尾指针
typedef struct 
{
    LQNode *front; // 头节点 不是实际上的第一个元素
    LQNode *rear; // 尾节点
}LinkQueue;


void InitQueue(LinkQueue &q)
{
    // 头尾指向相同 
    q.rear=(LQNode *)malloc(sizeof(LQNode));
    q.front=q.rear;

    q.front->next=NULL;
}

bool IsEmpty(const LinkQueue q)
{
    /* version1 */
    if (q.front==q.rear)
    {
        return true;
    }
    else
    {
        return false; 
    }

    /* version2 */
    // if (q.front->next==NULL)
    // {
    //     return true;
    // }
    // else
    // {
    //     return false;
    // }
}

void EnQueue(LinkQueue &q,int val)
{
    LQNode *node=(LQNode *)malloc(sizeof(LQNode));

    node->data=val;
    node->next=NULL;

    q.rear->next=node; // 入队
    q.rear=node; // 修改尾指针
    
}


bool DeQueue(LinkQueue &q,int &return_val)
{
    if (IsEmpty(q))
    {
        return false;
    }

    /* version1 */
    // return_val=q.front->data; 
    // q.front->next=q.front->next->next; // 最好不要使用next->next 会出现内存内存泄漏！！！

    /* version2 */ // -- 推荐写法
    LQNode *pnode=q.front->next;
    return_val=pnode->data;
    q.front->next=pnode->next; // 出队

    // 特殊处理
    if (q.rear==pnode) // 如说是最后一个节点,画图理解很重要！！！
    {
        q.rear=q.front;
    }
     
    free(pnode); // 这种方法好，最好不要使用next->next 会出现内存内存泄漏！！！

    return true;
}

int main()
{
    LinkQueue q;
    InitQueue(q);

    for (int i=0;i<MaxSize;i++)
    {
        EnQueue(q,i);
    }

    int val=0;
    for (int i=0;i<MaxSize;i++)
    {
        if (DeQueue(q,val))
        {
            cout<<val<<endl;
        }
    }

    return 0;
}

例子2 !!! 反复思考

#include <iostream>
using namespace std;

#define MaxSize 10

// 定义节点
typedef struct linkQueueNode
{
    int data;
    struct linkQueueNode* next;
}LQNode;

// 队头、队尾指针
typedef struct LQ
{
    LQNode *front; // 头节点 不是实际上的第一个元素
    LQNode *rear; // 尾节点
}LQ,* LinkQueue;


void InitQueue(LinkQueue &q)
{
    // 头尾指向相同 
    // q=(LQ *)malloc(sizeof(LQ)); // q=(LinkQueue)malloc(sizeof(LinkQueue)); // !!!
    
    q->rear=(LQNode *)malloc(sizeof(LQNode));
    q->front=q->rear;

    q->front->next=NULL;
}

bool IsEmpty(const LinkQueue q)
{
    /* version1 */
    if (q->front==q->rear)
    {
        return true;
    }
    else
    {
        return false; 
    }

    /* version2 */
    // if (q->front->next==NULL)
    // {
    //     return true;
    // }
    // else
    // {
    //     return false;
    // }
}

void EnQueue(LinkQueue &q,int val)
{
    LQNode *node=(LQNode *)malloc(sizeof(LQNode));

    node->data=val;
    node->next=NULL;

    q->rear->next=node; // 入队
    q->rear=node; // 修改尾指针
    
}


bool DeQueue(LinkQueue &q,int &return_val)
{
    if (q==NULL|| IsEmpty(q))
    {
        return false;
    }

    /* version1 */
    // return_val=q->front->data; 
    // q->front->next=q->front->next->next; // 最好不要使用next->next 会出现内存内存泄漏！！！

    /* version2 */ // -- 推荐写法
    LQNode *pnode=q->front->next;
    return_val=pnode->data;
    q->front->next=pnode->next; // 出队

    // 特殊处理
    if (q->rear==pnode) // 如说是最后一个节点,画图理解很重要！！！
    {
        q->rear=q->front;
    }
     
    free(pnode); // 这种方法好，最好不要使用next->next 会出现内存内存泄漏！！！

    return true;
}

int main()
{
    // LinkQueue q=NULL;
    LinkQueue q;//=NULL;
    InitQueue(q);

    for (int i=0;i<MaxSize;i++)
    {
        EnQueue(q,i);
    }

    int val=0;
    for (int i=0;i<MaxSize;i++)
    {
        if (DeQueue(q,val))
        {
            cout<<val<<endl;
        }
    }

    return 0;
}

2. 递归

例子 斐波那契数列

#include <iostream>
using namespace std;

int Fib(int n)
{
    if (n==0)
    {
        return 0;
    }
    else if (n==1)
    {
        return 1;
    }
    else 
    {
        return Fib(n-1)+Fib(n-2);
    }
}

int main()
{
    int x=Fib(4);
    cout<<x<<endl;

    return 0;
}

在这里插入图片描述
在这里插入图片描述

aoaoGofei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dsa-in-cpp：C ++中的数据结构和算法问题的实现
02-13
基础类型包括数组、链表、栈、队列、树（如二叉搜索树、平衡二叉树等）、图等。这些数据结构在编程中广泛使用，例如，数组是基本的存储单元，链表解决了动态内存分配的问题，栈和队列则常用于处理递归和任务调度，而...
DSA-Using-CPP
04-04
常见的数据结构包括数组、链表、栈、队列、树（如二叉树、平衡树）、图等。在C++中，通过自定义结构体或类来实现这些数据结构，可以充分利用面向对象编程的优势，如封装、继承和多态性。 例如，数组是最基础的数据...
dsa基础-c/cpp 串
L_fengzifei的博客
01-07 134
dsa基础-c/cpp 串
DSAC、DSAC++、DSAC*
qq_43606268的博客
02-22 1594
DSAC系列文章阅读笔记小结
超全面的后端开发C/C++面经整理分享含详细参考答案 包括简历分享
热门推荐
GhostLWB的博客
08-26 9万+
本文为博主2020年秋招提前批的c/c++后端开发面经整理，包括C/C++语言基础，计网，数据库，linux，操作系统，场景题，智力题和hr常问题。面试问题来自前人的工作和博主面试时遇到的值得记录的问题，其中面试题答案多为博主自行解答（并且面试的时候也基本是这样回答的），回答中都附上了参考资料的链接，全文共七万余字，仅供大家作为面试准备材料的参考。 希望大家在准备面试的时候都能建立一个属于自己的题库，自己从网上寻找问题，然后自己进行解答，并且记录下来，这样在面试的时候就能行云流水般的回答上来。因此我把这份面
dsa-基础
L_fengzifei的博客
11-09 563
算法与数据结构基础
C/C++ 开源库及示例代码
iloveyankitty的博客
01-22 3707
转至：http://blog.csdn.net/x356982611/article/details/53187766?%3E 说明 本页面汇总俺收集的各种 C 和 C++ 的开源代码库，不定期更新。 如果你发现本页面的开源库有错漏之处，非常欢迎给俺提供反馈——有 GitHub 帐号的同学，可以给俺发 issue；没帐号的同学，可以去俺博客留言。 1 综合性的库
【八股】2024春招八股复习笔记3（测试、运维、安全、游戏、客户端）
小哈里的博客
03-27 3136
1、测试开发 2、运维开发 SRE 3、安全开发 4、运营开发/应用开发（全栈） 5、客户端：PC & 移动 & 游戏 我有一个问题，既然测试、运维、安全、运营、客户端都要会开发，同时还要会很多专业领域的知识，但是待遇和职业发展却都远远不如开发。那为什么不直接投业务开发呢（好吧可能是太卷了） 1、测试开发 1、网络 & 系统（含linux） 2、数据库，MySQL，JAVA 3、测试流程：单元测试、集成测试、系统测试 【八股】2024春招八股复习笔记3（测试、运维、安全、游戏、客户端）
JDBC心得体会-->总结
CSDN流星追月专属频道--吃的苦中苦，方为人上人！
09-10 1万+
JDBC部分 终端进入mysql： mysql -u root回车 终端进入oracle： telnet 192.168.0.23  然后sqlplus openlab/open123 MySQL常用命令： show databases; use tableName;  show tables; 一、概述JDBC     JDBC从物理结构上说就是Java语言访问数据库的
二叉搜索树增删改查完整实现(C++)
zorchp
01-19 1370
-
DSA-Cpp：cpp中dsa的Baiscs
02-16
首先，C++提供了一些内置的数据结构，如数组、链表、栈、队列、哈希表等。数组是最基础的结构，可以用来存储同类型元素的集合。链表则由一系列节点组成，每个节点包含数据和指向下一个节点的指针。栈和队列是两种...
DSA-cpp
03-10
在这个项目中，开发者可能集中展示了如何用 C++ 实现各种常用的数据结构（如数组、链表、栈、队列、树、图等）以及经典的算法（排序、搜索、图算法等）。下面我们将深入探讨这些数据结构和算法的核心概念以及它们在 ...
cpp-dsa-src.zip
06-06
数据结构是存储和组织数据的方式，包括数组、链表、栈、队列、树、图等；而算法是解决问题的步骤或计算过程，如排序、搜索、图遍历等。在cpp-dsa-src项目中，我们可以期待找到这些基本概念的实现。 CMake是一种跨...
C++对比C语言新的赋值
2401_85947445的博客
08-27 359
/int a=10;只能用于初始化不能运用于再次赋值。推荐你使用at函数，原因时at函数更安全。但是[ ]的方式效率更高。③string循环分为普通循环（for）和for each循环。可以使用cin把用户在命令行中的内容赋值到变量中。// 接收键盘输入，一个整数和字符串，可以连续操作。①在string中sizeof=strlen；// C++的字符串是string。// 会报一个异常，程序运行停止。④ string字符串与数字转换。4.string是字符串类。// 输出一个越界数据。
MySQL数据库MVCC机制底层原理详解
2303_78892316的博客
08-28 1199
由于min_id是所有未提交事务中最小的id，所以事务id小于min_id的一定是已经提交的事务是可见的，同时大于max_id的事务，是生成快照时还没有创建的事务，是不可见的，在min_id和max_id之间的事务要分两种情况，在未提交数组中则说明是不可见的，不在则说明事务已经提交是可见的，当执行查询语句，就会沿着版本链从最新的数据开始查，直到查到可见的数据。接下来执行第5行，同样是一个写操作也会生成事务id，同时上面我们说过，对于被修改的数据行还会生成一个数据版本，于是这个新生成的。
Python 数据结构：字典与集合的详细对比
最新发布
08-31 506
在 Python 编程语言中，字典（dictionary）和集合（set）是两种非常核心且功能强大的数据结构。它们在处理数据时扮演着不同的角色，了解它们的区别对于编写高效、清晰的代码至关重要。本文将详细介绍字典和集合的特点、用法以及何时使用它们。
数据结构
2301_80184169的博客
08-28 557
4.执行代码,复现段错误,产生包含出错信息的core文件(检查core文件是否生成)3.ulimit -c unlimited 不限制core文件的生成的大小。使用这种方法能够很好的解决段错误，在纠正和优化代码时效率显著提升。1.首先按照如下的方法配置Ubuntu，允许生成core文件。5.gdb a.out core 查看段错误产生的位置。2.重新编译代码并加入-g选项(允许进行GDB调试)
ssh-keygen -t dsa -f /etc/ssh/ssh_host_dsa_key 什么意思？
07-11
这个命令是用于生成 DSA 类型的 SSH 密钥对。具体含义如下： - `ssh-keygen`：是一个用于生成、管理和转换 SSH 密钥的命令行工具。 - `-t dsa`：指定生成的密钥类型为 DSA（Digital Signature Algorithm，数字签名算法）。 - `-f /etc/ssh/ssh_host_dsa_key`：指定生成的密钥文件路径为 `/etc/ssh/ssh_host_dsa_key`。这个密钥文件是用于 SSH 服务器的身份验证和加密通信的。 总结起来，这个命令的作用是在指定路径下生成一个 DSA 类型的 SSH 密钥对，用于 SSH 服务器的安全通信。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值