精华内容
下载资源
问答
  • 顺序表基本操作

    2017-04-14 14:27:12
    顺序表基本操作 顺序表实现 顺序表
  • 数据结构C语言完成顺序表基本操作,上数据结构课的时候的任务,可以在vs上实现,用switch函数选择
  • 主要介绍了C语言实现顺序表基本操作汇总,对学习数据结构的朋友有一定的借鉴价值,需要的朋友可以参考下
  • 【实验课程名称】算法与数据结构 【实验项目名称】顺序表基本操作的实现
  • 实验报告1.2.2顺序表基本操作应用实验2
  • 实验报告1.1顺序表基本操作的设计与实现
  • 实验报告1.2.1顺序表基本操作应用实验1
  • 顺序表基本操作

    2017-09-18 23:24:03
    本资源是:线性表中的顺序表的一些操作,包括初始化顺序表、建立顺序表、删除顺序表、在顺序表中插入元素,在顺序表中删除元素、判断空的等一些基本操作
  • 顺序表基本操作的实现

    千次阅读 2020-02-22 22:52:43
    实验一 顺序表基本操作的实现 一、实验学时: 2学时 二、实验目的 实现顺序表的基本操作 三、实验内容 顺序表的建立、取指定元素、返回指定元素位置 顺序表中插入新元素、删除指定元素操作的实现 四、主要仪器...

    实验一 顺序表基本操作的实现

    一、实验学时: 2学时

    二、实验目的

    • 实现顺序表的基本操作

    三、实验内容

    1. 顺序表的建立、取指定元素、返回指定元素位置
    2. 顺序表中插入新元素、删除指定元素操作的实现

    四、主要仪器设备及耗材

    • 硬件:计算机一台
    • 软件:VC++ 6.0,MSDN2003或者以上版本

    五、实验步骤

    1. 分析问题
    2. 写出算法
    3. 编制程序
    4. 上机调试
    5. 分析结果

    六、程序清单

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>			//要用exit所以加它 
    #define OK 1				//成功返回值 
    #define ERROR 0         	//出错返回值 
    #define OVERFLOW -2    		//溢出返回值 
    #define MAXSIZE 10000   	//空间大小 
    //用户自定义类型Status 
    typedef int Status;
    
    //定义图书结构体 
    typedef struct
    {
    	char no[20];		//书号 
    	char name[50];		//书名 
    	float price;		//价格 
    }Book;
    
    //用户自定义类型SqList 
    typedef struct
    {
    	Book *elem;		//图书指针 
    	int length;		//图书顺序表长度 
    }SqList;
    
    //初始化顺序表 
    Status InitList(SqList &L)		//形参要的是SqList的引用,调用时是InitList(L),因为引用更改后它本身就更改了。不然传的只是副本,对原值无影响。 
    {
    	L.elem=new Book[MAXSIZE];	//为顺序表分配一个MAXSIZE大小的数组空间 
    	if(!L.elem) exit(OVERFLOW);	//分配失败退出 
    	L.length=0;					//空表长度为0 
    	return OK;
    }
    
    //取值 
    Book GetElem(SqList L,int i)	//取出顺序表位于第i个位置的元素 
    {
        if(i<1||i>L.length) printf("取值操作异常");	//取值异常 
        return L.elem[i-1];							//返回找到的值 
    }
    
    //查找 
    int LocateElem(SqList L,Book e)		//查找元素e在顺序表中的位置 
    {
    	int i;
        for(i=0;i<L.length;i++)
            if(strcmp(L.elem[i].no,e.no)==0&&strcmp(L.elem[i].name,e.name)==0&&L.elem[i].price==e.price) return i+1;
        return 0;
    }
    
    //插入 
    Status ListInsert(SqList &L,int i,Book e)	//将元素e插入到顺序表L的第i的位置 
    {
        if((i<1)||(i>L.length+1)) return ERROR;
        if(L.length==MAXSIZE) return ERROR;
        int j;
        for(j=L.length-1;j>=i-1;j--)
            L.elem[j+1]=L.elem[j];				//i位置及以后的元素整体后移 
        L.elem[i-1]=e;
        ++L.length;
        return OK;
    }
    
    //删除 
    SqList ListDelete(SqList &L,int i)
    {
        if((i<1)||(i>L.length+1)) printf("删除异常");
        int j; 
        for(j=i;j<=L.length-1;j++)
            L.elem[j-1]=L.elem[j];				//被删元素后面的整体前移 
        --L.length;
        return L;
    }
    
    int main()
    {
    	SqList L;
    	Status status = InitList(L);
    	if(!status)
    	{
    		printf("顺序表初始化失败!\n");
    		return ERROR;	
    	}
    	else
    	{
    		printf("顺序表初始化成功!\n");
    		Book e;
    		printf("请录入图书信息:\n");
    		printf("书号:");scanf("%s",&e.no);
    		printf("书名:");scanf("%s",&e.name);
    		printf("价格:");scanf("%f",&e.price);
    		int i;
    		for(i=1;;++i)
    		{
    			ListInsert(L,i,e);
    			printf("成功收藏%d本书至图书馆\n",i);
    			printf("书号:");scanf("%s",&e.no);
    			printf("书名:");scanf("%s",&e.name);
    			printf("价格:");scanf("%f",&e.price);
    			if(e.price==0)
    				break;
    		}
    		
    		printf("图书馆共%d本书\n",L.length);
    		printf("图书馆的图书列表:\n");
    		Book e1;
    		int j;
    		printf("编号\t书名\t\t价格\n");
    		for(j=1;j<=L.length;j++)
    		{
    			e1=GetElem(L,j);
    			printf("%s\t",e1.no);
    			printf("%s\t",e1.name);
    			printf("%-7.2f\n",e1.price);
    		}
    		Book e2={"10102","计算机组成原理",46.5};
    		int location = LocateElem(L,e2);
    		printf("其中第%s在第%d个位置\n",e2.name,location); 
    		printf("------------------------------\n"); 
    		
    		printf("删除第二本后的列表:\n"); 
    		SqList sl = ListDelete(L,2);
    		printf("图书馆共%d本书\n",sl.length);
    		printf("图书馆的图书列表:\n");
    		printf("编号\t书名\t\t价格\n");
    		for(j=1;j<=sl.length;j++)
    		{
    			e2=GetElem(sl,j);
    			printf("%s\t",e2.no);
    			printf("%s\t",e2.name);
    			printf("%-7.2f\n",e2.price);
    		}
    	}
    }
    

    七、运行结果及分析
    当价格为0结束输入
    八、小总结

    • 建立顺序表(初始化):初始化就是用指针指向新分配的空间,若内存不足分配失败则退出,否的话长度置为0,然后返回OK。
    • 取指定位置元素(取值):就是超出范围取值异常,在范围内就返回第i个元素。
    • 返回指定元素位置(查找):循环查找,如果是基本数据类型相等就行了,像本程序中用的是Book结构体类型,所以要比较每一个数据,都相等则返回位置。
    • 向指定位置插入元素(插入):超出范围和溢出都报错,i位置及以后的元素整体后移空出位置i放元素e,然后长度加1。
    • 删除指定位置元素(删除):超出范围报错,否则被删元素后面的元素整体前移,长度减1。
    • 要说的问题:&L与L
      参数里的这两者区别,带&是传的引用,可以更改L里的数据,不然的话只是传了一个副本,形参改变对实参无影响。
    展开全文
  • C语言实现顺序表基本操作

    千次阅读 2019-07-31 15:42:08
    C语言实现顺序表基本操作

    C语言实现顺序表的基本操作,包括增删查操作以及顺序表的合并

    SequentialList.h

    #include <stdio.h>
    #include <stdlib.h>
    #define MAXSIZE 30
    
    typedef int DataType;
    //顺序表格式定义
    typedef struct
    {
        DataType Data[MAXSIZE];  //数据域,存放数据
        int last;       //记录最后顺序表一个元素下标,空表为-1
    }SeqList;
    //定义三个顺序表LA,LB,LC
    SeqList LA,LB,LC;
    
    //判空
    int IsEmpty(SeqList L);
    //判满
    int IsFull(SeqList L);
    
    //初始化顺序表
    int InitSeqList(SeqList* L);
    
    //在下标i处插入数据
    int InsList(SeqList* L,int i,int e);
    //递增按序插入数据
    int InsertList(SeqList* L,int e);
    
    //删除下标为i的元素
    int DelList(SeqList* L,int i);
    //删除数据e
    int DeleteList(SeqList* L,int e);
    
    //查找并返回下标为i的元素
    int GetData(SeqList L,int i);
    //查找变量e并返回下标
    int Locate(SeqList L,int e);
    
    //显示L所有数据
    int Show(SeqList L);
    
    //合并有序顺序表LA,LB
    int MergeList(SeqList* LA,SeqList* LB,SeqList* LC);
    
    //状态判断函数,判断并输出操作的运行状态
    int State(int i);
    
    //对顺序表L进行操作
    int Operation(SeqList* L);
    
    //主界面
    int MainMenu();
    

    SequentialList.c

    #include <stdio.h>
    #include <stdlib.h>
    #include "SequentialList.h"
    
    //初始化顺序表
    int InitSeqList(SeqList* L)
    {
        //将顺序表last值赋为-1,将顺序表置为空表
        L->last = -1;
        return 0;
    }
    
    //在下标i处插入数据
    int InsList(SeqList* L,int i,int e)
    {
        int j;
        if(IsFull(*L))
            return -1;      //表已满,无法插入
        if((i < 0)||(i > L->last + 1))
            return 0;       //插入位置i不合法
        if(i == L->last + 1)
        {
            L->Data[i] = e;
            L->last++;
            return 1;        //插入成功返回1
        }
        else
        {
            for(j = L->last;j >= i; j--)
                L->Data[j+1] = L->Data[j];
            L->Data[i] = e;
            L->last++;
            return 1;        //插入成功返回1
        }
    }
    
    //按递增顺序插入数据e
    int InsertList(SeqList* L,int e)
    {
        int i;
        if(IsEmpty(*L))
        {
            L->Data[0] = e;
            L->last++;
            return 1;     //插入成功返回1
        }
        else
        {
            for(i = 0;i <= L->last; i++ )
            {
                if(L->Data[i] > e)
                    break;
            }
            return InsList(L,i,e);
             //在下标i处插入数据并返回其返回值
        }
    }
    
    //删除下标为i的元素
    int DelList(SeqList* L,int i)
    {
        int j;
        if((i < 0)||(i > L->last))
            return 0;           //删除位置不合法返回0
        if(i < L->last)
            for(j = i;j < L->last; j++ )
                L->Data[j] = L->Data[j+1];
        L->last--;
        return 1;               //删除成功返回1
    }
    
    //删除数据e
    int DeleteList(SeqList* L,int e)
    {
        int i = Locate(*L,e);
        if(i >= 0)
            return DelList(L,i);
        return -2;
    }
    
    //返回下标为i的数据
    int GetData(SeqList L,int i)
    {
        if((i < 0)||(i > L.last))
            return 0;        //位置不合法返回0
        return L.Data[i];           //操作成功返回1
    }
    
    //查找e返回下标
    int Locate(SeqList L,int e)
    {
        int i = 0;
        while((i <= L.last)&&(L.Data[i] != e))
            i++;
        if(i <= L.last)
            return i;  //找到位置则1
        return -1;         //未找到返回-2
    }
    
    //判空
    int IsEmpty(SeqList L)
    {
        if(L.last == -1)
            return 1;  //表为空返回1
        return 0;
    }
    
    //判满
    int IsFull(SeqList L)
    {
        if(L.last == MAXSIZE - 1)
            return 1;   //表已满返回1
        return 0;
    }
    
    //显示顺序表中所有元素
    int Show(SeqList L)
    {
        int i;
        for(i = 0;i <= L.last; i++)
            printf("\t%d. %d\n",i,L.Data[i]);
        return 0;
    }
    
    //状态判断函数,判断并输出操作的运行状态
    int State(int i)
    {
        if(i == -1)
            printf("\t顺序表已满\n");
        else if(i == 0)
            printf("\t输入位置不合法\n");
        else if(i == -2)
            printf("\t在顺序表中未找到该数据\n");
        else if(i == -3)
            printf("\t顺序表为空\n");
        else
            printf("\t操作成功\n");
        return 0;
    }
    
    //对顺序表进行操作
    int Operation(SeqList* L)
    {
        int i,e,k,m;
        //i操作数,e增删查的数据,k要操作的位置
        while(1)
        {
            system("cls");
            printf("\t1.按序插入数据e\n");
            printf("\t2.删除第k个数据\n");
            printf("\t3.删除数据e\n");
            printf("\t4.查找数据e\n");
            printf("\t5.显示所有数据\n");
            printf("\t0.返回主界面\n");
            scanf("%d",&i);
            switch(i)
            {
            case 1:
                printf("请输入要插入的数据");
                scanf("%d",&e);
                State(InsertList(L,e));
                system("pause");
                break;
            case 2:
                printf("请输入要删除数据的位置");
                scanf("%d",&k);
                State(DelList(L,k-1));
                system("pause");
                break;
            case 3:
                printf("请输入要删除的数据");
                scanf("%d",&e);
                State(DeleteList(L,e));
                system("pause");
                break;
            case 4:
                printf("请输入要查找的数据");
                scanf("%d",&e);
                m =Locate(*L,e);
                if(m >= 0)
                    printf("\n%d的下标为%d\n",e,m);
                system("pause");
                break;
            case 5:
                Show(*L);
                system("pause");
                break;
            case 0:
                return 0;
                break;
            default:
                break;
            }
        }
    }
    
    //合并有序顺序表LA,LB
    int MergeList(SeqList* LA,SeqList* LB,SeqList* LC)
    {
        int i,j,k;
        i = j = k = 0;
        while((i <= LA->last)&&(j <= LB->last))
        if(LA->Data[i] < LB->Data[j])
        {
            LC->Data[k] = LA->Data[i];
            i++;
            k++;
        }
        else
        {
            LC->Data[k] = LB->Data[j];
            j++;
            k++;
        }
        while(i <= LA->last)
        {
            LC->Data[k] = LA->Data[i];
            i++;
            k++;
        }
        while(j <= LB->last)
        {
            LC->Data[k] = LB->Data[j];
            j++;
            k++;
        }
        LC->last = LA->last + LB->last + 1;
        return 0;
    }
    
    //主界面
    int MainMenu()
    {
        int i;
        printf("\t1.对顺序表LA进行操作\n");
        printf("\t2.对顺序表LB进行操作\n");
        printf("\t3.合并顺序表LA和LB\n");
        printf("\t4.查看LC\n");
        printf("\t0.退出系统\n");
        scanf("%d",&i);
        switch(i)
        {
        case 1:
            Operation(&LA);
            break;
        case 2:
            Operation(&LB);
            break;
        case 3:
            MergeList(&LA,&LB,&LC);
            break;
        case 4:
            Show(LC);
            break;
        case 0:
            exit(0);
            break;
        default:
            break;
        }
        system("pause");
        return 0;
    }
    
    

    main.c

    #include <stdio.h>
    #include <stdlib.h>
    #include "SequentialList.h"
    
    int main()
    {
        InitSeqList(&LA);
        InitSeqList(&LB);
        InitSeqList(&LC);
        while(1)
        {
            system("cls");
            MainMenu();
        }
        return 0;
    }
    
    
    展开全文
  • 数据结构-顺序表基本操作的实现(含全部代码)

    万次阅读 多人点赞 2018-09-13 22:14:57
    今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构...L,int n) 参数:顺序表L,顺序表长度n 功能:创建长度为的顺序表 时间复杂度:O(n) InitList(SqList &...

    今天起开始编写数据结构中的各种数据结构及其算法的实现。

    主要依据严蔚敏版数据结构教材以及王道数据结构考研辅导书。

    今天是线性表中的顺序表的实现,主要实现函数如下,读者有需要可以评论,我可以适当加几个。

    • CreateList(SqList &L,int n) 参数:顺序表L,顺序表长度n 功能:创建长度为的顺序表 时间复杂度:O(n)
    • InitList(SqList &L) 参数:顺序表L 功能:初始化 时间复杂度:O(1)
    • InsertList(SqList &L,int i,ElemType e) 参数:顺序表L,位置i,元素e 功能:位置i处插入元素e 时间复杂度:O(n)
    • ListDelete(SqList &L,int i) 参数:顺序表L,位置i 功能:删除位置i处元素 时间复杂度:O(n)
    • LocateElem(SqList L,ElemType e) 参数:顺序表L,元素e 功能:返回第一个等于e的元素的位置 时间复杂度:O(n)
    • Reverse(SqList &L) 参数:顺序表L 倒置函数 将原顺序表直接倒置
    • PrintList(SqList L) 参数:顺序表L 功能:遍历L,并输出
    • SplitSort(SqList &L) 参数:顺序表L 功能:分开奇偶,并分开排序
    • ClearList(SqList &L) 参数:顺序表L 功能:清空顺序表

    代码如下:

    /*
    Project: sequence_list(数据结构-顺序表)
    Date:    2018/09/12  20191012修改 添加Reverse  20200819修改 添加ClearList
    Author:  Frank Yu
    CreateList(SqList &L,int n) 参数:顺序表L,顺序表长度n 功能:创建长度为的顺序表 时间复杂度:O(n)
    InitList(SqList &L) 参数:顺序表L 功能:初始化 时间复杂度:O(1)
    InsertList(SqList &L,int i,ElemType e) 参数:顺序表L,位置i,元素e 功能:位置i处插入元素e 时间复杂度:O(n)
    ListDelete(SqList &L,int i) 参数:顺序表L,位置i 功能:删除位置i处元素 时间复杂度:O(n)
    LocateElem(SqList L,ElemType e) 参数:顺序表L,元素e 功能:返回第一个等于e的元素的位置 时间复杂度:O(n)
    Reverse(SqList &L) 参数:顺序表L 倒置函数 将原顺序表直接倒置
    PrintList(SqList L) 参数:顺序表L 功能:遍历L,并输出
    SplitSort(SqList &L) 参数:顺序表L 功能:分开奇偶,并分开排序
    ClearList(SqList &L) 参数:顺序表L 功能:清空顺序表
    */
    #include<cstdio>
    #include<cstdlib>
    #include<cstring>
    #include<cmath>
    #include<algorithm>
    #include<iostream>
    #define MaxSize 100
    #define ElemType int
    #define Status int
    using namespace std;
    //顺序表数据结构
    typedef struct
    {
    	ElemType data[MaxSize];//顺序表元素
    	int length;            //顺序表当前长度
    }SqList;
    //***************************基本操作函数*******************************//
    //初始化顺序表函数,构造一个空的顺序表 
    Status InitList(SqList &L)
    {
    	memset(L.data, 0, sizeof(L));//初始化数据为0
    	L.length = 0;                //初始化长度为0
    	return 0;
    }
    //创建顺序表函数 初始化前n个数据
    bool CreateList(SqList &L, int n)
    {
    	if (n<0 || n>MaxSize)false;//n非法
    	for (int i = 0; i<n; i++)
    	{
    		scanf("%d", &L.data[i]);
    		L.length++;
    	}
    	return true;
    }
    //插入函数 位置i插入数据 i及之后元素后移  1=<i<=length+1 
    bool InsertList(SqList &L, int i, ElemType e)
    {
    	if (i<1 || i>L.length + 1) //判断位置是否有效
    	{
    		printf("位置无效!!!\n");
    		return false;
    	}
    	if (L.length >= MaxSize)//判断存储空间是否已满
    	{
    		printf("当前存储空间已满!!!\n");
    		return false;
    	}
    	for (int j = L.length; j >= i; j--)//位置i及之后元素后移
    	{
    		L.data[j] = L.data[j - 1];
    	}
    	L.data[i - 1] = e;
    	L.length++;
    	return true;
    }
    //删除函数 删除位置i的元素 i之后的元素依次前移
    bool  ListDelete(SqList &L, int i)
    {
    	if (i<1 || i>L.length)
    	{
    		printf("位置无效!!!\n");
    		return false;
    	}
    	for (int j = i; j <= L.length - 1; j++)//位置i之后元素依次前移覆盖
    	{
    		L.data[j - 1] = L.data[j];
    	}
    	L.length--;
    	return true;
    }
    //查找函数 按位置从小到大查找第一个值等于e的元素 并返回位置
    int LocateElem(SqList L, ElemType e)
    {
    	for (int i = 0; i<L.length; i++)//从低位置查找
    	{
    		if (L.data[i] == e)
    			return i + 1;
    	}
    	return 0;
    }
    //倒置函数 将原顺序表直接倒置
    void Reverse(SqList &L)
    {
    	if (L.length)
    		for (int i = 0; i<L.length - 1 - i; i++)
    		{
    			int t = L.data[i];
    			L.data[i] = L.data[L.length - 1 - i];
    			L.data[L.length - 1 - i] = t;
    		}
    }
    //奇偶分开并排序
    void SplitSort(SqList &L)
    {
    	int Even = 0;
    	int Odd = L.length - 1;
    	int i = 0;
    	int j = L.length - 1;
    	bool flag = false;
    	if (L.length)
    		for (; i < j; i++, j--)
    		{
    			while (L.data[i] % 2 != 0)i++;
    			while (L.data[j] % 2 == 0)j--;
    			if (L.data[i] % 2 == 0 && L.data[j] % 2 != 0&&i<j)
    			{
    				int temp = L.data[i];
    				L.data[i] = L.data[j];
    				L.data[j] = temp;
    				flag = true;
    			}
    			if(!flag) //没有交换
    			{
    				Even = L.length - 1;//全奇数
    				Odd = 0; //全偶数
    			}
    		}
    	if (flag)
    	{
    		for(int i=0;i<L.length;i++)
    			if (L.data[i] % 2 == 0) 
    			{
    				Odd = i;
    				Even = i - 1;
    				break;
    			}
    	}
    	sort(L.data, L.data + Even + 1);
    	sort(L.data + Odd, L.data + L.length);
    }
    //清空顺序表
    void ClearList(SqList &L) {
    	L.length = 0;
    }
    //********************************功能函数*****************************************//
    //输出功能函数 按位置从小到大输出顺序表所有元素
    void PrintList(SqList L)
    {
    	printf("当前顺序表所有元素:");
    	for (int i = 0; i<L.length; i++)
    	{
    		printf("%d ", L.data[i]);
    	}
    	printf("\n");
    }
    //创建顺序表函数
    void Create(SqList &L)
    {
    	int n; bool flag;
    	L.length = 0;
    	printf("请输入要创建的顺序表长度(>1):");
    	scanf("%d", &n);
    	printf("请输入%d个数(空格隔开):", n);
    	flag = CreateList(L, n);
    	if (flag) {
    		printf("创建成功!\n");
    		PrintList(L);
    	}
    	else printf("输入长度非法!\n");
    
    }
    //插入功能函数 调用InsertList完成顺序表元素插入 调用PrintList函数显示插入成功后的结果
    void Insert(SqList &L)
    {
    	int place; ElemType e; bool flag;
    	printf("请输入要插入的位置(从1开始)及元素:\n");
    	scanf("%d%d", &place, &e);
    	flag = InsertList(L, place, e);
    	if (flag)
    	{
    		printf("插入成功!!!\n");
    		PrintList(L);
    	}
    }
    //删除功能函数 调用ListDelete函数完成顺序表的删除 调用PrintList函数显示插入成功后的结果
    void Delete(SqList &L)
    {
    	int place; bool flag;
    	printf("请输入要删除的位置(从1开始):\n");
    	scanf("%d", &place);
    	flag = ListDelete(L, place);
    	if (flag)
    	{
    		printf("删除成功!!!\n");
    		PrintList(L);
    	}
    }
    //查找功能函数 调用LocateElem查找元素
    void Search(SqList L)
    {
    	ElemType e; int flag;
    	printf("请输入要查找的值:\n");
    	scanf("%d", &e);
    	flag = LocateElem(L, e);
    	if (flag)
    	{
    		printf("该元素位置为:%d\n", flag);
    	}
    	else
    		printf("未找到该元素!\n");
    }
    //菜单
    void menu()
    {
    	printf("********1.创建                        2.插入*********\n");
    	printf("********3.删除                        4.查找*********\n");
    	printf("********5.倒置                        6.分奇偶排序***\n");
    	printf("********7.输出                        8.清空*********\n");
    	printf("********9.退出                              *********\n");
    }
    int main()
    {
    	SqList L; int choice;
    	InitList(L);
    	while (1)
    	{
    		menu();
    		printf("请输入菜单序号:\n");
    		scanf("%d", &choice);
    		if (9 == choice) break;
    		switch (choice)
    		{
    		case 1:Create(L); break;
    		case 2:Insert(L); break;
    		case 3:Delete(L); break;
    		case 4:Search(L); break;
    		case 5:Reverse(L); break;
    		case 6:SplitSort(L); break;
    		case 7:PrintList(L); break;
    		case 8:ClearList(L); break;
    		default:printf("输入错误!!!\n");
    		}
    	}
    	return 0;
    }

    结果截图:

    插入结果截图
    删除结果截图
    查找结果截图
    输出结果截图

    ---------------------------------------------2018-09-18更新 添加创建函数 菜单有改动-----------------------------------------

                                                                     

     

    ---------------------------------------------20191012更新 添加Reverse函数--------------------------------------------

    根据下方评论,添加了倒置函数,参考stl的Reverse写法

    template <class _RandomAccessIter>
    _STLP_INLINE_LOOP void
    __reverse(_RandomAccessIter __first, _RandomAccessIter __last, const random_access_iterator_tag &) {
      for (; __first < __last; ++__first)
        _STLP_STD::iter_swap(__first, --__last);
    }
    倒置展示

    2019年10月23日更新,应评论区小伙伴的要求,添加了奇偶分开,并排序的函数

    //奇偶分开并排序
    void SplitSort(SqList &L)
    {
    	int Even = 0;
    	int Odd = L.length - 1;
    	int i = 0;
    	int j = L.length - 1;
    	bool flag = false;
    	if (L.length)
    		for (; i < j; i++, j--)
    		{
    			while (L.data[i] % 2 != 0)i++;
    			while (L.data[j] % 2 == 0)j--;
    			if (L.data[i] % 2 == 0 && L.data[j] % 2 != 0&&i<j)
    			{
    				int temp = L.data[i];
    				L.data[i] = L.data[j];
    				L.data[j] = temp;
    				flag = true;
    			}
    			if(!flag) //没有交换
    			{
    				Even = L.length - 1;//全奇数
    				Odd = 0; //全偶数
    			}
    		}
    	if (flag)
    	{
    		for(int i=0;i<L.length;i++)
    			if (L.data[i] % 2 == 0) 
    			{
    				Odd = i;
    				Even = i - 1;
    				break;
    			}
    	}
    	sort(L.data, L.data + Even + 1);
    	sort(L.data + Odd, L.data + L.length);
    }
    测试全奇偶

     

    有奇偶

    代码已更新至上方全部代码!!!

    -------------------------20200819修改 添加ClearList-------------------------------------

    代码由评论区用户__BlackHole提供,已更新至上方全部代码。

    至于销毁,我是使用的静态分配,如果是new(delete释放)或malloc(free释放)的话,需要释放空间,其实就是堆和栈的区别。

    堆和栈的区别就是申请方式不同:栈是系统自动分配空间,而堆则是程序员根据需要申请空间。由于栈上的空间是自动分配自动回收的,所以,栈内数据的生存周期只是在函数的运行过程中,运行后就释放掉。而堆上的数据只要程序员不释放空间,就一直可以访问到,缺点是一旦忘记释放会造成内存泄露。

    综上,我写的顺序表不需要进行销毁,当然,顺序表最大长度也固定了,各有利弊,如果是动态分配的话记得释放空间呀!

    更多数据结构与算法的实现:数据结构(严蔚敏版)与算法的实现(含全部代码)

    本人b站账号:lady_killer9

    有问题请下方评论,转载请注明出处,并附有原文链接,谢谢!如有侵权,请及时联系。如果您感觉有所收获,自愿打赏,可选择支付宝18833895206(小于),您的支持是我不断更新的动力。

    展开全文
  • 数据结构顺序表基本操作(C/C++实现)

    千次阅读 多人点赞 2019-10-22 23:23:01
    数据结构顺序表基本操作(C/C++实现) 涉及基本运算 初始化顺序表L 依次插入abcde元素 输出顺序表L 输出顺序表L的长度 判断顺序表L是否为空 输出顺序表L的第3个元素 输出元素a的位置 在第4个元素位置上插入f元素 ...

    数据结构顺序表基本操作(C/C++实现)

    注意:本代码为了测试运行默认含有操作所需数据,如有需要可自己增删改相关数据

    涉及基本运算

    1. 初始化顺序表
    2. 依次插入元素
    3. 输出顺序表
    4. 输出顺序表的长度
    5. 判断顺序表是否为空
    6. 输出顺序表的第n个元素
    7. 输出元素x的位置
    8. 在第n个元素位置上插入x元素
    9. 输出顺序表
    10. 删除顺序表的第n个元素
    11. 输出顺序表
    12. 释放顺序表

    GitHub地址(包含.cpp文件和可执行程序exe)

    我的数据结构GitHub地址

    源代码(经VS2015、devC++编译器运行通过)

    #include "stdio.h"    
    #include "stdlib.h"   
    #include "io.h"  
    #include "math.h"  
    #include "time.h"
    
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    
    #define MAXSIZE 20 /* 存储空间初始分配量 */
    
    typedef int Status;          /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
    typedef char ElemType;        /* ElemType类型根据实际情况而定,这里假设为int */
    
    
    Status visit(ElemType c)
    {
    	printf("%c ", c);
    	return OK;
    }
    
    typedef struct
    {
    	ElemType data[MAXSIZE];        /* 数组,存储数据元素 */
    	int length;                                /* 线性表当前长度 */
    }SqList;
    
    /* 1.初始化顺序线性表 */
    Status InitList(SqList *L)
    {
    	L->length = 0;
    	return OK;
    }
    
    /* 2.初始条件:顺序线性表L已存在,1≤i≤ListLength(L), */
    /* 操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1 */
    Status ListInsert(SqList *L, int i, ElemType e)
    {
    	int k;
    	if (L->length == MAXSIZE)  /* 顺序线性表已经满 */
    		return ERROR;
    	if (i<1 || i>L->length + 1)/* 当i比第一位置小或者比最后一位置后一位置还要大时 */
    		return ERROR;
    
    	if (i <= L->length)        /* 若插入数据位置不在表尾 */
    	{
    		for (k = L->length - 1; k >= i - 1; k--)  /* 将要插入位置之后的数据元素向后移动一位 */
    			L->data[k + 1] = L->data[k];
    	}
    	L->data[i - 1] = e;          /* 将新元素插入 */
    	L->length++;
    
    	return OK;
    }
    
    
    /* 3.初始条件:顺序线性表L已存在 */
    /* 操作结果:依次对L的每个数据元素输出 */
    Status ListTraverse(SqList L)
    {
    	int i;
    	for (i = 0; i<L.length; i++)
    		visit(L.data[i]);
    	printf("\n");
    	return OK;
    }
    
    /* 4.初始条件:顺序线性表L已存在。
    操作结果:返回L中数据元素个数 */
    int ListLength(SqList L)
    {
    	return L.length;
    }
    
    /* 5.初始条件:顺序线性表L已存在。
    操作结果:若L为空表,则返回TRUE,否则返回FALSE */
    Status ListEmpty(SqList L)
    {
    	if (L.length == 0)
    		return TRUE;
    	else
    		return FALSE;
    }
    
    /* 6.初始条件:顺序线性表L已存在,1≤i≤ListLength(L) */
    /* 操作结果:用e返回L中第i个数据元素的值,注意i是指位置,第1个位置的数组是从0开始 */
    Status GetElem(SqList L, int i, ElemType *e)
    {
    	if (L.length == 0 || i<1 || i>L.length)
    		return ERROR;
    	*e = L.data[i - 1];
    
    	return OK;
    }
    
    /* 7.初始条件:顺序线性表L已存在 */
    /* 操作结果:返回L中第1个与e满足关系的数据元素的位序。 */
    /* 若这样的数据元素不存在,则返回值为0 */
    int LocateElem(SqList L, ElemType e)
    {
    	int i;
    	if (L.length == 0)
    		return 0;
    	for (i = 0; i<L.length; i++)
    	{
    		if (L.data[i] == e)
    			break;
    	}
    	if (i >= L.length)
    		return 0;
    
    	return i + 1;
    }
    
    
    
    /* 初始条件:顺序线性表L已存在。
    操作结果:将L重置为空表 */
    Status ClearList(SqList *L)
    {
    	L->length = 0;
    	return OK;
    }
    
    
    
    
    
    
    
    /* 10.初始条件:顺序线性表L已存在,1≤i≤ListLength(L) */
    /* 操作结果:删除L的第i个数据元素,并用e返回其值,L的长度减1 */
    Status ListDelete(SqList *L, int i, ElemType *e)
    {
    	int k;
    	if (L->length == 0)               /* 线性表为空 */
    		return ERROR;
    	if (i<1 || i>L->length)         /* 删除位置不正确 */
    		return ERROR;
    	*e = L->data[i - 1];
    	if (i<L->length)                /* 如果删除不是最后位置 */
    	{
    		for (k = i; k<L->length; k++)/* 将删除位置后继元素前移 */
    			L->data[k - 1] = L->data[k];
    	}
    	L->length--;
    	return OK;
    }
    
    void unionL(SqList *La, SqList Lb)
    {
    	int La_len, Lb_len, i;
    	ElemType e;
    	La_len = ListLength(*La);
    	Lb_len = ListLength(Lb);
    	for (i = 1; i <= Lb_len; i++)
    	{
    		GetElem(Lb, i, &e);
    		if (!LocateElem(*La, e))
    			ListInsert(La, ++La_len, e);
    	}
    }
    
    int main()
    {
    
    	SqList L;
    	SqList Lb;
    
    	ElemType e;
    	Status i;
    	int j, k;
    	/*1.初始化*/
    	i = InitList(&L);
    	printf("1.初始化L后:L.length=%d\n", L.length);
    
    	/*2.依次插入abcde*/
    	i = ListInsert(&L, 1, 'e');
    	i = ListInsert(&L, 1, 'd');
    	i = ListInsert(&L, 1, 'c');
    	i = ListInsert(&L, 1, 'b');
    	i = ListInsert(&L, 1, 'a');
    	printf("2.abcde插入执行完毕\n");
    
    	/*3.输出顺序表*/
    	printf("3.在L的表头依次插入a~e后:L.data=\n");
    	ListTraverse(L);
    
    	/*4.顺序表长度*/
    	printf("4.L.length=%d \n", L.length);
    
    	/*5.判空*/
    	i = ListEmpty(L);
    	printf("5.L是否空:i=%d(1:是 0:否)\n", i);
    
    	/*6.输出顺序表L的第三个元素*/
    	GetElem(L, 3, &e);
    	printf("6.第3个元素的值为:%c\n", e);
    
    	/*7.输出顺序表a的位置*/
    	int l = LocateElem(L, 'a');
    	printf("7.返回元素a的位序:%d\n", l);
    
    	/*8.在第4个元素位置上插入f元素*/
    	i = ListInsert(&L, 5, 'f');
    	printf("8.在第4个元素位置上插入f元素执行完毕\n", L.length);
    
    	/*9.输出顺序表*/
    	printf("9.在L的第4个元素位置上插入f元素后:L.data=\n");
    	ListTraverse(L);
    
    	/*10.删除顺序表L的第三个元素*/
    
    	i = ListDelete(&L, 3, &e); /* 删除第j个数据 */
    	if (i == ERROR)
    		printf("删除第%d个数据失败\n", 3);
    	else
    		printf("10.删除第个的元素成功\n");
    
    	/*11.输出顺序表L*/
    	printf("11.输出顺序表\n");
    	ListTraverse(L);
    
    	/*12.释放顺序表*/
    	i = ClearList(&L);
    	printf("释放顺序表执行完毕\n"); 
    	system("pause");
    		return 0;
    }
    
    
    
    
    
    展开全文
  • 1.编写程序实现顺序表的下列基本操作: (1)初始化顺序表La。 (2)将La置为空表。 (3)销毁La。 (4)在La中插入一个新的元素。 (5)删除La中的某一元素。 (6)在La中查找某元素,若找到,则返回它在La中第一次出现...
  • 线性表、顺序表基本操作的编程实现 二、实验要求 线性表、顺序表基本操作的编程实现,掌握线性表、顺序表的建立、遍历、插入、删除、读取等基本操作的编程实现,也可以进一步编程实现逆序等操作,存储结构可以采用...
  • 顺序表基本操作实现(详细)

    千次阅读 2019-04-12 14:03:41
    动态顺序表基本操作4.0包含头文件和结构体4.1初始化,销毁,扩容4.2尾插,尾删,头插,头删4.3任意位置的插入和删除4.4移除指定值的元素4.5其它简单操作5.测试函数 1.顺序表的概念 (1)顺序结构-----------将表...
  • #define MAXSIZE 100 //顺序表的最大长度; int k=0;//全局变量,用于循环; typedef int elemtype;//元素类型; typedef struct{ elemtype data[MAXSIZE];//用数组存储线性表的元素; int length;//顺序表的长度...
  • 顺序表基本操作(函数)

    千次阅读 2018-09-10 15:22:17
    6-2 顺序表基本操作(10 分) 本题要求实现顺序表元素的增、删、查找以及顺序表输出共4个基本操作函数。L是一个顺序表,函数Status ListInsert_Sq(SqList &amp;L, int pos, ElemType e)是在顺序表的pos位置...
  • 数据结构—顺序表基本操作(c语言代码)

    万次阅读 多人点赞 2018-04-21 17:23:31
    创建一个静态的顺序表存放整数,大小为10,完成以下的操作 1.输入6个整数,打印出顺序表的内容,并显示表中剩余空间的个数 2.在顺序表的第三个位置处插入元素0,打印出表中的内容,并显示空间中剩余的个数 3.再试图...
  • 顺序表基本操作归纳整理

    千次阅读 2017-07-26 20:23:41
    Think: 本篇blog主要 包括顺序表的4中基本操作 查询 ,插入, 移位, 删除#include #include #include #define LISTINCREASMENT 100 /*每次分配元素的个数*/ #define LISTSIZE 10
  • 2. 顺序表基本操作的实现;3. 掌握利用C/C++编程语言实现数据结构的编程方法;4. 通过上机时间加强利用数据结构解决实际应用问题的能力;二、 实验相关知识1. 线性表的顺序存储结构的实现;2. 线性表的应用三...
  • 【PTA】6-1 顺序表基本操作(10 分)

    千次阅读 2018-09-06 21:53:28
    题目来自 网络与信息安全-... 6-1 顺序表基本操作(10 分) 本题要求实现顺序表元素的增、删、查找以及顺序表输出共4个基本操作函数。L是一个顺序表,函数Status ListInsert_Sq(SqList &amp;L, int pos, ElemT...
  • 6-2 顺序表基本操作 (10 分)

    千次阅读 2018-12-11 20:44:44
    6-2 顺序表基本操作 (10 分) 本题要求实现顺序表元素的增、删、查找以及顺序表输出共4个基本操作函数。L是一个顺序表,函数Status ListInsert_Sq(SqList &amp;L, int pos, ElemType e)是在顺序表的pos位置...
  • 主要为大家详细介绍了C++顺序表基本操作,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 顺序表基本操作C++实现

    千次阅读 多人点赞 2017-12-06 16:42:42
    //输出顺序表中所有元素 int GetLength(); //获取顺序表的长度 bool GetElem( int , int &elem); // 获取顺序表中的某个元素 bool ListInsert( int i, int elem); // 插入元素 bool ...
  • class SqList: #顺序表 def __init__(self): #构建空表 self.elem = [] def listAppend(self, item): #插入元素item在表尾 self.elem.append(item) def listInsert(self, item,index)...
  • C++实现顺序表基本操作

    千次阅读 2020-01-15 17:00:26
    此代码按照上篇博客线线性表基础概念,顺序表实现将概念用代码实现 #include<stdio.h> #include<iostream> using namespace std; //函数结果状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 546,410
精华内容 218,564
关键字:

顺序表的基本操作