精华内容
下载资源
问答
  • 数据结构顺序表主函数
    2020-02-07 11:54:55

    数据结构–顺序表函数

    数据结构线性表–顺序表常用函数

    1、	创建有n个元素构成的线性表:
    
    Status CreatAscend(LinkList &L,int n)
    {
        int j;
        LinkList p,q,s;
        if(n<=0)
            return ERROR;
        InitList(L);
        cout<<"请输入元素个数:"<<n<<endl;
        s=(LinkList)malloc(sizeof(LNode)); // 第一个结点
        cin>>(&s->data);
        s->next=NULL;
        L->next=s;
        for(j=1; j<n; j++)
        {
            s=(LinkList)malloc(sizeof(LNode)); // 其余结点
            cin>>(&s->data);
            q=L;
            p=L->next;
    
            while(p&&p->data<s->data) // p没到表尾,且所指元素值小于新值
            {
                q=p;
                p=p->next; // 指针后移
            }
            s->next=q->next; // 元素插在q的后面
            q->next=s;
        }
        return OK;
    }
    
    2、	插入一个指定序列的表:
    
    Status ListInsert_Sq(SqList &L,int i,ElemType e){
        //在顺序线性表L中第i个位置之间插入新的元素e
        //i的合法值为1≤i≤listlenghth.Sq(L)+1
        if(i<1||i>L.length+1)
            return ERROR;
        if(l.length>=L.listsize)
        {
            newbase = (ElemType * )realloc(l.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
            L.elem = newbase;
            L.listsize += LISTINCREMENT;
        }
        q = &(L.elem[i-1]);
        for(p = &(L.elem[L.length-1]);p>=q;--p)
            *(p+1) = *p;
        *q = e;
        ++L.length;
        return OK;
    }  //ListInsert_Sq
    
    3、	删除一个指定序列的表:
    
    Status ListDelete_Sq(SqList &L,int i,ElemType e){
        //在顺序线性表L中删除第i个元素,并用e返回值
        //i的合法值为1≤i≤listlenghth.Sq(L)+1
        if(i<1||i>L.length+1)
            return ERROR;
        p = &(L.elem[i-1]);
        e = *p;
        q = l.elem+L.length-1;
        for(++p;p<=q;++p)*(p-1) = *p;
        --l.length;
        return OK;
    }  //ListDelete_Sq
    
    4、	逆置线性表:
    
    Status ListInversion_Sq(SqList &L,int i,ElemType e){
        //在顺序线性表L中将元素顺序倒置
        for(p = &(L.elem[L.length-1]);p<=L.length/2;p++)
        {
            *q = *p;
            *p = *(p+L.listsize);
            *(p+L.listsize) = *q;
        }
        return OK;
    }  //ListInversion_Sq
    
    5、	输出线性表:
    Status ListOutput_Sq(SqList &L,int i,ElemType e){
        //在顺序线性表L中将元素顺序倒置
        for(p = &(L.elem[L.length-1]);p<=L.length;p++)
        {
            cout<<*p;
        }
        cout<<endl;
        return OK;
    }  //ListOutput_Sq
    
    更多相关内容
  • 模拟通讯录,设计相关数据结构,用菜单选择方式实现:通讯录的建立、通讯联系人的插入、删除、修改、查找等功能。
  • 编写一个完整的程序,实现顺序表的生成、插入、删除、输出等基本运算。
  • 将建表、遍历、插入、删除分别定义为4个子函数,通过主函数实现对上述子函数的调用。
  • 在众多数据结构当中,线性表是最简单、也是最...本实验相对比较简单,通过本实验,对顺序表基本操作及 其组合应用的演练,加深对线性表顺序存储方法及其基本操作的理解,为以后进一步学习更 复杂的数据结构打下基础。
  • 数据结构初阶——顺序表

    千次阅读 多人点赞 2022-04-29 10:17:19
    博客写到这里,关于C语言的相关内容就告一段落了,从这篇开始,跟我一起进入一个全新的领域吧。把顺序表的代码放到了结尾。击鼓进军数据结构!!!

           博客写到这里,关于C语言的相关内容就告一段落了,从这篇开始,跟我一起进入一个全新的领域吧。

           前面也为大家介绍了通讯录应该怎样去实现,其实顺序表也与通讯录差不多。顺序表是一种线性表,线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的, 线性表在物理上存储时,通常以数组和链式结构的形式存储,关于线性表后面也会介绍很多。


    目录

    1. 顺序表的基本结构

    2. 接口实现

    3. 增加数据

            3.1 创建、初始化与销毁

            3.2 增加

                    3.2.1 尾插

                    3.2.2 头插

    4. 删除数据

            4.1 尾删

            4.2 头删

    5. 随机插入

    6. 随机删除

    7. 查找

    8. 修改

    结尾总结


    1. 顺序表的基本结构

           顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储。在数组上完成数据的增删查改。
    顺序表一般可以分为:
    1. 静态顺序表:使用定长数组存储元素

        像通讯录第一次实现时定义了1000个。

    2. 动态顺序表:使用动态开辟的数组存储。

        动态的通讯录


    2. 接口实现

           静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了,空间开多了浪费,开少了不够用。所以现实中基本都是使用动态顺序表,根据需要动态的分配空间大小。

           以后会经常用到typedef去对类型重命名,首先就要把顺序表的结构写出来,之后就来实现各种功能。


    3. 增加数据

            3.1 创建、初始化与销毁

           再增加数据之前,首先要在主函数创建一个顺序表,再对这个顺序表初始化。还是继续用模块化的方式。

     函数的参数是结构体指针,所以实参传入的时候要对结构体变量取地址。

            3.2 增加

    对于增加有两种形式,一种是头插,另一种是尾插。

                    3.2.1 尾插

    在开始插入时,我们要先对空间进行一个检查,检查空间是否足够我们插入数据。

    在检查时,先使用临时变量newcapacity和tmp,如果空间不够,我们直接扩容一倍,在开始的时候,size和capacity都是0,那开始直接先给4个空间,最后检查无误后再赋值。

    开始size是0,正好对应下标为0的位置,也就是第一个位置,之后size++,这时数据就可以存入了。

    为了检测我们插入的数据是否真的存到了顺序表中,再写一个打印函数 。

    之后就测试一下

     

                    3.2.2 头插

    头插不能在顺序表的头部插入,只能把所有的数据往后挪,再把数据插入。

    问题就是需要拿几次,和在存放时的越界问题,但这里应该不会出现这种问题,当size和capacity的值相等的时候就会扩容。

     

     


    4. 删除数据

            4.1 尾删

    尾删就简单很多,但还是得检查一下size,如果没用数据就不要删了,这种assert的方法比较“暴力”,但感觉方便。

    这样就尾删了三个数据。 

            4.2 头删

     

     

     

    可以看到什么都没有打印,前面一共有5个数据,尾删了三次,头删两次,所以最后什么也没有,可不是出错啊。


    5. 随机插入

       

     

    总之就是需要插入的时候就得判断需不需要扩容,既然pos是下标,就要判断pos的有效性。pos=0就是头插,pos=size就是尾插。之后也就可以复用。

    一个头插一个尾插测试一下。

     


    6. 随机删除

     

     

     

    和插入之前的数据一样。

    当然,随机删除也是可以复用的。

     

     一个头删一个尾删来测试一下。


    7. 查找

     

    找到了返回下标,找不到返回-1,毕竟下标没用负数。 


    8. 修改

    修改就可以使用查找函数,只有找到了才能修改,把SLFind的返回值传入再进行修改。


    结尾总结

    关于顺序表的大致实现就介绍到这里,数据结构介绍的还是数据存放的形式,顺序表是连续存放的,不存在空缺。Test.c文件中只是潦草的写了一些调试的代码,如果想变得更好,也可以像通讯录的时候写一个菜单,再写的时候一定要创建结构体变量再进行操作,最后把所有的代码放在下面。

    Seqlist.h文件

    #pragma once
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <assert.h>
    
    typedef int SLDataType;
    
    typedef struct Seqlist
    {
    	SLDataType* a;//指向动态开辟的数组
    	int size;     //表中已存入数据的个数
    	int capacity; //容量空间的大小
    }SL;
    
    //初始化
    void SLInit(SL* ps);
    //销毁
    void SLDestory(SL* ps);
    //打印
    void SLPrint(SL* ps);
    
    //尾插/头插/尾删/头删
    void SLPushBack(SL* ps, SLDataType x);
    void SLPushFront(SL* ps, SLDataType x);
    void SLPopBack(SL* ps);
    void SLPopFront(SL* ps);
    
    //随机插入
    void SLInsert(SL* ps, int pos, SLDataType x);
    //随机删除
    void SLErase(SL* ps, int pos);
    
    //查找
    int SLFind(SL* ps, SLDataType x);
    
    //修改
    void SLModify(SL* ps, int pos, SLDataType x);

    Seqlist.c文件

    #define _CRT_SECURE_NO_WARNINGS 1
    
    #include "Seqlist.h"
    
    void SLPrint(SL* ps)
    {
    	assert(ps);
    	int i = 0;
    	for (i = 0; i < ps->size; i++)
    	{
    		printf("%d ", ps->a[i]);
    	}
    	printf("\n");
    }
    
    void SLInit(SL* ps)
    {
    	assert(ps);
    	ps->a = NULL;
    	ps->capacity = ps->size = 0;
    }
    
    void SLDestory(SL* ps)
    {
    	assert(ps);
    	if (ps->a)
    	{
    		free(ps->a);
    		ps->a = NULL;
    		ps->capacity = ps->size = 0;
    	}
    }
    
    void SLCheckCapacity(SL* ps)
    {
    	if (ps->capacity == ps->size)
    	{
    		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
    		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));
    		if (tmp == NULL)
    		{
    			printf("realloc fail\n");
    			return;
    		}
    		ps->capacity = newCapacity;
    		ps->a = tmp;
    	}
    }
    
    void SLPushBack(SL* ps, SLDataType x)
    {
    	//assert(ps);
    	//SLCheckCapacity(ps);
    
    	//ps->a[ps->size] = x;
    	//ps->size++;
    	SLInsert(ps, ps->size, x);
    }
    
    void SLPushFront(SL* ps, SLDataType x)
    {
    	//assert(ps);
    	//SLCheckCapacity(ps);
    
    	//int end = ps->size;
    	//while (end > 0)
    	//{
    	//	ps->a[end] = ps->a[end - 1];
    	//	end--;
    	//}
    	//ps->a[end] = x;
    	//ps->size++;
    	SLInsert(ps, 0, x);
    }
    
    void SLPopBack(SL* ps)
    {
    	//assert(ps);
    	//assert(ps->size > 0);
    	//ps->size--;
    	SLErase(ps, ps->size - 1);
    }
    
    void SLPopFront(SL* ps)
    {
    	//assert(ps);
    	//assert(ps->size > 0);
    
    	//int end = ps->size - 1;
    	//for (int i = 0; i < end; i++)
    	//{
    	//	ps->a[i] = ps->a[i + 1];
    	//}
    	//ps->size--;
    	SLErase(ps, 0);
    }
    
    void SLInsert(SL* ps, int pos, SLDataType x)
    {
    	assert(ps);
    	assert(pos >= 0 && pos <= ps->size);
    	SLCheckCapacity(ps);
    
    	//pos就是插入的下标
    	int end = ps->size;
    	while (end > pos)
    	{
    		ps->a[end] = ps->a[end - 1];
    		end--;
    	}
    	ps->a[pos] = x;
    	ps->size++;
    }
    
    void SLErase(SL* ps, int pos) 
    {
    	assert(ps);
    	assert(pos >= 0 && pos < ps->size);
    
    	for (int i = pos; i < ps->size - 1; i++)
    	{
    		ps->a[i] = ps->a[i + 1];
    	}
    	ps->size--;
    }
    
    int SLFind(SL* ps, SLDataType x)
    {
    	assert(ps);
    	for (int i = 0; i < ps->size; i++)
    	{
    		if (ps->a[i] == x)
    		{
    			return i;
    		}
    	}
    	return -1;
    }
    
    void SLModify(SL* ps, int pos, SLDataType x)
    {
    	assert(ps);
    	assert(pos >= 0 && pos < ps->size);
    
    	ps->a[pos] = x;
    }

    展开全文
  • 顺序表基本操作在主函数中的实现

    千次阅读 2020-11-05 20:58:33
    #include<iostream> #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define MAXSIZE 100 using namespace std; typedef int Status; typedef struct { int *elem;... L.elem=new int
    #include<iostream>
    #define OK 1
    #define ERROR 0
    #define OVERFLOW -2
    #define MAXSIZE 100
    using namespace std;
    
    typedef int Status;
    
    typedef struct
    {
        int *elem;
        int length;
    } SqList;
    //构建空线性表
    Status InistList(SqList &L)
    {
        L.elem=new int [MAXSIZE];
        if(!L.elem)exit (OVERFLOW);
        L.length=0;
        return OK;
    }
    //输入
    Status  CreatList(SqList &L,int n)
    {
        for(int i=0; i<n; i++)
        {
            cin>>L.elem[i];
        }
        L.length=n;
        return OK;
    }
    //取值
    Status   iGetNumber(SqList &L,int i,int &e)
    {
        if(i<1||i>L.length)
        {
            return ERROR;
        }
        e=L.elem[i-1];
        return OK;
    }
    //查找
    int  eLocateList(SqList &L,int e)
    {
        for(int i=0; i<L.length; i++)
        {
            if(L.elem[i]==e)
            {
                return i+1;
            }
        }
        return 0;
    }
    
    //插入
    Status   eInsertList(SqList &L,int i,int e)
    {
        if(i<1||i>L.length+1)
        {
            return ERROR;
        }
        if(L.length==MAXSIZE)
        {
            return ERROR;
        }
        for(int j=L.length-1; j>=i-1; j--)
        {
            L.elem[j+1]=L.elem[j];
        }
        L.elem[i-1]=e;
        ++L.length;
        return OK;
    }
    //删除
    Status  aDeleteList(SqList &L,int i)
    {
        if(L.length==0){
            return ERROR;
        }
        if((i<1)||(i>L.length))
        {
            return ERROR;
        }
        for(int j=i; j<=L.length-1; j++)
        {
            L.elem[j-1]=L.elem[j];
        }
        --L.length;
        return OK;
    }
    //输出
    void DisplayList(SqList &L)
    {
        for(int i=0; i<L.length; i++)
        {
            cout<<L.elem[i]<<" ";
        }
    }
    //欢迎
    void WelcomeMenu()
    {
        cout<<"1.初始化\n";
        cout<<"2.输入\n";
        cout<<"3.取值\n";
        cout<<"4.查找\n";
        cout<<"5.插入\n";
        cout<<"6.删除\n";
        cout<<"7.输出\n";
        cout<<"0.退出\n";
        cout<<endl;
    }
    int main()
    {
        SqList L;
        WelcomeMenu();
        bool a=true;
        while(a)
        {
            int N;
            cout<<endl<<"请选择:";
            cin>>N;
            switch(N)
            {
            case 1:
            {
                if(InistList(L))
                {
                    cout<<"成功初始化线性表";
                }
                else
                {
                    cout<<"初始化线性表失败";
                }
                break;
            }
            case 2:
            {
                int n;
                cout<<"请输入元素个数:";
                cin>>n;
                cout<<"请输入"<<n<<"个元素:";
                CreatList(L,n);
                cout<<"输入完成";
                break;
            }
            case 3:
            {
                int i,e;
                cout<<"请输入一个位置用来取值:";
                cin>>i;
                if(iGetNumber(L,i,e))
                {
                    cout<<"取值成功,值为:";
                    cout<<e;
                }
                break;
            }
            case 4:
            {
                int e;
                cout<<"请输入所要查找的元素:";
                cin>>e;
                cout<<"查找成功,位置为:"<<eLocateList(L,e);
                break;
            }
            case 5:
            {
                int i,e;
                cout<<"请输入插入位置:";
                cin>>i;
                cout<<"请输入插入元素:";
                cin>>e;
                eInsertList(L,i,e);
                cout<<"插入成功!";
                break;
            }
            case 6:
            {
                int a;
                cout<<"请输入所要删除的元素:";
                cin>>a;
                aDeleteList(L,a);
                cout<<"删除成功";
                break;
            }
            case 7:
            {
                cout<<"当前线性表为:";
                DisplayList(L);
                break;
            }
            case 0:
            {
                a=false;
                break;
            }
            }
        }
        return 0;
    }
    
    
    展开全文
  • 数据结构_顺序表的查找实验报告.pdf数据结构_顺序表的查找实验报告.pdf数据结构_顺序表的查找实验报告.pdf数据结构_顺序表的查找实验报告.pdf数据结构_顺序表的查找实验报告.pdf
  • 构建顺序表进行数据的查询,删除,增容等操作。

    系列文章目录

    提示:这里可以添加系列文章的所有文章的目录,目录需要自己手动添加
    例如:第一章 Python 机器学习入门之pandas的使用


    提示:写完文章后,目录可以自动生成,如何生成可参考右边的帮助文档


    前言

    顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中,即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系,采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。


    提示:以下是本篇文章正文内容,下面案例可供参考

    一、顺序表的相关描述

    示例:pandas 是基于NumPy 的一种工具,该工具是为了解决数据分析任务而创建的。

    二、顺序表的增删查改;

    1.定义顺序表

    代码如下(示例):

    typedef struct
    {
    	tempstyle* data;
    	//数据域;
    	int curpity;
    	//链表的容量;
    	int cursize;
    	//链表的长度; 
    }Seqlist;
    

    2.顺序表的初始化

    代码如下(示例):

    Seqlist* INIT_list(Seqlist* plist)//顺序表初始化; 
    {
    	//对链表的容量进行赋值;
    	plist->curpity = SEQ_INIT_SIZE;
    	plist->cursize = 0;
    	plist->data = (tempstyle*)malloc(sizeof(tempstyle) * plist->curpity);
    	//申请动态存储空间; 
    }
    

    3.顺序表查找,删除,插入;

    顺序表本质就是一定长度的具有连续地址的数组,所以数据的查询和删除都是在数组的基础上进行,考察的就是数组的应用。
    
    bool insert_list(Seqlist* plist, int pos, tempstyle val)
    {
    	assert(plist != NULL);
    	if (pos<0 || pos>plist->cursize)
    	{
    		return false;
    	}
    	if (INIT_man(plist) == true)
    	{
    		return false;
    	}
    	else
    	{
    		for (int i = plist->cursize; i > pos; i--)
    		{
    			plist->data[i] = plist->data[i - 1];
    		}
    		plist->data[pos] = val;
    		plist->cursize += 1;
    		return true;
    		/*
    		for(int i=plist->cursize-1;i>=pos;i--)
    		{
    			plist->data[i+1]=plist->data[i];
    		}
    		plist->data[pos]=val;
    		plist->cursize+=1;
    		return true;
    		*/
    	}
    }
    //查找函数,对输入的值进行查找;
    int FIND_list(Seqlist* plist, tempstyle val)
    {
    	assert(plist != NULL);
    	int pos = plist->cursize;
    	while (pos > 0 && plist->data[pos - 1] != val)
    	{
    		pos--;
    	}
    	if (pos == 0)
    		return -1;
    	else
    		return pos;
    }
    

    4.顺序表的扩容;

    顺序表的扩容就是将已有的数据转移到另一个大一点的数组中。可以用realloc函数,也可以用memmove函数,也可以用数组直接单个单个进行转移。以上三种方法我都已经实现。可以自己测试。
    bool INIT_seqlist(Seqlist* plist)
    {
    	assert(plist != NULL);
    	int total;
    	total = plist->curpity * SEQ_SIZE;
    	tempstyle* newnode = (tempstyle*)malloc(sizeof(tempstyle) * total);
    	if (plist == NULL)
    	{
    		return false;
    	}
    	else
    	{
    		/*	for(int i=0;i<plist->curpity;i++)
    			{
    				newnode[i]=plist->data[i];
    			}
    			memmove(newnode,plist->data,sizeof(tempstyle)*plist->curpity);
    			free(plist->data);
    			plist->data=newnode;
    			plist->curpity=total;
    			return true;*/
    
    		plist->data = (tempstyle*)realloc(plist->data, sizeof(tempstyle) * total);//增加到tatol的空间; 
    		plist->cursize += 1;
    		plist->curpity = total;
    		return true;
    	}
    }
    

    三、顺序表的源代码;

    #define _CRT_SECURE_NO_WARNINGS 1
    #include<stdio.h>  //printf
    #include<stdlib.h>  //malloc,realloc,free
    #include<assert.h>//assert
    #include<string.h>//memmove内存移动函数, 
    //#define NDEBUG  //可以对assert函数进行禁用; 
    #define SEQ_INIT_SIZE 10
    #define SEQ_SIZE 2
    typedef int tempstyle;
    typedef struct
    {
    	tempstyle* data;
    	//数据域;
    	int curpity;
    	//链表的容量;
    	int cursize;
    	//链表的长度; 
    }Seqlist;
    //功能模块化;
    //对链表进行动态空间的申请; 
    Seqlist* INIT_list(Seqlist* plist)//顺序表初始化; 
    {
    	//对链表的容量进行赋值;
    	plist->curpity = SEQ_INIT_SIZE;
    	plist->cursize = 0;
    	plist->data = (tempstyle*)malloc(sizeof(tempstyle) * plist->curpity);
    	//申请动态存储空间; 
    }
    //创建链表; 
    void creatlist(Seqlist* plist, int n)
    {
    	assert(plist != NULL);
    	plist->cursize = n;
    	for (int i = 0; i < n; i++)
    	{
    		scanf("%d", &plist->data[i]);
    	}
    }
    //创建打印函数;
    void printlist(Seqlist* plist)
    {
    	assert(plist != NULL);
    	printf("输出链表:\n");
    	for (int i = 0; i < plist->cursize; i++)
    	{
    		printf("%5d", plist->data[i]);
    	}
    	putchar('\n');
    }
    //判断是否已经满了;
    bool INIT_man(const Seqlist* plist)
    {
    	assert(plist != NULL);
    	if (plist->cursize < plist->curpity)
    	{
    		return false;
    	}
    	else
    		return true;
    }
    //创建插入函数;
    bool insert_list(Seqlist* plist, int pos, tempstyle val)
    {
    	assert(plist != NULL);
    	if (pos<0 || pos>plist->cursize)
    	{
    		return false;
    	}
    	if (INIT_man(plist) == true)
    	{
    		return false;
    	}
    	else
    	{
    		for (int i = plist->cursize; i > pos; i--)
    		{
    			plist->data[i] = plist->data[i - 1];
    		}
    		plist->data[pos] = val;
    		plist->cursize += 1;
    		return true;
    		/*
    		for(int i=plist->cursize-1;i>=pos;i--)
    		{
    			plist->data[i+1]=plist->data[i];
    		}
    		plist->data[pos]=val;
    		plist->cursize+=1;
    		return true;
    		*/
    	}
    }
    //查找函数,对输入的值进行查找;
    int FIND_list(Seqlist* plist, tempstyle val)
    {
    	assert(plist != NULL);
    	int pos = plist->cursize;
    	while (pos > 0 && plist->data[pos - 1] != val)
    	{
    		pos--;
    	}
    	if (pos == 0)
    		return -1;
    	else
    		return pos;
    }
    
    //判断链表是否为空;
    bool INIT_kong(const Seqlist* plist)
    {
    	assert(plist != NULL);
    	if (plist->cursize == 0)
    		return true;
    	else
    		return false;
    }
    //增加扩容;
    bool INIT_seqlist(Seqlist* plist)
    {
    	assert(plist != NULL);
    	int total;
    	total = plist->curpity * SEQ_SIZE;
    	tempstyle* newnode = (tempstyle*)malloc(sizeof(tempstyle) * total);
    	if (plist == NULL)
    	{
    		return false;
    	}
    	else
    	{
    		/*	for(int i=0;i<plist->curpity;i++)
    			{
    				newnode[i]=plist->data[i];
    			}
    			memmove(newnode,plist->data,sizeof(tempstyle)*plist->curpity);
    			free(plist->data);
    			plist->data=newnode;
    			plist->curpity=total;
    			return true;*/
    
    		plist->data = (tempstyle*)realloc(plist->data, sizeof(tempstyle) * total);//增加到tatol的空间; 
    		plist->cursize += 1;
    		plist->curpity = total;
    		return true;
    	}
    }
    //尾部插入;
    void insert_back(Seqlist* plist, tempstyle val)
    {
    	assert(plist != NULL);
    	//也可以调用函数,进行插入; 
    	insert_list(plist, plist->cursize, val);
    	/*
    	plist->data[plist->cursize]=val;
    	plist->cursize+=1;
    	*/
    }
    //头部插入; 
    void insert_front(Seqlist* plist, tempstyle val)
    {
    	assert(plist != NULL);
    	insert_list(plist, 0, val);
    	/*
    	for(int i=plist->cursize;i>0;i--)
    	{
    		plist->data[i]=plist->data[i-1];
    	}
    	plist->data[0]=val;
    	plist->cursize+=1;
    	*/
    }
    void makemenu()
    {
    	printf("\t创建循环链表:\n");
    	putchar('\n');
    	printf("\t输入你要输入的值:\n");
    	putchar('\n');
    	printf("\tn代表链表的长度,val1代表头插入的值,val2代表尾插入的值:\n");
    	putchar('\n');
    	printf("\t你可以输入pos的值来删除函数中指定位置的数据:\n");
    	putchar('\n');
    }
    //求出链表还差多少字节才能满;
    int LENGTH_list(Seqlist* plist)
    {
    	assert(plist != NULL);
    	if (plist->cursize == plist->curpity)
    	{
    		printf("链表已经满了:\n");
    	}
    	else
    		return plist->curpity - plist->cursize;
    }
    int length_list(Seqlist* plist)
    {
    	assert(plist != NULL);
    	return plist->cursize;
    }
    //指定位置删除; 
    bool delete_list(Seqlist* plist, int pos)
    {
    	assert(plist != NULL);
    	//需要判断输入的位置是否存在;
    	if (pos > 0 && pos <= plist->cursize)
    	{
    		for (int i = pos - 1; i <= plist->cursize - 1; i++)
    		{
    			plist->data[i] = plist->data[i + 1];//最后一个给了空值; 
    		}
    		/*
    		for(int i=pos;i<plist->cursize;i++)
    		{
    		plist->data[i-1]=plist->data[i];
    		}
    		*/
    		plist->cursize -= 1;
    		return true;
    	}
    	else
    		return false;
    }
    //判断一个值是否在这个表中;
    bool ADJUST_list(Seqlist* plist, tempstyle val)
    {
    	assert(plist != NULL);
    	int cnt = 0;
    	for (int i = 0; i < plist->cursize; i++)
    	{
    		if (plist->data[i] == val)
    		{
    			cnt++;
    		}
    	}
    	if (cnt >= 1)
    		return true;
    	else
    		return false;
    }
    //删除你想删除的值;
    int delete_val_list(Seqlist* plist, tempstyle val)//状态返回; 
    {
    	assert(plist != NULL);
    	return	delete_list(plist, FIND_list(plist, val));
    }
    //摧毁函数;
    void destroy_list(Seqlist* plist)
    {
    	plist->curpity = 0;
    	plist->cursize = 0;
    	free(plist->data);
    }
    //链表重置为空;
    void clear_list(Seqlist* plist)
    {
    	assert(plist != NULL);
    	plist->cursize = 0;
    }
    //删除链表中所有等于val的值;
    
    /*void delete_all_list(Seqlist*plist,tempstyle val)
     {
    	assert(plist!=NULL);
    	int pos;
    	while(pos=FIND_list(plist,val)!=-1)
    	{
    		delete_list(plist,pos);
    	}
     }
     */
    
     /*void delete_all_list(Seqlist*plist,tempstyle val)
     {
    	 assert(plist!=NULL);
    	 int j=-1;
    	 int i=0;
    	 for(i;i<plist->cursize;++i)
    	 {
    		 if(plist->data[i]!=val)
    		 {
    			 j+=1;
    			 plist->data[j]=plist->data[i];
    		 }
    	 }
    	 plist->cursize=j+1;
     }*/
    void delete_all_list(Seqlist* plist, tempstyle val)
    {
    	assert(plist != NULL);
    	tempstyle* newnode = (tempstyle*)malloc(sizeof(tempstyle) * plist->curpity);
    	int i = 0;
    	for (int j = 0; j < plist->cursize; j++)
    	{
    		if (plist->data[j] != val)
    		{
    			newnode[i] = plist->data[j];
    			i++;
    		}
    	}
    	memmove(plist->data, newnode, i);
    	plist->cursize = i;
    
    }
    //创建主函数; 
    int main()
    {
    	Seqlist* plist;
    	int n;
    	int m;
    	int pos;
    	tempstyle val1, val2, val3;
    	system("color 05");
    	makemenu();
    	scanf("%d", &n);
    	INIT_list(plist);
    	if (n > 10)
    	{
    		INIT_seqlist(plist);
    	}
    	creatlist(plist, n);
    	printlist(plist);
    	printf("\t输入你要插入的值:\n");
    	scanf("%d", &val1);
    	insert_front(plist, val1);
    	printlist(plist);
    	printf("\t输入你要插入的值:\n");
    	scanf("%d", &val2);
    	insert_back(plist, val2);
    	printlist(plist);
    	printf("链表的长度为:\n");
    	printf("%d\n", length_list(plist));
    	if (INIT_man(plist) == true)
    	{
    		printf("\t链表已经满了:\n");
    		return 0;
    	}
    	if (INIT_kong(plist) == true)
    	{
    		printf("\t链表为空:\n");
    	}
    	m = LENGTH_list(plist);
    	printf("\t链表还差%d才会满:\n", m);
    	printf("\t判断链表中是否有你输入的值:\n");
    	scanf("%d", &val3);
    	if (ADJUST_list(plist, val3) == true)
    	{
    		printf("\t有你要查找的数:\n");
    	}
    	printf("\t现在可以进行删除函数:\n");
    	printf("输入n你要删除的数据的位置:\n");
    	scanf("%d", &pos);
    	delete_list(plist, pos);
    	printf("删除后的链表的长度为:\n");
    	printf("%d", length_list(plist));
    	printlist(plist);
    	tempstyle val4;
    	printf("\t删除链表中所有指定的值:\n");
    	scanf("%d", &val4);
    	delete_all_list(plist, val4);
    	printlist(plist);
    	putchar('\n');
    	m = LENGTH_list(plist);
    	printf("\t链表还差%d才会满:\n", m);
    	//destroy_list(plist); 
    	return 0;                                                                                                                                                                                                                                                                                                                                                                                                                               return 0;
    }
    
    
    

    总结

    顺序表想比单链表有操作简单,无需更多的内存空间,查询数据简单。但是链表的长度不容易控制,每次插入数据需要移动大量数据,容易造成数据遗失。

    展开全文
  • 数据结构基础入门】顺序表的概念、结构和接口实现
  • 例、设计一个删除算法,删除顺序表L中的第i个位置的元素,用引用变量返回。 思路: 由于这个函数删除后顺序表L有变,所以L前要有&,且我们要返回的变量一开始为初始值0,它也是变化的,所以该变量前面也要加引用...
  • 这是数据结构和算法设计课程设计一个选题。实践了顺序表的基本操作的封装,及实践中的调用。特别的对顺序表上的插入和删除操作做出详细的介绍。课设采用静态存储,按值查找。希望能够对其他同学有所帮助
  • 编写一个程序,实现顺序表的各种基本运算(假设顺序表的元素类型为char),并在此基础上设计一个主程序完成如下功能: (1)初始化顺序表L; (2)依次采用尾插法插入a、b、c、d、e元素; (3)输出顺序表L; (4)...
  • 数据结构实验报告一 顺序表与链表

    千次阅读 2020-12-31 12:52:40
    数据结构实验报告:实验一 顺序表与链表
  • #define MAXSIZE 100 //预估顺序表容量 #define OK 1 #define ERROR 0 #define OVERFLOW -2 //数据类型的重命名、定义 typedef int Status; typedef int ElemType; typedef struct{ ElemType *elem; int lengt...
  • 顺序表存储数据,预先申请一整块足够大的存储空间,然后将数据按照次序逐一存储,数据之间紧密贴合,不留一丝空隙。 优点:在O(1)时间内查找元素;存储密度高。 缺点:扩容不方便;插入和删除元素不方便。 二、代码...
  • 图书信息管理系统(数据结构顺序表,c语言版)

    千次阅读 多人点赞 2021-07-18 00:47:18
    严蔚敏数据结构(C语言版)第2版,数据结构顺序表,课本第21页图书信息管理系统实验。
  • 数据结构顺序表写学生管理系统

    千次阅读 2020-09-05 18:08:21
    上一篇学习了顺序表(线性表的顺序存储)的九大操作,为了巩固知识点,今天用顺序表写了简单的学生管理系统。一下用了两种方式来实现,不适用指针和使用指针,加深对C语言指针的了解。 一、不使用指针方式 /********...
  • 数据结构查找--顺序表的顺序查找

    千次阅读 2021-11-20 19:49:26
    顺序查找:从表的一端开始,依次将记录在...数据结构类型定义如下: typedef struct { KeyType key; //关键字域 InfoType otherinfo; //其他域 }ElemType; 定义单个结点后,再定义顺序表 typedef struct { ...
  • 数据结构-顺序表(动态分配存储空间)

    千次阅读 多人点赞 2019-10-10 18:52:47
    数据结构-顺序表(动态分配存储空间) (1)顺序表的结构定义: 结构型定义:(动态分配存储空间) /** * 动态分配存储空间 */ #define InitSize 100 //动态分配存储空间时,不限制最大,只给定一个初始值 #define ...
  • 数据结构顺序表实验

    千次阅读 2017-09-19 16:20:17
    顺序表实验
  • 一、用链表或者顺序表实现以下系统,完成线性表的建立(至少包括10个结点),以及线性表中信息(结点)的插入、查找、删除、修改、输出等操作,具体的模块要求见上方的“总的模块要求”。建议用“文件”存储数据。 1...
  • 数据结构 顺序表,链表源代码
  • 数据结构 顺序表(动态分配内存) 文章目录数据结构 顺序表(动态分配内存)前言一、顺序表二、代码部分1.头文件2.预定义3.定义存储结构4.顺序表初始化5.创建顺序表6.遍历顺序表7.销毁顺序表8.重置顺序表9判断顺序表...
  • 顺序表_主程序

    2021-02-07 17:50:23
    顺序表检验bo2-1.h的主程序 以下内容为main2-1.cpp /* * 时间:2021.01.30 * 内容:检验 bo2-1.h 的主函数,也是线性表主要功能检验主函数 * 位置: * 高书p15 */ #include "c1.h" typedef int ElemType; // ...
  • 好进行增容3、顺序表尾插4、顺序表尾删5、顺序表头插6、顺序表头删7、打印顺序表8、在顺序表中查找指定值9、在顺序表指定下标位置插入数据10、在顺序表中删除指定下标位置的数据11、查看顺序表中有效数据个数12、...
  • 线性表是一种最基本、最常用的数据结构,它有两种存储结构——顺序表和链表。顺序表是由地址连续的的向量实现的,便于实现随机访问。顺序表进行插入和删除运算时,平均需要移动表中大约一半的数据元素,容量难以扩充...
  • 顺序表的存储 #include <stdio.h> #include <stdlib.h> typedef int KeyType; typedef struct { KeyType key; //关键子域 }ElemType; typedef struct { ElemType *R; //存储空间基地址 int ...
  • 目录前言一、顺序表的定义二、顺序表的初始化三、顺序表的建立四、顺序表的输出五、顺序表的逆序输出六、顺序表的插入操作七、顺序表的删除操作八、顺序表的按位和按值查找完整代码*九、删除常用操作(一)删除顺序...
  • #include <stdio.h> /** * 数组空间静态分配 */ #define MaxSize 100 //表示有MaxSize个位置 typedef struct { int data[MaxSize]; //定义一个数组空间,用于存储数据 ... //自定义的顺序表类型为S...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,968
精华内容 9,187
关键字:

数据结构顺序表主函数

数据结构 订阅