数据结构day3

已于 2022-07-21 21:14:28 修改
阅读量140 收藏
点赞数
文章标签： 数据结构 链表
于 2022-07-21 20:22:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yayyy4/article/details/125919812
版权

循环列表实现约瑟夫杯

主函数（main.c文件）

#include<stdio.h>
#include<stdlib.h>
#include"a.h"
int main(int argc,const char *argv[])
{
        Looplink *L=link_create();
        if(NULL==L)
        {
                return -1;
        }
        int i=1;
        int j=0,n,m;
        printf("m=");
        scanf(" %d",&m);
        printf("n=");
        scanf(" %d",&n);
        while(i<=n)
        {
                list_tail_insert(L,i);
                i++;
        }
        list_traver(L);
        Looplink *p=L->next;
        Looplink *S=link_create();
        Looplink *q=kill_head(L);
        printf("约瑟夫杯:");
        while(j<n)
        {
                for(i=0;i<m;i++)
                {
                    if(i==m-1)
                        {
                                //1.
                                //printf("%d ",p->data);
                                //2.
                                list_tail_insert(S,p->data);
                                p=kill_head(p);
                        }
                        else
                        {
                                p=p->next;
                        }
                }
                j++;
        }
        list_traver(S);
}

两种表现方式，注释1为输出显示约瑟夫杯，注释2的地方为将寻找的数从新放进一个新的循环链表中，再利用链表的遍历输出。

.h函数部分（主要使用的部分）

删除头节点函数（主要利用函数）

Looplink *kill_head(Looplink *L)
{
        if(NULL==L || list_empty(L))
        {
                printf("delate failed!\n");
                return NULL;
        }
        Looplink *q=L->next;
        while(q->next!=L)
        {
                q=q->next;
        }
        q->next=L->next;
        free(L);
        L=NULL;
        printf("head delate successful!\n");
        return q->next;
}

创建函数

Looplink *link_create()
{
        Looplink *L=(Looplink*)malloc(sizeof(Looplink));
        if(NULL == L)
        {
                printf("create failed!\n");
                return NULL;
        }
        L->len=0;
        L->next=L;
        printf("create successful!\n");
        return L;
}

尾插函数

//tail insert
int list_tail_insert(Looplink *L,datatype e)
{
        if(NULL == L)
        {
                printf("link is wrong!\n");
                return -1;
        }
        Looplink *p=(Looplink*)malloc(sizeof(Looplink));
        if(NULL==p)
        {
                printf("node apply failed!\n");
                return -2;
        }
        p->data=e;
        p->next=NULL;
        Looplink *q=L;
        while(q->next!=L)
        {
                q=q->next;
        }
        p->next=L;
        q->next=p;
        L->len++;
//      printf("insert successful!\n");
        return 0;
}

遍历函数

//traverse
void list_traver(Looplink *L)
{
        if(NULL == L || list_empty(L))
        {
                printf("traverse failed!\n");
                return;
        }
        Looplink *q=L->next;
        while(q!=L)
        {
                printf("%d ",q->data);
                q=q->next;
        }
        printf("\n");
}

无头遍历

​
//no head traverse
void list_show(Looplink *S)
{
        if(NULL==S)
        {
                printf("traverse failed!\n");
                return ;
        }
        Looplink *q=S;
        do
        {
                printf("%d ",q->data);
                q=q->next;
        }while(q!=S);
        printf("\n");
}

​

头删函数

//head delate
Looplink *kill_head(Looplink *L)
{
        if(NULL==L || list_empty(L))
        {
                printf("delate failed!\n");
                return NULL;
        }
        Looplink *q=L->next;
        while(q->next!=L)
        {
                q=q->next;
        }
        q->next=L->next;
        free(L);
        L=NULL;
        printf("head delate successful!\n");
        return q->next;
}

 尾删函数

//tail delate
int list_tail_delate(Looplink *L)
{
        if(NULL == L || list_empty(L))
        {
                printf("tail delate failed!\n");
                return -1;
        }
        Looplink *q=L;
        while(q->next->next!=L)
        {
                q=q->next;
        }
        free(q->next);
        q->next=L;
        L->len--;
        printf("delate successful!\n");
        return 1;
}

.h文件

#ifndef __D__
#define __D__

typedef int datatype;
typedef struct Node
{
        union
        {
                datatype data;
                int len;
        };

        struct Node *next;
}Looplink;

//create
Looplink *link_create();
//empty
int list_empty(Looplink *L);
//tail insert
int list_tail_insert(Looplink *L,datatype e);
//traverse
void list_traver(Looplink *L);
//tail delate
int list_tail_delate(Looplink *L);
//head delate
Looplink *kill_head(Looplink *L);
//no head traverse
void list_show(Looplink *L);
#endif

利用栈实现进制转换

主函数（main.c文件）

#include<stdio.h>
#include<stdlib.h>
#include"a.h"
int main(int argc,const char *argv[])
{
        SqStack *S=stack_create();
        if(NULL==S)
        {
                return -1;
        }
        int i,j,k;
        printf("1.二进制转换\n2.八进制转换\n3.十六进制转换\n请选择操作方式：\n");
        scanf("%d",&k);
        switch(k)
        {
                case 1: printf("请输入十进制数：");
                        scanf("%d",&i);
                        printf("转换为二进制数为：");
                        while(i>0)
                        {
                                j=i%2;
                                Push(S,j);
                                i=i/2;
                        }
                        show(S);
                        break;
                case 2: printf("请输入十进制数：");
                        scanf("%d",&i);
                        printf("转换为八进制数为：");
                        while(i>0)
                        {
                                j=i%8;
                                Push(S,j);
                                i=i/8;
                        }
                        show(S);
                        break;
                case 3: printf("请输入十进制数：");
                        scanf("%d",&i);
                        printf("转换为十六进制数为：");
                        while(i>0)
                        {
                                j=i%16;
                                Push(S,j);
                                i=i/16;
                        }
                        show(S);
                        break;
                }
                return 0;
}

在进行十六进制转换的时候，10-15对应A-F，所有在遍历输出的时候需要做一些调整，调整方式如下

int i=S->top;
while(i>=0)
{
    if(S->data[i]>9)
    {
        printf("%c ",'A'+S->data[i]-10);
    }
    else
    {
        printf("%d ",S->data[i]);
    }
    i--;
}

当S->data的值等于10，就输出字符‘A’，S->data的值每增加1，就让字符'A'加上S->data的增值(也就是S->data-10)，利用字符串以及askii码的规律使其增加，从而输出十六进制对应的字母。

.c文件

#include<stdio.h>
#include<stdlib.h>
#include"a.h"

SqStack *stack_create()
{
        SqStack *S=(SqStack*)malloc(sizeof(SqStack));
        if(NULL == S)
        {
                printf("创建失败!\n");
                return NULL;
        }
        S->top=-1;
        printf("创建成功!\n");
        return S;
}
//判满
int Full(SqStack *S)
{
        if(S->top == MAX-1)
        {
                return 1;
        }
        else
        {
                return 0;
        }
}
//判空
int Empty(SqStack *S)
{
        if(S->top==-1)
        {
                return 1;
        }
        else
        {
                return 0;
        }
}
//进栈
int Push(SqStack *S,datatype e)
{
        if(Full(S))
        {
                printf("栈满！\n");
                return -1;
        }
        else
        {
                S->top++;
                S->data[S->top]=e;
        //      printf("入栈成功! \n");
                return 0;
        }
}
//出栈
int Pop(SqStack *S)
{
        if(NULL == S || Empty(S))
        {
                printf("出栈失败!\n");
                return -1;
        }
        printf("%d ",S->data[S->top]);
        S->top--;
        return 0;
}
//遍历
void show(SqStack *S)
{
        if(NULL == S || Empty(S))
        {
                printf("遍历失败!\n");
                return;
        }
        int i=S->top;
        while(i>=0)
        {
                if(S->data[i]>9)
                {
                        printf("%c ",'A'+S->data[i]-10);
                }
                else
                {
                        printf("%d ",S->data[i]);
                }
                i--;
        }
        printf("\n");
}
//销毁
void destroy(SqStack *S)
{
    if(NULL==S)
    {
        printf("释放失败\n");
    return;
    }
    free(S);
    S = NULL;
    printf("释放成功\n");
}

.h文件

#ifndef __E__
#define __E__

#define MAX 10

typedef int datatype;

typedef struct
{
        datatype data[MAX];
        int top;
}SqStack;

//create
SqStack *stack_create();
//empty
int Empty(SqStack *S);
//full
int Full(SqStack *S);
//push
int Push(SqStack *S,datatype e);
//pop
int Pop(SqStack *S);
//show
void show(SqStack *S);
//destroy
void destroy(SqStack *S);

#endif
~

 

yayyy4
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构 Day 3 主函数
06-12
main.c
数据结构 栈与队列
07-23 295
1. 采用链式存储实现栈的初始化、入栈、出栈操作。 存储结构： typedef int Status; typedef int SElemType; typedef struct SNode{ SElemType data; struct SNode *next; }SNode,*LinkStack; 程序： #include<iostream> using namespace ...
#数据结构#第三章：栈
vircorns的博客
09-21 2053
第二章：链表判断题 判断题 1-1.通过对堆栈S操作：Push(S,1), Push(S,2), Pop(S), Push(S,3), Pop(S), Pop(S)。输出的序列为：123。 F 1-2.若一个栈的输入序列为1，2，3，…，N，输出序列的第一个元素是i，则第j个输出元素是j−i−1。 (2分) F 1-3.若一个栈的输入序列为{1, 2, 3, 4, 5}，则不可能得到{3,...
实现顺序栈的初始化、入栈和出栈操作
热门推荐
ancientear的博客
05-04 4万+
编写一个程序实现顺序栈的初始化、入栈和出栈操作； //方案1 # include&amp;amp;lt;stdlib.h&amp;amp;gt; #include&amp;amp;lt;iostream&amp;amp;gt; using namespace std; # define STACK_INIT_SIZE 20 # define stackincrement 20/*不是动态分配存储空间，所以需要定义一个增量*/ typedef int
数据结构（五）——栈
qq_34528825的博客
11-18 267
栈的定义： 栈是限定仅在表位进行插入和删除操作的线性表。允许插入和删除的一端称为栈顶，另一端为栈底，不含任何数据元素的栈称为空栈。 栈的插入操作，叫做进栈，也叫做压栈，入栈，打个比方，像子弹如弹夹；栈的删除操作，叫做出栈，有的叫做弹栈，如同子弹出弹夹。示意图如下： 栈的顺序存储结构及实现： typedef struct { int data[MAXSIZE];
Chapter 4(栈与队列)
weixin_30892763的博客
07-17 94
1.栈的顺序存储结构//*********************************stack_array.h************************************ #ifndef STACK_ARRAY_H #define STACK_ARRAY_H #define MAXSIZE 1000 #include <stdio.h> #include...
数据结构 Day 3 预处理
06-12
head.h
数据结构 Day 3 功能函数
06-12
function.c
12.20 day1 数据结构
12-20
12.20 day1 数据结构
【数据结构】Day51
08-03
【数据结构】Day51和Day52的内容主要聚焦在数据结构中的树，特别是二叉树和表达式树。在这一部分的学习中，我们将深入理解这两种重要的数据结构及其应用。 4.2 叉树（Binary Trees） 二叉树是一种特殊类型的树，...
数据结构栈的创建以及出栈入栈功能代码7.21(c语言)
qq_60071225的博客
07-21 1797
数据结构创建栈、入栈、出栈、销毁栈功能实现代码
栈的基本操作
nullcanon的博客
09-05 388
包括构造空栈，销毁栈，把栈置空，检验栈是否为空，求栈的长度，取出栈顶元素，入栈，出栈
数据结构 栈 基础知识，及其简单应用
qq_53120038的博客
04-19 165
栈 //定义栈的成员 base是栈的底部 top是栈的顶部 stacksize是栈的空间 typedef struct stack { int* base; int* top; int stacksize; }sqstack; //创建一个栈 给空间，并进行相应的赋值 int initsqstack(sqstack& s) { s.base = new int[100]; if (s.base == 0) exit(overflow); s.top = s.base; s.stack
动态顺序栈的C语言实现
沐尔还吃
07-12 608
#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;#include &lt;malloc.h&gt;#define STACK_INIT_SIZE 100#define STACK_INCREMENT 10#define FALSE -1#define TRUE 1#define OK 2typedef struct{    int *base;  ...
C语言实现数据结构——栈（Stack）
weixin_51408717的博客
10-14 1万+
C语言数据结构之堆栈（Stack）栈的定义及原理概述图解优缺点栈的主要操作实现代码1. Status.h文件代码2. SqStack.h文件代码3. SqStack.c函数实现文件代码4. SqStack_main功能测试主函数代码 栈的定义及原理 概述 栈是一个先进后出的数据结构，类似于一个弹匣，栈中的数据就相当于弹匣中的子弹 在栈中进行操作的时候 只预留了一个端口进行数据的存取操作，即无论是向数据结构中添加新的数据还是将其中的已有数据删除，只能从栈的一段进行操作 图解 数据入栈示意图 先将数据压
2020-4-21-栈
小小书童
04-21 119
一：基本概率 栈(stack)：只允许在一端进行删除和插入的线性表 栈顶(Top) :允许删除和插入的那一端 栈底(Bottom)：固定的，不允许操作的那一端 空栈：没有任何元素的空表 栈的操作： 1 ：初始化操作 2 ：判断栈是不是空栈 3 ：压栈操作 4 ：出栈操作 5 ：求栈长操作 6 ：取栈顶元素 7：输出栈 二 ：C++代码实现（顺序栈和链...
c语言（7.23）
fhgfyrsg的博客
07-23 425
【代码】c语言（7.23）
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 776
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构之判断完全二叉树详解与示例（C，C++）
最新发布
qq_35320456的博客
07-23 391
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构C语言day
08-27
- *1* *2* *3* [数据结构-C语言代码 day 5-多项式加法](https://blog.csdn.net/yydslty/article/details/124612624)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值