数据结构子系统

最新推荐文章于 2024-06-08 14:48:20 发布
最新推荐文章于 2024-06-08 14:48:20 发布
阅读量532 收藏 2
点赞数
文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67828940/article/details/128390028
版权

这个子系统的switch嵌套怎么改啊 为什么建完表就直接到栈的子系统了   有大佬可以教我一下吗

#include<stdio.h>
#include<windows.h>
#define OK 1;
#define ERROR 0;
#define OVERFLOW -2;
#define MaxSize 10

typedef int ElemType;
typedef int Status;
// 线性表子系统实验
typedef struct 
{
    ElemType *elem;
    int length;
    int size;
}SqList;


//7初始化 
InitList(SqList &L)
{
    L.elem = (ElemType*)malloc(100*sizeof(ElemType));
    if(!L.elem)
    exit(-2);
    L.length=0;
    L.size=100;

}

//1建表 
Create(SqList &L,ElemType a[],int n)
{
    for(int i=0;i<n;i++)
    {
        L.elem[i]=a[i];
        L.length++;
    }
    printf("建表完成\n");
    return OK; 
}
//2插入
Insert(SqList &L,ElemType e,int i)//在位置i插入元素e 
{
    int j;
    if(i<1 ||i> L.length+1)//i的位置不合法
    {
        return ERROR;
    }    
    if(L.length >=L.size)// 表L的空间已满
    {
        ElemType *newbase=(ElemType *)realloc(L.elem,(L.size+10)*sizeof(ElemType)); //开辟新空间 
        if(!newbase)
        {
            exit(-2);
        }
        L.elem=newbase;
        L.size+=10;
     } 
     ElemType *q = &(L.elem[i-1]);//将表中第i个元素的地址传给指针q 
     for(ElemType *p=&L.elem[L.length-1];p>=q;--p)
     {
         *(p+1)=*p;
     }
     *q=e;
     ++L.length;
    printf("插入完成\n");
    printf("插入后的表为：\n");    
    for(int j=0 ;j<L.length; j++)
    {
        printf("%d",L.elem[j]);
    }
     return OK;             
 }
 
 
 //3删除
Delete(SqList &L)//删除i位置的元素 
 {    
    int z;
    printf("请输入要删除元素的位置:\n");
    scanf("%d",&z);
     if(z<1 ||z>L.length)
     return ERROR;
    ElemType *p=&(L.elem[z-1]);
    ElemType *q=L.elem+L.length-1 ;
    for(p; p<q; p++)
    {
        *p=*(p+1);
    }
    --L.length;
    printf("删除完成\n");
    printf("删除后的表为：\n");    
    for(int j=0 ;j<L.length; j++)
    {
        printf("%d",L.elem[j]);
    }
    return OK;
  } 
 
//4显示
Output(SqList L)
{
    printf("线性表中的元素为：\n");
    for(int i=0 ;i<L.length; i++)
    {
        printf("%d",L.elem[i]);

    }    
    printf("\n");
    return OK;
 } 
 
typedef struct {  //定义线性表数据项结构 
    int key;
    int otherinfo;
}Elemtype;

typedef struct{
    int length;//顺序表长度
    Elemtype *R;//顺序表的动态建立，R用于之后动态建立一块连续的存储空间，是建立存储空间的基地址
}SeqList;

//初始化线性表 
bool InitList(SeqList &T)
{
    T.R=(Elemtype *)malloc(sizeof(Elemtype)*MaxSize);//动态分配内存 
    if(!T.R)//检查是否成功给线性表 T分配空间
    {
        printf("分配空间失败");
        return false; 
    } 
    T.length=0;
    return true;
 } 

//根据输入的元素建立线性表 
bool CreatList(SeqList &T)
{
    int n;
    printf("请输入您想建立的线性表中的元素个数：\n");
    scanf("%d",&n);
    printf("请依次输入元素:\n");
    for(int i=0;i<n;i++)
    {
        scanf("%d",&T.R[i].key);//赋值
        T.length++; 
    } 
    return true;
 } 

//1顺序查找
int search1(SeqList T,int key)
{
    for(int i=0;i<=T.length;i++)
    {
        if(T.R[i].key==key)
        {
        return i+1; 
        }
    }
    return 0;
 } 

//二分查找
int search2(SeqList T,int key,int low,int high)
{
    int mid=(low+high)/2;
    if(T.R[mid].key==key)
    {
    return key;
    }
    else if(T.R[mid].key<key)
    {
    search2(T,key,mid+1,high); 
    }
    else if(T.R[mid].key>key)
    {
    search2(T,key,low,mid-1);
    } 
 } 

//二叉排序树结点定义
typedef struct BSTNode{ 
    int data;
    struct BSTNode *left;
    struct BSTNode *right;
};
 
//二叉树结点创建 
BSTNode *CreateTreeNode(int x)
{
    BSTNode *p = (BSTNode *)malloc(sizeof(BSTNode));
    p->data = x;
    p->left = NULL;
    p->right = NULL;
    return p;
}

//二叉排序树的构造

void Creat(BSTNode *&root,int str[],int n)
{
    root=NULL; 
    for(int i=0;i<n;i++) 
    {
// Insert(root,str[i]);
    } 
 } 
 
void Show(int result,int key)

{
    if(result==0)
    {
    printf("没有找到该元素\n");
    }
    else
    {
    printf("找到元素%d，在第%d位\n",key,result);
    }
}

void menu()
{
    printf("\t\t\t\t数据结构子系统  \n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t*    1  线     性     表     *\n");
    printf("\t\t\t*    2         栈            *\n");
    printf("\t\t\t*    3  队            列     *\n");
    printf("\t\t\t*    4  二     叉     树     *\n");
    printf("\t\t\t*    5         图            *\n");
    printf("\t\t\t*    6  查            找     *\n");
    printf("\t\t\t*    7  排            序     *\n");
    printf("\t\t\t*    0  退            出     *\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t请输入菜单号(0-7):\n");

}

void menu_1()
{
    printf("\t\t\t\t   线性表子系统\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t*    1  建            表     *\n");
    printf("\t\t\t*    2  插            入     *\n");
    printf("\t\t\t*    3  删            除     *\n");
    printf("\t\t\t*    4  显            示     *\n");
    printf("\t\t\t*    0  返            回     *\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t请输入菜单号(0-4):\n");        
 } 
 
void menu_2()
{
    printf("\t\t\t\t   栈子系统\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t*    1  进            栈     *\n");
    printf("\t\t\t*    2  出            栈     *\n");
    printf("\t\t\t*    3  显            示     *\n");
    printf("\t\t\t*    4  数   制  转   换     *\n");
    printf("\t\t\t*    5  逆   波  兰   式     *\n");
    printf("\t\t\t*    6         图            *\n");
    printf("\t\t\t*    0  返            回     *\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t请输入菜单号(0-6):\n");    
    
}
void menu_3()
{
    printf("\t\t\t\t   队列子系统\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t*    1  进            队     *\n");
    printf("\t\t\t*    2  出            队     *\n");
    printf("\t\t\t*    3  读     队     头     *\n");
    printf("\t\t\t*    4  显            示     *\n");
    printf("\t\t\t*    5  双     向     队     *\n");
    printf("\t\t\t*    0  返            回     *\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t请输入菜单号(0-5):\n");    
 } 
void menu_4()
{
    printf("\t\t\t\t   树子系统\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t*    1  建  二   叉   树     *\n");
    printf("\t\t\t*    2  先  序   遍   历     *\n");
    printf("\t\t\t*    3  中  序   遍   历     *\n");
    printf("\t\t\t*    4  后  序   遍   历     *\n");
    printf("\t\t\t*    5  层  次   遍   历     *\n");
    printf("\t\t\t*    6  叶  结   点   数     *\n");
    printf("\t\t\t*    7  总  结   点   数     *\n");
    printf("\t\t\t*    8  树  的   深   度     *\n");
    printf("\t\t\t*    0  返            回     *\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t请输入菜单号(0-8):\n");    
 }
void menu_5()
{
    printf("\t\t\t\t   图子系统\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t*    1  建 立 邻 接 矩 阵     *\n");
    printf("\t\t\t*    2  深 度 优 先 遍 历     *\n");
    printf("\t\t\t*    3  广 度 优 先 遍 历     *\n");
    printf("\t\t\t*    0  返            回     *\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t请输入菜单号(0-3):\n");    
 } 
void menu_6()
{
    printf("\t\t\t\t   查找子系统\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t*    1  顺  序   查   找     *\n");
    printf("\t\t\t*    2  二  分   查   找     *\n");
    printf("\t\t\t*    3  二  叉  排 序 树     *\n");
    printf("\t\t\t*    4  建  排   序   树     *\n");
    printf("\t\t\t*    5  查  找   结   点     *\n");
    printf("\t\t\t*    6  插  入   结   点     *\n");
    printf("\t\t\t*    7  删  除   结   点     *\n");
    printf("\t\t\t*    8  中  序   输   出     *\n");
    printf("\t\t\t*    0  返            回     *\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t请输入菜单号(0-8):\n");    
 }  
void menu_7()
{
    printf("\t\t\t\t   排序子系统\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t*    1  数  据   输   入     *\n");
    printf("\t\t\t*    2  插  入   排   序     *\n");
    printf("\t\t\t*    3  希  尔   排   序     *\n");
    printf("\t\t\t*    4  冒  泡   排   序     *\n");
    printf("\t\t\t*    5  快  速   排   序     *\n");
    printf("\t\t\t*    6  选  择   排   序     *\n");
    printf("\t\t\t*    7  归  并   排   序     *\n");
    printf("\t\t\t*    8  堆     排     序    *\n");
    printf("\t\t\t*    0  返            回     *\n");
    printf("\t\t\t******************************\n");
    printf("\t\t\t请输入菜单号(0-8):\n");    
 }   
int main()
{
    int c,c1,c2,c3,c4,c5,c6,c7;
    SeqList T; 
    SqList sql; 
    BSTNode *root;
    int key,result; 
    menu();
//    while (1)
//    {
        scanf("%d",&c);
        system("cls");
        InitList(sql);
        switch(c){
        while(1)
          {            
            case 1:
                {
                    menu_1();
                    scanf("%d",&c1);    
                    system("cls");
                    switch (c1)
                    {
                        case 1:
                            {
                            ElemType a[]={1,2,3,4,5,6,7,8};    
                            Create(sql,a,8);
                            break;                                
                            }
                        case 2:
                            {
                            ElemType x ;
                            int y;
                            printf("请输入要插入的元素及其位置(中间用空格隔开):\n");
                            scanf("%d%d",&x,&y);
                            Insert(sql , x , y);                                
                            }break;
                        case 3:
                            {
                            Delete(sql );        
                            }break;
                        case 4:
                            {
                            Output(sql);        
                            }break;
                        case 0:
                            {
                                
                            }break;
                    }
/*                    if(c1==1)
                    {
                        ElemType a[]={1,2,3,4,5,6,7,8};    
                        Create(sql,a,8);
                        break; 
                        }
                    else if(c1==2)
                    {
                        ElemType x ;
                        int y;
                        printf("请输入要插入的元素及其位置(中间用空格隔开):\n");
                        scanf("%d%d",&x,&y);
                        Insert(sql , x , y);                        
                        }
                    else if(c1==3)
                    {
                        Delete(sql );
                        }
                    else if(c1==4)
                    {
                        Output(sql);
                        }
                    else if(c1==0);
                    {
                    //    menu();
                    
                        }
                    break;
                    }    */
//                }
            case 2:
                {
                menu_2();
                scanf("%d",&c2);
                system("cls");
                if(c2==0);
                {
                menu();    
                }    
                break;    
                }
            case 3:
                {
                    menu_1();
                    scanf("%d",&c3);
                    system("cls");
                    if(c3==0);
                    {
                    menu();    
                    }
                    break;
                }
            case 4:
                {
                    menu_4();
                    scanf("%d",&c4);
                    system("cls");
                    if(c4==0);
                    {
                    menu();    
                    }
                    break;
                }
            case 5:
                {
                    menu_5();
                    scanf("%d",&c5);
                    system("cls");
                    if(c5==0);
                    {
                    menu();    
                    }
                    break;
                }
            case 6:
                {
                    menu_6();
                    scanf("%d",&c6);
                    system("cls");
                    if(c6=1)
                    {
                    if(InitList(T)&&CreatList(T))
                    {
                        printf("创建成功\n");
                    }                        
                    printf("请输入要查找的关键字:\n");
                    scanf("%d",&key);
                    result=search1(T,key);
                    Show(result,key);
                    system("cls");
                     } 
                    if(c6=2)
                    {
                    if(InitList(T)&&CreatList(T))
                    {
                        printf("创建成功\n");
                    }                        
                    printf("请输入要查找的关键字:\n");
                    scanf("%d",&key);
                    result=search2( T, key, 1, T.length);
                    Show(result,key);                        
                    }
                    if(c6==0);
                    {
                    menu();    
                    }
                    break;
                }
            case 7:
                {
                    menu_7();    
                    scanf("%d",&c7);
                    system("cls");
                    if(c7==0);
                    {
                    menu();    
                    }
                    break;
                }
            case 0:
                {
                    printf("已退出系统！\n");
                }
                break;                
            }
    
     }
    return 0;
    }
}

m0_67828940
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
划分子系统的三种必用策略
软件设计专栏
02-27 5431
分层的细化： 分层最常用的架构模式，在架构设计初期，100%的系统都可以用分层架构，就算随着设计的深入而采用了其他的架构模式也未必和分层架构矛盾。于是，架构师最熟知、最自然的划分模式就是分层的细化。 分区的引入： 为了支持迭代开发，逻辑架构设计中必须引入分区，分区是一个单元，其粒度比层要小。一旦架构师针对每个层进行了分区设计，“深度优先”式的迭代开发就非常自然。 机制的提取： 机制是指预
数据结构与C语言实现（十二）——排序合集
Sonihr的犀牛园
10-27 193
#include #include #define MAXSIZE 200 #define MAXDATA 65535 int arry[MAXSIZE]; struct HNode { int data[MAXSIZE + 1]; int size; int num; }; typedef struct HNode* Heap; void Print() { for (int
数据结构（C语言）-图子系统（实验）
czh2637750821的博客
03-16 3409
图子系统一、实验目的二、实验内容三、实验步骤四、参考程序5、运行结果 一、实验目的 （1)掌握图邻接矩阵的存储方法。 （2)掌握图的深度优先遍历的基本思想。 （3)掌握图的广度优先遍历的基本思想。 （4）掌握普利姆算法与克鲁斯卡尔算法 （5）掌握利用迪杰斯特拉算法求最短路径 二、实验内容 （1）编写为从键盘输入的数据建立邻接矩阵存储 （2）编写图的深度优先遍历算法 （3）编写图的广度优先遍历算法 （4）编写普利姆算法与克鲁斯卡尔算法 （5）编写迪杰斯特拉算法求最短路径 三、实验步骤 （1）输入并调试程序 （
数据结构，栈子系统
最新发布
2402_82406812的博客
06-08 153
完成栈的进栈，出栈，显示，数制转换，逆波兰式，栈的子系统
数据结构课程设计源码 图子系统
03-21
数据结构课程设计源码 图子系统 详细注释+图形界面操作 简单易操作
图子系统
05-13 1029
图子系统 1.实验目的 （1）掌握图邻接矩阵的存储方法。 （2）掌握图深度优先遍历的基本思想。 （3）掌握图广度优先遍历的基本思想。 2.实验内容 （1）编写按键盘输入的数据建立图的邻接矩阵存储。 （2）编写图的深度优先遍历函数。 （3）编写图的广度优先遍历函数。 （4）设计一个选择式菜单如下： 图 ...
数据结构——查找
weixin_53603519的博客
08-27 103
查找基本概念、线性结构查找：顺序查找/折半查找、树形结构查找：二叉排序树、AVL、B树、散列结构，以及各查找结构的ASL
数据结构：栈子系统.docx
07-11
数据结构中的栈是一种重要的抽象数据类型，它遵循“后进先出”（LIFO, Last In First Out）的原则。在本题中，我们讨论的是一个栈子系统，它包括了多个与栈操作相关的功能，如进栈、出栈、显示栈内所有元素以及两个...
查找子系统数据结构课设.rar
07-03
在本课程设计中，我们将深入探讨“查找子系统”这一主题，它主要涉及计算机科学中的数据结构和算法。数据结构是计算机科学中的基石，它研究如何有效地存储、组织和处理数据，以便进行高效的检索和操作。C语言是一种...
数据结构演示系统
08-15
二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。常见的二叉树操作有插入、删除、查找等。二叉树类型还包括完全二叉树、满二叉树和平衡二叉树（如AVL树和红黑树）。这些...
【数据结构---排序】很详细的哦
yyzzzj0301的博客
10-03 853
本篇文章主要介绍数据结构中的几种排序算法~
2018.4数据结构实验报告的注意事项
04-21
实验一：线性表的顺序存储 实验二：线性表的链式存储 实验三：栈子系统 实验四：队列子系统 实验五：串子系统 实验六：二叉树子系统 实验七：图子系统 实验八：查找子系统
排序子系统 C语言版
12-14
这是一个我们数据结构课程设计做的排序子系统，当时我们学的是c语言，很适合于大学生作为课程设计之用，当然也可以做为毕业设计的参考，真心希望对你的课程设计有所帮助！！！
数据结构之队列（顺序队和链队）（C语言附完整代码）
m0_62795460的博客
04-12 5997
队列简称队，它是一种操作受限的线性表，其限制为仅允许在表的一端进行插入操作，而在表的另一端进行删除操作。把进行插入的一端称为队尾，把进行删除的一端称为队头或队首。向队列中插入新元素称为进队或入队，从队列中删除元素称为出队或离队。由于队列的插入和删除操作分别是在各自的一端进行的，每个元素必然按照进入的次序出队，所以又把队列称为先进先出表。采用顺序存储结构的队列称为顺序队声明顺序队//存放队中元素 int front , rear;//队首和队尾指针 } SqQueue;采用链式存储结构的队列称为链队。
C语言数据结构，线性子列表系统的简单实现
qq_45728434的博客
10-02 1144
线性表子系统 主要内容：用结构体描述一个字符型的单链表；创建线性表；在线性表中插入元素、删除元素、显示线性表中所有元素；用if语句设计一个选择式菜单。 代码： #include<stdio.h> #include<stdlib.h> typedef struct node { char data; struct node *next; }NODE,*PNODE; PNODE head; int n; void create(){ char x; PNODE p,s; int
数据结构--栈
waj_aj的博客
11-02 365
栈 什么是栈——首先，栈是一种线性表，也就是说，栈元素具有线性关系，即前驱后继的关系。只不过他是一种特殊的线性表，定义中说在线性表的表尾可以进行插入和删除的操作。这里的表尾指的是栈顶，而不是栈低。 栈的插入叫做进栈，栈的删除叫做出栈。栈的进出要遵循“后进先出”的规则。 例如：这里有三个数字 1， 2， 3。依次进栈，会有哪些出栈结果呢？ 第一种：1、2、3依次进栈，3、2、1再依次出栈，这
数据结构---栈
爱上在路上
05-28 565
栈是一种后进先出的结构 通常有两种实现方式 1.静态数组或者动态数组的实现方式 2.链表的实现方式。 运用到栈的算法有哪些呢：括号匹配问题，中缀表达式转后缀表达式问题，迷宫路径搜索问题，非递归遍历问题，回溯搜索问题，递归转非递归。 1.栈的实现 1.1 java数组实现 /* * 用java数组实现简单的栈 * */ public class StackX { priv
数据结构-栈和队列
weixin_30636089的博客
06-19 2153
1．栈 1.1栈的定义 栈是一种特殊的线性表。其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行。如下所示： 结论：后进先出（Last In First Out），简称为LIFO线性表。 栈的基本运算有六种： 构造空栈：InitStack(S)、 判栈空: StackEmpty(S)、 判栈满：StackFull(S)、 ...
数据结构实验——查找实验
qq_65814357的博客
07-05 1863
一实验内容编写算法实现下列问题的求解。(1) 对下列数据表，分别采用二分查找算法实现查找，给出查找过程依次所比较的元素（的下标），并以二分查找的判定树来解释。 第一组测试数据：数据表为 (1,2,3,4,6,7,8,9,10,11,12,13,17,18,19,20,24,25,26,30,35,40,45,50,,100)查找的元素分别为： 2，8，20, 30，50，5，15，33，110 第二组数据：数据表为 (2,3,5,7,8,10,12,15,18,20,22,25,30,35,40,
c语言线性表子系统位置查找解析
03-22
线性表是一种常见的数据结构，它可以用来存储一组有序的数据。在 C 语言中，我们可以使用数组或者链表来实现线性表。如果要在线性表中查找某个元素的位置，可以使用顺序查找或者二分查找等算法。顺序查找的时间复杂度为 O(n)，而二分查找的时间复杂度为 O(log n)。在 C 语言中，我们可以使用指针来实现链表，从而实现线性表的操作。如果您需要更详细的解析，可以参考相关的教材或者网上的资料。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值