精华内容
下载资源
问答
  • 顺序表的初始化 出栈 入栈 运行截图: 源代码: #include<stdio.h> #include<stdlib.h> #define MAXSIZE 100 #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int SElemType; typedef int ...

    顺序表的初始化 出栈 入栈

    运行截图:
    在这里插入图片描述
    源代码:

    #include<stdio.h>
    #include<stdlib.h>
    #define MAXSIZE 100
    #define OK 1
    #define ERROR 0
    #define OVERFLOW -2
    typedef int SElemType;
    typedef int Status;
    //顺序栈的表示
    typedef struct
    {
    	SElemType *base;
    	SElemType *top;
    	int stacksize;
    }SqStack;
    //顺序栈的初始化
    Status InitStack(SqStack &S)
    {
    	S.base=new SElemType[MAXSIZE];
    	if(!S.base)
    		return OVERFLOW;
    	S.top=S.base;
    	S.stacksize=MAXSIZE;
    	return OK;
    }
    //顺序栈入栈
    Status Push(SqStack &S,SElemType e)
    {
    	if(S.top-S.base==S.stacksize )//栈满
    		return ERROR;
    	*S.top++=e;//*S.top=e;S.top++;
    	return OK;
    }
    //顺序栈出栈
    Status Pop(SqStack &S,SElemType &e)
    {
    	if(S.top==S.base)//栈空
    		return ERROR;
    	e=*--S.top;//--S.top;e=*S.top
    	return OK;
    }
    //主函数
    int main()
    {
    	SqStack S;
    	InitStack(S);
    	int e,n=0,i;
    	printf("请说明要输入多少个元素\n");
    	scanf("%d",&i);
    	printf("请输入要输入的元素:\n");
    	while(1)
    	{
    		scanf("%d",&e);
    		Push(S,e);
    		n++;
    		if(n==i) break;
    	}
    	printf("出栈:\n");
    	while(S.top!=S.base)
    	{
    		Pop(S,e);
    		printf("%   d",e);
    	}
    	printf("\n");
    	printf("出栈完毕!\n");
    	return 0;
    }
    
    
    展开全文
  • 顺序表的初始化、插入、删除

    千次阅读 多人点赞 2016-06-04 11:21:10
    顺序表的初始化、插入、删除

    昨天晚上做了中移动苏州软件公司的暑期实习岗的笔试题,感觉备受打击,尤其是自以为是的数据结构题(从快排、归并排序、堆排序中选一种实现),碎决定再次学习数据结构一次,并将重要的数据结构用程序实现。
    这里先实现的是顺序表的初始化,插入和删除操作。

    #include<iostream>
    using namespace std;
    // - - - - 线性表的动态分配顺序存储结构 - - - - 
    #define LIST_INIT_SIZE 100  //存储空间的初始分配量
    #define INCREMENT 10        //存储空间的分配增量
    #define ElemType char
    
    typedef struct{
        //线性表的存储结构
        ElemType *elem;   //存储空间基地址
        int length;       //当前长度
        int listsize;     //当前分配的存储容量
    }SqList;
    
    //线性表的初始化
    int InitList_Sq(SqList *L){
        L->elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));//动态分配存储空间
        if (L->elem == NULL)
            return 0;
        L->length = 0;
        L->listsize = LIST_INIT_SIZE;
        return 0;
    }
    
    int ListInsert_Sq(SqList *L, int i, ElemType e){
        //在顺序表L的第i个位置之前插入元素e
        if (i<1 || i>L->length + 1)
            cout << "i值不合法" << endl;
        if (L->length >= L->listsize){    //当前空间已满,增加分配
            ElemType *newbase = (ElemType *)realloc(L->elem, (L->listsize + INCREMENT)*sizeof(ElemType));
            if (newbase = NULL){
                cout << "分配失败" << endl;
                return 0;
            }
            L->elem = newbase;      //新基地址
            L->listsize += INCREMENT;//增加存储容量
        }
        ElemType *q = &(L->elem[i - 1]);//q为插入位置
        for (ElemType *p = &(L->elem[L->length - 1]); p >= q; --p)
            *(p + 1) = *p;    //插入位置及其后的元素右移
    
        *q = e; //插入元素
        +L->length; //表长加1
        return 1;
    }
    
    int ListDelete_Sq(SqList *L, int i, ElemType *e){
        //顺序表中删除第i个元素,并用e返回其值
        if (i<1 || i>L->length + 1){          //i的合法值为1length
            cout << "i值不合法" << endl;
            return 0;
        }
        ElemType *p = &(L->elem[i - 1]);  //p为被删除的元素的位置
        *e = *p; //把p的值赋给e
        ElemType *q = L->elem + L->length - 1;//表尾元素的位置
        for (++p; p <= q; ++p)
            *(p - 1) = *p;
        --L->length;
        return 0;
    }
    
    int main(){
        SqList L;
        InitList_Sq(&L);
        for (int i = 0; i < 22; i++)
            ListInsert_Sq(&L, 1, 'a' + i);
        ElemType e;
        ListDelete_Sq(&L, 10, &e);
        cout << "删除的元素是" << e;
    
        for (int j = 0; j < L.length; j++)
            cout << L.elem[j];
        return 0;
    }
    展开全文
  • 数据结构 C语言描述 第三版 顺序表的初始化

    数据结构C语言的描述第三版 -顺序表的初始化

    顺序表

    #include <stdio.h>
    #include <stdlib.h>
    typedef int DataType;//自定义数据类型
    typedef struct student//定义student表
    {
      int MAX;//最大元素个数
       DataType n;//其中的元素
       int length; //元素个数
    }stu1;//表名
    typedef struct student *list;//用typedef 给顺序表一个新的别名
    
    list_createNULLlist(int m)//分配空间给顺序表
    {
        list plist=(list)malloc(sizeof(struct student));
        if(plist!=NULL)//如果为头指针为空  开辟空间
        {
             plist->n=(DataType*)malloc(sizeof(DataType)*m);
        if(plist->n)//如果表内元素为空
        {
    
            plist->MAX=m;//表的最大的元素的个数
            plist->n=0;//表头的值设置为0
            return plist;//返回表的值
        }
        else free(plist);//释放表的内存
        }
        printf("out of space!!\n");//清空
        return NULL;//返回空值
    }//顺序表的初始化
    
    int main()
    {
        int m;//定义顺序表的需要分配内存的大小
        printf("please input size of the list :");
        scanf("%d",&m);//输入元素的最大个数
        printf("%d\n",list_createNULLlist(m));//打印表
        return 0;
    }
    
    
    
    
    
    
    展开全文
  • 1、 init_listinit_list表示顺序表的初始化 2、 2、 prin_list表示顺序表的打印 3、 get_list表示读取顺序表中的元素 4、 search_list表示输入元素后,返回元素在表中的位置 5、 search_list1输入位置,返回相应的...
  • #include<stdlib.h> #include <iostream> using namespace std; #define MAX_SIZE 100 typedef struct { int* elems;//顺序表地址 ...//顺序表的初始化 bool listAppend(SqList& L, int e
    #include<stdlib.h>
    #include <iostream>
    
    using namespace std;
    #define MAX_SIZE 100
    
    typedef struct {
    	int* elems;//顺序表地址
    	int length;//顺序表长度
    	int size;//顺序表的空间
    }SqList;
    
    bool InitList(SqList& L);//顺序表的初始化
    bool listAppend(SqList& L, int e);//顺序表的增加
    bool listIsert(SqList& L, int i, int e);//顺序表的插入
    bool listDelete(SqList& L, int i);//顺序表删除元素
    void destroyList(SqList& L);//顺序表摧毁
    void menuShow();
    int menuChoise();
    
    void listPrint(SqList& L) {
    	cout << "顺序表存储空间size:" << L.size << ",已保存元素的个数length:" << L.length << endl;
    	for (int i = 0; i < L.length; i++) {
    		cout << L.elems[i] << " ";
    	}
    	cout << endl;
    }
    
    int main() {
    	SqList list;
    	int i, e;
    	int count = 0;
    	
    	while (1) {
    		menuShow();
    		int n = menuChoise();
    		switch (n) {
    		case 1:
    			cout << "顺序表初始化....!" << endl;
    			if (InitList(list)) {
    				cout << "顺序表初始化成功!" << endl;
    			}
    			listPrint(list);
    			break;
    
    		case 2:
    			cout << "请输入要添加的元素个数:";
    			std::cin >> count;
    			for (int i = 0; i < count; i++) {
    				cout << "\n请输入要添加的元素e:";
    				std::cin >> e;
    				if (listAppend(list, e)) {
    					cout << "添加成功!" << endl;
    				}
    				else {
    					cout << "添加失败!" << endl;
    				}
    			}
    			listPrint(list);
    			break;
    
    		case 3:             //	3.插入元素
    			cout << "请输入要插入的位置和要插入的元素";
    			std::cin >> i >> e;
    			if (listIsert(list, i, e)) {
    				cout << "插入成功!" << endl;
    			}
    			else {
    				cout << "插入失败!" << endl;
    			}
    			listPrint(list);
    			break;
    
    		case 4:         //4.删除元素
    			cout << "请输入要删除元素的位置:";
    			std::cin >> i;
    			if (listDelete(list, i)) {
    				cout << "删除成功!" << endl;
    			}
    			else {
    				cout << "删除失败!" << endl;
    			}
    			listPrint(list);
    			break;
    
    		case 5:            //5.销毁
    			destroyList(list);
    			break;
    		}
    		system("pause");
    	}
    }
    
    bool InitList(SqList& L) {
    	L.elems = new int[MAX_SIZE];
    	if (!L.elems) return false;
    	L.length = 0;
    	L.size = MAX_SIZE;
    	return true;
    }
    
    //顺序表元素的增加
    bool listAppend(SqList& L, int e)
    {
    	if (L.length>=L.size) return false;//储存空间已满
    	L.elems[L.length] = e;
    	L.length++;
    	return true;
    }
    
    bool listIsert(SqList& L, int i, int e)
    {
    	if(i<1||i>L.length+1) return false;
    	if (L.length >= MAX_SIZE) return false;
    	for (int j = L.length - 1; j >= i-1; j--) {
    		L.elems[j + 1] = L.elems[j];
    	}
    	L.elems[i-1] = e;
    	L.length++;
    	return true;
    }
    
    bool listDelete(SqList& L, int i)
    {
    	if(i<0||i>=L.length) return false;
    	if (i == L.length - 1) {
    		L.length--;
    		return true;
    	}
    	for (int j = i; j < L.length - 1; j++) {
    		L.elems[j] = L.elems[j + 1];
    	}
    	L.length--;
    	cout << "删除成功" << endl;
    	return true;
    }
    
    void destroyList(SqList& L)
    {
    	if (L.elems)  delete []L.elems;
    	L.length = 0;
    	L.size = 0;
    }
    
    void menuShow()
    {
    	system("cls");
    	cout << "1.顺序表的初始化" << endl;
    	cout << "2.顺序表的添加" << endl;
    	cout << "3.顺序表的插入" << endl;
    	cout << "4.顺序表的删除" << endl;
    	cout << "5.顺序表的销毁" << endl;
    }
    
    int menuChoise(void) {
    	int n = 0;
    
    	while (1) {
    		cin >> n;
    		if (cin.fail()) {
    			cin.clear();
    			cin.sync();
    			cout << "无效输入. 请重新输入." << endl;
    			system("pause");
    		}
    		else {
    			break;
    		}
    	}
    	return n;
    }
    
    

    这个是进行程序的初始化
    初始化成功

    顺序表的销毁
    顺序表元素的添加
    ![顺序表的]删除](https://img-blog.csdnimg.cn/20210323080916386.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2Mzc2ODM0,size_16,color_FFFFFF,t_70)
    顺序表元素的插入

    展开全文
  • 静态顺序表的初始化以及插入删除操作 1. 首先是静态顺序表结构体的编写 typedef struct { int data[MaxSize]; int length; }Sqlist; 2. 初始化 void InitList(Sqlist *L) { L->length = 0; } 3....
  • 创建有若干个元素(可以是整型数值)的顺序表,实现对顺序表的初始化,对已建立的顺序表插入操作、删除操作、遍历输出顺序表。 要求各个操作均以函数的形式实现,在主函数中调用各个函数实现以下操作: ( 1...
  • 数据结构-顺序表的初始化

    万次阅读 多人点赞 2014-09-24 17:12:44
    //顺序表的初始化 #include #include // #define OK 1; #define OVERFLOW -2 #define MAXSIZE 100//顺序表可能达到的最大长度  typedef int Status;//Status是函数的类型,其值是函数结果状态代码,如OK等 typedef...
  • 补上之前动态顺序表的初始化,实现语言依旧是C,注释都已经标注在代码中 /* 陈卓阳 2020年5月14日20:03:57 顺序表的基本操作(初始化,扩容,插入,删除,查找) */ #include <stdio.h> #include <stdlib.h&...
  • C语言实现顺序表的初始化、增删查改基本功能引言定义原理实现过程及结果代码运行结果总结 引言 定义 顺序表是线性表的顺序存储结构。形如A_1 、A_2…….A_n的表,这个表的大小为N;并且,我们称大小为0的表为空表。 ...
  • 顺序表的初始化、计算表长度、插入节点、追加节点 写的时候不能急。 #include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #define maxlen 100000 using namespace ...
  • 完成顺序表的初始化、插入、删除、输出、查找等操作直接上代码,要注意理解何时用“&”,何时不用。代码里有详解。 #include <stdio.h> #define MaxSize 10 //定义最大长度 typedef struct { int data...
  • 顺序存储结构 顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻...3.顺序表的长度,也就是表中存储数据元素
  • C语言顺序表的初始化,添加,删除,打印。体现和链表添加,删除的区别。
  • C语言顺序表的初始化

    2021-02-24 18:26:58
    没学过C语言,将就着看着吧! #include<stdio.h> #include<...// typedef 关键字来定义自己习惯数据类型名称 typedef int Status ; typedef int ElemType ; // struct 结构体 typedef struct
  • 线性顺序表的初始化,创建,打印。 数据结构 #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #define MAXNUM 100 #define OVERFLOW 0 typedef int ...
  • /* time:2018/9/20 function:  顺序表的初始化  b1赋值给顺序表 summarize:  1.结构体声明2种  #1#   typedef struct  {  char no[20];//图书ISBN  char name[50];...
  • //初始化 Status InitList(SqStack &S) { S.base = new SElemType[MAXSIZE]; S.top = S.base; S.stacksize = MAXSIZE; return OK; } //入栈 Status Push(SqStack &S,SElemType e) { if(S.top-S.base == S....
  • //初始化 void InitList(SqList*&L) { L = (SqList *)malloc(sizeof(SqList)); int length = 0; } //创建 Status CreateList(SqList& L) { int n; printf("输入插入个数\n"); scanf_s("%d", &n); ...
  • #include <stdio.h> #include <stdlib.h>... //顺序表的当前长度 }SqList; //顺序表的类型定义 void InitList(SqList *p){ int i; for (i = 0; i < MaxSize; i++) { p->data
  • 目录 1、顺序表初始化 2、顺序表插入元素 3、顺序表删除元素 4、顺序表查找元素 5、顺序表合并 ...线性表的顺序表示指的是用一组地址连续的存储... 并且顺序表的存储空间需要预先分配 1、方法简单,...
  • //初始化 void InitList(SqList*&L) { L = (SqList *)malloc(sizeof(SqList)); int length = 0; } //创建 Status CreateList(SqList& L) { int n; printf("输入插入个数\n"); scanf_s("%d", &n); ...
  • 数据结构—顺序表的初始化

    千次阅读 2018-08-18 17:19:32
    #include <stdio.h> #include <stdlib.h> ... #define LIST_INIT_SIZE 10// 线性表存储空间的初始分配量 typedef int Status; //Status是函数数据类型 ,其值是函数结果状态,如OK ...
  • ![图片说明]...蓝色圈内,当我使用”&“号时,第一个L说表达式必须是可修改左值, 当我使用指针符时,两个L都说表达式必须包含类类型是怎么回事,求大佬指教
  • list)//顺序表的初始化 { int i; while (1) { printf( "输入元素个数(0-10000 ):" ); scanf("%d", list.length); if (list.length >= 0 && list.length <= max) /*本人百度搜索...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,944
精华内容 1,577
关键字:

顺序表的初始化