顺序表 订阅
顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中,即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系,采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 [1] 展开全文
顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中,即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系,采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 [1]
信息
结    构
存储结构
外文名
Contiguous List
中文名
顺序表
形    式
数组
顺序表简介
将表中元素一个接一个的存入一组连续的存储单元中,这种存储结构是顺序结构。采用顺序存储结构的线性表简称为“ 顺序表”。顺序表的存储特点是:只要确定了起始位置,表中任一元素的地址都通过下列公式得到:LOC(ai)=LOC(a1)+(i-1)*L  1≤i≤n 其中,L是元素占用存储单元的长度。顺序表的结构定义:#define maxlen 50 //定义顺序表中元素个数最多有几个 typedef struct{elementtype data[maxlen]; //elementtype是元素的类型 依具体情况而定int listlen; //便于时刻了解顺序表里元素的个数}seqlist; //顺序表的名称 不妨为seqlist声明顺序表类型变量:seqlist L,L1;如顺序表的每个结点占用len个内存单元,用location (ki)表示顺序表中第i个结点ki所占内存空间的第1个单元的地址。则有如下的关系:location (ki+1) = location (ki) +lenlocation (ki) = location(k1) + (i-1)len存储结构要体现数据的逻辑结构,顺序表的存储结构中,内存中物理地址相邻的结点一定具有顺序表中的逻辑关系。 [2] 
收起全文
精华内容
下载资源
问答
  • 顺序表

    千次阅读 多人点赞 2019-11-06 08:49:33
    顺序表是什么呢? 顾名思义,顺序表是物理地址连续的存储单元依次存储数据的线性结构,一般情况下采用数组存储,在数组上完成数据的增删查改。 顺序表和数组有什么区别呢? 顺序表比数组更约束,顺序表物理地址上...

    顺序表是什么呢?
    顾名思义,顺序表是物理地址连续的存储单元依次存储数据的线性结构,一般情况下采用数组存储,在数组上完成数据的增删查改。
    在这里插入图片描述
    顺序表和数组有什么区别呢?
    顺序表比数组更约束,顺序表物理地址上必须连续存储,数组是顺序表在实际编程中的具体实现方式。

    顺序表分为静态顺序表和静态顺序表(主要区别在于他们的容量是否可变)

    静态顺序表

    静态顺序表的概念

    顺序表的容量在静态时期(编译期间)确定,大小不可改变。

    静态顺序表的创建
    typedef struct SeqList{
    	int array[100];
    	int size;//顺序表中实际存储的数据个数
    }SeqList;//别名
    

    静态顺序表相对来比较简单,我们这里就不做深入的讨论,接下来主要了解一下动态顺序表。

    动态顺序表

    动态顺序表的概念

    顺序表的容量在动态时期(运行期间)确定,大小可改变。

    动态顺序表的创建
    typedef struct SeqList{
    	int* array;//动态从堆上申请
    	int capacity;//容量
    	int size;//有效数据的个数  尾插时,可用位置的下标
    }SeqList;
    
    动态顺序表的初始化

    Main.c
    初始化顺序表传参时应该传&seqlist,用结构体指针来接收 SeqList ✳ps,并且还应传顺序表的容量capacity。

    	SeqList seqlist;
     	SeqListInit(&seqlist,10);
    

    SeqList.h

    void SeqListInit(SeqList *ps,int capacity);
    

    SeqList.c

    void SeqListInit(SeqList *ps,int capacity){
    	ps->array = malloc(sizeof(int) * capacity);//申请空间大小
    	assert(ps->array != NULL);
    	ps->size = 0;
    	ps->capacity = capacity;
    }
    
    动态顺序表的销毁

    Main.c
    这里传参依旧是&seqlist,注意释放顺序表空间free(ps->array),销毁时传参不需要传顺序表的容量。

    SeqListDestroy(&seqlist);
    

    SeqList.h

    void SeqListDestroy(SeqList *ps);
    

    SeqList.c

    void SeqListDestroy(SeqList *ps){
    	//释放 array 的空间
    	free(ps->array);
    	//锦上添花
    	ps->array = NULL;
    	ps->size = 0;
    	ps->capacity = 0;
    
    }
    
    动态顺序表的扩容

    当顺序表的容量不够用时,我们应该怎么办呢?当然是扩大顺序表的容量。
    在这里插入图片描述
    具体步骤:
    1.当size(实际存储)>=capacity(顺序表容量)时,顺序表执行扩容。
    2.扩容一般是两倍增长,新顺序表是原顺序表容量的2倍大小。(缺陷:会造成空间的浪费)int newCapacity = ps->capacity * 2;
    3.注意:不是在原顺序表的基础上增加容量,而是新建一个顺序表。int *newArray = (int*)malloc(sizeof(int)*newCapacity);

    4.将原来顺序表的数据加载到新的顺序表中。
    for (int i = 0; i < ps->sz; i++){ newArray[i] = ps->array[i]; }
    5.扩容完成,释放原来顺序表的内存。
    free(ps->array);
    6.将array的关系指向新的顺序表。
    ps->array = newArray;
    7.改变capacity
    ps->capacity = newCapacity;

    static void CheckCapacity(SeqList *ps){
    	if (ps->size < ps->capacity){
    		return;
    	}
    	//需要扩容
    	int newCapacity = ps->capacity * 2;
    	int *newArray = (int*)malloc(sizeof(int)*newCapacity);
    	assert(newArray != NULL);
    
    	//搬移
    	for (int i = 0; i < ps->size; i++){
    		newArray[i] = ps->array[i];
    	}
    
    	//释放老空间
    	free(ps->array);
    	ps->array = newArray;
    	ps->capacity = newCapacity;
    }
    
    
    动态顺序表的插入(头插,尾插,根据pos下标插入)

    尾插
    在这里插入图片描述
    尾插时,顺序表有效数据的个数就是尾插时可用位置的下标。
    完成尾插之后,使有效数据个数size++。

    void SeqListPushBack(SeqList *ps, int v);
    
    void SeqListPushBack(SeqList *ps, int v){
    	CheckCapacity(ps);
    	ps->array[ps->size] = v;
    	ps->size++;
    }
    

    头插
    在这里插入图片描述
    头插可以直接将数据插到顺序表的首位吗?很显然是不行的,因为顺序表首位已经有了数据。
    头插时,应从后向前依次将数据向后搬移一位,将首位腾出给目标数据插入。

    void SeqListPushFront(SeqList *ps, int v);
    
    void SeqListPushFront(SeqList *ps, int v){
    	CheckCapacity(ps);
    	//i表示空间下标
    	for (int i = ps->size; i >= 1; i--){
    		ps->array[i] = ps->array[i - 1];
    	}
    	ps->array[0] = v;
    	ps->size++;
    }
    

    根据pos下标插入
    在这里插入图片描述
    将下标为pos及pos之后的数据向后移动一位,使ps->array[pos]=v。

    void SeqListInsert(SeqList *ps, int pos, int v);
    
    void SeqListInsert(SeqList *ps, int pos, int v){
    	CheckCapacity(ps);
    	//pos = 0为头插  pos = size为尾插
    	assert(pos >= 0 && pos <= ps->size);
    	//i代表数据的下标
    	for (int i = ps->size - 1; i >= pos; i--){
    		ps->array[i + 1] = ps->array[i];
    	}
    
    	ps->array[pos] = v;
    	ps->size++;
    }
    
    动态顺序表的删除(头删,尾删,根据pos下标删除)

    尾删
    在这里插入图片描述
    直接使顺序表size--

    void SeqListPopBack(SeqList *ps);
    
    
    void SeqListPopBack(SeqList *ps){
    	assert(ps->size > 0);
    	ps->size--;
    }
    

    头删
    在这里插入图片描述
    直接前移覆盖第一个数据

    void SeqListPopFront(SeqList *ps);
    
    void SeqListPopFront(SeqList *ps){
    	assert(ps->size > 0);
    	//i代表空间的下标
    	for (int i = 0; i <= ps->size - 2; i++){
    		ps->array[i] = ps->array[i + 1];
    	}
    	ps->size--;
    }
    

    根据pos下标删除
    在这里插入图片描述
    将pos+1及以后的数据依次前移

    void SeqListErase(SeqList *ps, int pos);
    
    void SeqListErase(SeqList *ps, int pos){
    	assert(ps->size > 0);
    	assert(pos >= 0 && pos < ps->size);
    	//i代表数据的下标
    	for (int i = pos + 1; i <= ps->size - 1; i++){
    		ps->array[i - 1] = ps->array[i];
    	}
    	ps->size--;
    }
    

    删除第一个遇到的目标元素
    调用查找和根据pos下标删除的函数即可

    int SeqListRemove(SeqList *ps, int v);
    
    int SeqListRemove(SeqList *ps, int v){
    	int pos = SeqListFind(ps, v);
    	if (pos = -1){
    		return;
    	}
    
    	SeqListErase(ps, pos);
    
    }
    

    删除所有的目标元素
    在这里插入图片描述
    定义i 和 j,若没有遇到目标元素,i++,j++,若遇到目标元素i++,j不动,直到i找到下一个不是目标元素的值,将值赋给j下标所在的数据,即可完成替换目标元素。

    int SeqListRemoveAll(SeqList *ps, int v);
    
    int SeqListRemoveAll(SeqList *ps, int v){
    	int i, j;
    	for (i = 0, j = 0; i < ps->size; i++){
    		if (ps->array[i] != v){
    			ps->array[j] = ps->array[i];
    			j++;
    		}
    	}
    	ps->size = j;
    }
    
    动态顺序表的查找

    遍历顺序表查找

    int SeqListFind(SeqList *ps, int v);
    
    int SeqListFind(SeqList *ps, int v){
    	for (int i = 0; i < ps->size; i++){
    		if (ps->array[i] = v){
    			return i;
    		}
    	}
    	return -1;
    }
    
    动态顺序表的更新

    目标数据直接替换pos下标所在数据

    void SeqListModify(SeqList *ps, int pos, int v);
    
    void SeqListModify(SeqList *ps, int pos, int v){
    	assert(pos >= 0 && pos < ps->size);
    	ps->array[pos] = v;
    }
    

    到这里顺序表的基本问题就解释完了,相信多多少少会解决大家心头的疑问,在数据结构的学习中应当善于思考,多画图,死磕代码,注意细节,将伪代码转换为代码,这样才能很好的掌握数据结构的有关知识。

    展开全文
  • 顺序表的基本操作

    2017-09-18 23:24:03
    本资源是:线性表中的顺序表的一些操作,包括初始化顺序表、建立顺序表、删除顺序表、在顺序表中插入元素,在顺序表中删除元素、判断空的等一些基本操作。
  • 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;
    }
    
    
    展开全文
  • C++实现简单顺序表

    千次阅读 2017-10-01 12:26:36
    顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。即线性表采用顺序存储的方式存储就称之为顺序表。在C语言中,我们通过创建一个结构体的方式来实现了...

              顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。即线性表采用顺序存储的方式存储就称之为顺序表。在C语言中,我们通过创建一个结构体的方式来实现了顺序表,在C++中可通过创建一个类的形式来创建一个顺序表。

    直接来看代码:

    #include <iostream>
    using namespace std;
    #include <assert.h>
    
    typedef int DataType;
    class SeqList
    {
    public:
    	// 思考两种方式的优缺点 
    	SeqList(DataType* array, size_t size)//构造函数
    		: _array(new DataType[size])
    		, _capacity(size)
    		, _size(size)
    	{
    		// 1、循环逐个搬移-缺陷:效率低 正确性 
    		for (size_t i = 0; i < size; ++i)
    			_array[i] = array[i];
    
    		// 2、优点:效率高--->问题?---可能会出错 
    		//memcpy(_array, array, size*sizeof(array[0])); 
    	}
    
    	// 三大big 
    	SeqList(const SeqList& s);
    	SeqList& operator=(const SeqList& s);//拷贝构造函数
    	~SeqList()//析构函数
    	{
    		if (_array)
    		{
    			delete[] _array;
    			_size = 0;
    			_capacity = 0;
    		}
    	}
    
    	void PushBack(int data);//后增
    	void PopBack();//后删
    	void Insert(size_t pos, DataType data);//任意位置增
    	void Erase(size_t pos);//任意位置删
    	size_t Size()const;//求顺序表大小
    	size_t Capacity()const;//求顺序表容量
    	bool Empty()const;//判断顺序表是否为空
    	DataType& operator[](size_t index);//[]操作符重载
    	const DataType& operator[](size_t index)const;
    
    	DataType& Front();// 返回顺序表中的第一个元素 
    	const DataType& Front()const; 
    	
    	DataType& Back();// 返回顺序表中最后一个元素
    	const DataType& Back()const;
    
    	void Clear();// 清空顺序表中的所有元素 
    
    	// 将顺序表中元素个数改变到newSize 
    	void ReSize(size_t newSize, const DataType& data = DataType());
    	//输出运算符重载
    	friend ostream& operator<<(ostream& _cout, const SeqList& s);
    
    private:
    	void _CheckCapacity();
    private:
    	DataType* _array;
    	size_t _size;
    	size_t _capacity;
    };
    
    //拷贝构造
    SeqList::SeqList(const SeqList& s)
    {
    	if (s._array != _array)
    	{
    		_array = new DataType[s._capacity];
    		_size = s._size;
    		_capacity = s._capacity;
    
    		for (size_t i = 0; i < _size; i++)
    		{
    			_array[i] = s._array[i];
    		}
    	}
    }
    
    //重载=
    SeqList& SeqList::operator=(const SeqList& s)
    {
    	if (s._array != _array)
    	{
    		_size = s._size;
    		_capacity = s._capacity;
    
    		for (size_t i = 0; i < _size; i++)
    		{
    			_array[i] = s._array[i];
    		}
    	}
    	return *this;
    }
    
    //后增
    void SeqList::PushBack(int data)
    {
    	if (_size < _capacity)
    	{
    		_array[_size] = data;
    		_size += 1;
    	}
    
    	else
    	{
    		DataType * temp = new DataType[_capacity + _size];
    
    		for (size_t i = 0; i < _size; i++)
    		{
    			temp[i] = _array[i];
    		}
    
    		temp[_size] = data;
    		_capacity += _size;
    		_size++;
    
    		delete[] _array;
    		_array = temp;
    	}
    }
    
    //后删
    void SeqList::PopBack()
    {
    	if (_size == 0)
    	{
    		return;
    	}
    	else
    	{
    		_size--;
    	}
    }
    
    //任意位置增
    void SeqList::Insert(size_t pos, DataType data)
    {
    	if (pos < _size)
    	{
    		if (_size < _capacity)
    		{
    			//将pos位置及之后的往后挪一个位置
    			for (size_t i = _size; i>=pos; i--)
    			{
    				_array[i] = _array[i - 1];
    			}
    
    			_array[pos] = data;
    			_size++;
    		}
    
    		else if (_size==_capacity)//增加元素就需要开辟新的空间
    		{
    			DataType * temp = new DataType[_capacity + _size];
    			size_t i = 0;
    
    			for (i = 0; i < _size; i++)//拷贝原来的元素
    			{
    				temp[i] = _array[i];
    			}
    
    			_array[pos] = data;
    
    			delete[] _array;
    			_array = temp;
    		}
    	}
    	else
    	{
    		cout << "输入位置有误\n";
    	}
    }
    
    //任意位置删
    void SeqList::Erase(size_t pos)
    {
    	//将Pos位置的数据覆盖掉(前挪)
    	for (size_t i = pos; i < _size; i++)
    	{
    		_array[i] = _array[i + 1];
    	}
    	_size--;
    }
    
    size_t SeqList::Size()const
    {
    	return _size;
    }
    
    size_t SeqList::Capacity()const
    {
    	return _capacity;
    }
    
    DataType& SeqList::operator[](size_t index)
    {
    	DataType * temp = _array;
    	return temp[index];
    }
    
    const DataType& SeqList::operator[](size_t index)const
    {
    	DataType * temp = _array;
    	return temp[index];
    }
    
    // 返回顺序表中的第一个元素 
    DataType& SeqList::Front()
    {
    	assert(0 != _size);
    	return _array[0];
    }
    
    const DataType& SeqList::Front()const
    {
    	assert(0 != _size);
    	return _array[0];
    }
    
    // 返回顺序表中最后一个元素 
    DataType& SeqList::Back()
    {
    	assert(0 != _size);
    	return _array[_size - 1];
    }
    
    const DataType& SeqList::Back()const
    {
    	assert(0 != _size);
    	return _array[_size - 1];
    }
    
    // 将顺序表中元素个数改变到newSize 
    void SeqList::ReSize(size_t newSize, const DataType& data)
    {
    	if (newSize <= _capacity)
    	{
    		_size = newSize;
    	}
    	else
    	{
    		size_t i = 0;
    		DataType * temp = new DataType[newSize];
    
    		for (i = 0; i < _size; i++)
    		{
    			temp[i] = _array[i];
    		}
    
    		for (i = _size; i < newSize; i++)
    		{
    			temp[i] = data;
    		}
    
    		_size = newSize;
    		_capacity = _size;
    		delete[] _array;
    		_array = temp;
    	}
    }
    
    // 清空顺序表中的所有元素 
    void SeqList::Clear()
    {
    	_size = 0;
    	_capacity = 0;
    }
    
    //判断顺序表是否为空
    bool SeqList::Empty() const
    {
    	if (_size == 0)
    		return 1;
    	else
    		return 0;
    }
    
    //对输出操作符<<重载
    ostream& operator<<(ostream& _cout, const SeqList& s)
    {
    	for (size_t i = 0; i < s._size; i++)
    	{
    		_cout << s._array[i] << ' ';
    	}
    
    	_cout << endl;
    	_cout << s._size << endl;
    	_cout << s._capacity;
    	return _cout;
    }
    
    DataType array[] = { 1, 2, 3, 4, 5 };
    SeqList List(array,5);
    
    void FunTest1()
    {
    	cout << List<<endl;
    
    	cout << "后增" << endl;
    	List.PushBack(6);
    	List.PushBack(7);
    	List.PushBack(8);
    	cout << List << endl;
    
    	cout << "后删" << endl;
    	List.PopBack();
    	List.PopBack();
    	cout << List<<endl; 
    	cout <<  endl;
    
    	cout << "任意位置增、删" << endl;
    	List.Insert(2, 7);
    	cout << List << endl;
    	List.Erase(3);
    	cout << List << endl;
    }
    
    void FunTest2()
    {
    	cout << List << endl;
    
    	size_t size = List.Size();
    	cout << "size=" <<size << endl;
    
    	size_t capacity = List.Capacity();
    	cout << "capacity=" << capacity << endl;
    
    	List.ReSize(8, 9);
    	cout << "重置后" << endl;
    	cout << List << endl;
    }
    void FunTest3()
    {
    	cout << List << endl;
    
    	DataType ret1 = List.Front();
    	cout << "first data is:" << ret1 << endl;
    
    	DataType ret2 = List.Back();
    	cout << "last data is:" << ret2 << endl;
    
    	cout << List[1] << endl;
    }
    
    void FunTest4()
    {
    	cout << List << endl;
    
    	List.Clear();
    	cout << "cleared" << endl;
    
    	bool ret = List.Empty();
    	if (ret)
    	{
    		cout << "EMPTY" << endl;
    	}
    	else
    	{
    		cout << "NOT EMPTY" << endl;
    	}
    }
    
    int main()
    {
    	FunTest1();//测试后增后删,任意位置增,删
    	//FunTest2();//测试求大小、容量,重置容量
    	//FunTest3();//测试获取首位、末位,任意位置元素
    	//FunTest4();//测试清空函数及判断是否为空
    	return 0;
    }

    说明:对于主函数里面调用的测试函数,想要测试哪部分函数功能就将相应的测试函数取消注释,这样更有利于观测其函数功能。



    PS:欢迎提出任何建议,谢谢!


    展开全文
  • 【数据结构】顺序表的c语言实现

    千次阅读 多人点赞 2019-05-18 15:21:55
    文章目录顺序表的c语言实现定义顺序表结构体初始化顺序表操作计算顺序表的长度获取顺序表中元素新元素插入顺序表删除某位置的元素查询某元素的位置打印整个顺序表顺序表的整体源码 线性表的顺序存储是指用一组...

    顺序表的c语言实现

    线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素,使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中,即:通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。

    顺序储存线性表的特点

    1. 线性表的逻辑顺序与物理顺序一致;
    2. 数据元素之间的关系是以元素在计算机内“物理位置相邻”来体现。

    下面我们逐个实现顺序表的基本操作

    定义顺序表结构体

    typedef struct
    {
    	elemtype data[MAXSIZE];			//用数组储存顺序表中的元素
    	int length;						//顺序表的长度  元素的个数
    }SqList;
    

    初始化顺序表操作

    void InitList(SqList *L)			//初始化顺序表L
    {
    	L->length = 0;
    }
    

    只需将顺序表的长度置为0即可

    计算顺序表的长度

    int ListLength(SqList *L)			//返回顺序表的元素个数
    {
    	if (NULL == L)
    		return 0;
    	return L->length;
    }
    

    获取顺序表中元素

    int GetElem(SqList L, int i,elemtype *e)			//获得i位置的元素,用e返回
    {
    	if (L.length == 0 || i < 1 || i > L.length)
    	{
    		printf("输入有误,查询不到该位置的元素!\n");
    		return 0;
    	}
    	*e = L.data[i - 1];
    	return 0;
    }
    

    新元素插入顺序表

    int ListInsert(SqList *L, int i, elemtype e)					//在i位置插入一个元素e
    {
    	int k;
    	if (L->length == MAXSIZE)
    	{
    		printf("顺序表已满,不能再继续插入元素!\n");
    		return 0;
    	}
    	if (i < 1 || i > L->length + 1)
    	{
    		printf("插入位置不对,请重新输入!\n");
    		return 0;
    	}
    
    	for (k = L->length - 1; k >= i - 1; k--)		//将要插入元素后的每个元素都向后移一位
    		L->data[k + 1] = L->data[k];
    	L->data[i - 1] = e;					//将新元素插入
    	L->length++;
    	return 1;
    }
    
    

    删除某位置的元素

    int ListDelete(SqList *L, int i, elemtype *e)			//删除i位置的元素,并用e返回其值
    {
    	int k;
    	if (L->length == 0)
    		return 0;
    	if (i < 1 || i > L->length)
    	{
    		printf("输入有误,请重新输入!\n");
    		return 0;
    	}
    	*e = L->data[i - 1];
    	for (k = i; k < L->length; k++)				//将删除元素后的每个元素前移一位
    		L->data[k - 1] = L->data[k];
    	L->length--;
    	return 0;
    }
    
    

    查询某元素的位置

    int LocateElem(SqList L, elemtype e)				//查询元素e,如查到返回该元素的位置,反之,返回0
    {
    	int k;
    	for (k = 0; k < L.length; k++)
    	{
    		if (L.data[k] == e)
    		{
    			printf("已查到%d,%d的位置为:", e, e);
    			return k + 1;
    		}
    	}
    	return 0;
    }
    

    打印整个顺序表值

    int ShowList(SqList L)						//打印顺序表
    {
    	int i;
    	if (L.length == 0)
    	{
    		printf("顺序表为空!");
    		return 0;
    	}
    	for (i = 0; i < L.length; i++)
    	{
    		printf("第%d个元素为%d \n", i + 1, L.data[i]);
    	}
    	return 1;
    }
    

    顺序表的整体源码

    到此,顺序表的基本操作就已经完成了,下面附上源码

    源码:

    #include<stdio.h>
    #include<stdlib.h>
    #include<conio.h>
    #define MAXSIZE 100					//顺序表的最大长度
    typedef int elemtype;				//元素类型
    typedef struct
    {
    	elemtype data[MAXSIZE];			//用数组储存顺序表中的元素
    	int length;						//顺序表的长度  元素的个数
    }SqList;
    
    void InitList(SqList *L)			//初始化顺序表L
    {
    	L->length = 0;
    }
    
    int ListLength(SqList *L)			//返回顺序表的元素个数
    {
    	if (NULL == L)
    		return 0;
    	return L->length;
    }
    
    int GetElem(SqList L, int i,elemtype *e)			//获得i位置的元素,用e返回
    {
    	if (L.length == 0 || i < 1 || i > L.length)
    	{
    		printf("输入有误,查询不到该位置的元素!\n");
    		return 0;
    	}
    	*e = L.data[i - 1];
    	return 0;
    }
    
    int ListInsert(SqList *L, int i, elemtype e)					//在i位置插入一个元素e
    {
    	int k;
    	if (L->length == MAXSIZE)
    	{
    		printf("顺序表已满,不能再继续插入元素!\n");
    		return 0;
    	}
    	if (i < 1 || i > L->length + 1)
    	{
    		printf("插入位置不对,请重新输入!\n");
    		return 0;
    	}
    
    	for (k = L->length - 1; k >= i - 1; k--)		//将要插入元素后的每个元素都向后移一位
    		L->data[k + 1] = L->data[k];
    	L->data[i - 1] = e;					//将新元素插入
    	L->length++;
    	return 1;
    }
    
    int ListDelete(SqList *L, int i, elemtype *e)			//删除i位置的元素,并用e返回其值
    {
    	int k;
    	if (L->length == 0)
    		return 0;
    	if (i < 1 || i > L->length)
    	{
    		printf("输入有误,请重新输入!\n");
    		return 0;
    	}
    	*e = L->data[i - 1];
    	for (k = i; k < L->length; k++)				//将删除元素后的每个元素前移一位
    		L->data[k - 1] = L->data[k];
    	L->length--;
    	return 0;
    }
    
    int LocateElem(SqList L, elemtype e)				//查询元素e,如查到返回该元素的位置,反之,返回0
    {
    	int k;
    	for (k = 0; k < L.length; k++)
    	{
    		if (L.data[k] == e)
    		{
    			printf("已查到%d,%d的位置为:", e, e);
    			return k + 1;
    		}
    	}
    	return 0;
    }
    
    int ShowList(SqList L)						//打印顺序表
    {
    	int i;
    	if (L.length == 0)
    	{
    		printf("顺序表为空!");
    		return 0;
    	}
    	for (i = 0; i < L.length; i++)
    	{
    		printf("第%d个元素为%d \n", i + 1, L.data[i]);
    	}
    	return 1;
    }
    
    int main()
    {
    	elemtype e;
    	SqList list1;
    	InitList(&list1);
    	list1.data[0] = 1;
    	list1.data[1] = 2;
    	list1.data[2] = 3;
    	list1.data[3] = 13;
    	list1.data[4] = 23;
    	list1.data[5] = 54;
    	list1.length = 6;
    	printf("%d\n", LocateElem(list1, 23));
    	ShowList(list1);
    	printf("表长为%d\n", ListLength(&list1));
    	ListInsert(&list1, 7, 43);
    	printf("插入元素后的顺序表为:\n");
    	ShowList(list1);
    	printf("表长为%d\n", ListLength(&list1));
    	ListDelete(&list1, 4, &e);
    	printf("要删除的元素为%d\n", e);
    	printf("删除元素后的顺序表为:\n");
    	ShowList(list1);
    	printf("表长为%d\n", ListLength(&list1));
    	GetElem(list1, 4, &e);
    	printf("查询位置的元素为%d\n", e);
    	system("pause");
    	return 0;
    }
    
    展开全文
  • 将两个有序顺序表合并为一个新的有序顺序表

    万次阅读 多人点赞 2019-06-28 21:31:16
    将两个有序顺序表合并为一个新的有序顺序表题目要求基本思想核心代码完整代码(C++) 题目要求 将两个有序顺序表合并为一个新的有序顺序表,并由函数返回合并后的顺序表。 基本思想 非常经典的题目,哪怕死记硬背也...
  • 6-2 顺序表操作集 (20 分)

    千次阅读 2019-04-04 16:11:07
    6-2 顺序表操作集 (20 分) 本题要求实现顺序表的操作集。 函数接口定义: List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, ...
  • Python实现顺序表

    千次阅读 2020-01-18 18:41:17
    Python实现顺序表 关于顺序表的介绍,请参考:https://blog.csdn.net/weixin_43790276/article/details/103848039 Python 中的列表和元组都属于顺序表,下面根据顺序表的特性,自己来实现顺序表。 一、自定义一个...
  • c语言 顺序表的基本操作(创建、初始化、赋值、插入、删除、查询、替换、输出) 1、创建、申请空间 2、初始化、顺序表数据结构大小、长度 3、赋值、顺序表数据结构赋值 4、插入、在指定位置插入数据,后续数据...
  • 数据结构顺序表基本操作(C/C++实现)

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

    千次阅读 多人点赞 2019-09-24 17:02:55
    C语言顺序表 C语言顺序表 #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR -1 #define MAXSIZE 5 typedef char ElemType ; //声明顺序表的结构体类型 typedef struct{ ElemType...
  • 数据结构-顺序表基本操作的实现(含全部代码)

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

    千次阅读 2021-10-24 00:58:36
    顺序表的常用操作实现及测试: 初始化并建立顺序表 顺序表初始值输入 按位置插入 按位置删除 按值查询 按位置修改 去除顺序表重复元素 顺序表排序 顺序表遍历及输出 合并两个有序顺序表 代码(C语言): /*动态...
  • (1) 建立一个顺序表,含有n个数据元素。 (2) 输出顺序表顺序表的长度。 (3) 在顺序表给定的位置i,插入一个值为x的结点。 (4) 在顺序表中删除值为x的结点或者删除给定位置i的结点。 (5) 将顺序表逆置,...
  • c语言线性表-顺序表(完整版)

    千次阅读 多人点赞 2020-10-01 17:32:49
    这几天我尝试写写c语言顺序表,我是这样想的:在学链表之前,先搞懂顺序表。 不喜勿喷,本人新手,大多代码借鉴书上。如有错误之处,请原谅! 首先创建一个结构体: typedef struct { ElemType *elem;//存储空间的...
  • 分别创建两个有序的顺序表(每个表的元素个数及每个元素的值在运行时由键盘输入),现将两个有序表合并,并保证新表依然为有序的顺序表。 算法思想 先各自确定两个顺序表的长度并且各自输入对应长度的个数的...
  • 什么是顺序表

    千次阅读 2019-08-25 00:43:07
    顺序表 在程序中,经常需要将一组(通常是同为某个类型的)数据元素作为整体管理和使用,需要创建这种元素组,用变量记录它们,传进传出函数等。一组数据中包含的元素个数可能发生变化(可以增加或删除元素)。 对于...
  • 顺序表详解(C语言版)

    千次阅读 多人点赞 2020-09-27 22:44:24
    本文介绍了顺序表的定义和常见操作并使用C语言代码对其进行实现。
  • c语言顺序表的基本操作

    万次阅读 多人点赞 2018-06-30 15:18:36
    下面是顺序表的基本操作,c语言版的数据结构书上写的操作都实现了因为总体代码太长如果写在一个class中要近500行,阅读和修改都不方便,所以采用分开写,希望大家以后写较长的程序时也采用这种方法,自己运行的所有...
  • 顺序表(C++实现)

    万次阅读 多人点赞 2019-04-07 14:15:02
    一、实现要求 ...(5)将顺序表L中的奇数项和偶数项结点分解开(元素值为奇数、偶数),分别放入新的顺序表中,然后原表和新表元素同时输出到屏幕上,以便对照求解结果。 (6)求两个递增有序...
  • C语言创建顺序表并插入元素 详细注释

    万次阅读 多人点赞 2018-04-22 18:03:22
    顺序表是用一组地址连续的存储单元依次存储数据元素的数据结构。顺序表是线性表的一种,线性表是最常用且最简单的一种数据结构,一个线性表是 n 个数据元素的有限序列。我们使用 c 语言来创建顺序表并插入元素。IDE ...
  • 顺序存储(顺序表)

    万次阅读 多人点赞 2018-08-25 11:56:23
    1.顺序存储方式 线性表的顺序存储结构,就是在内存中找到一块空间,通过占位的方式,把一定内存空间给占了,然后把相同数据类型的数据元素依次存放在这块空间中,既然线性表的每个数据元素的类型相同,所以C语言...
  • 一、顺序表定义及特点 1.顺序表定义 2.顺序表特点 二、顺序表定义 三、顺序表插入运算 四、顺序表删除运算 五、顺序表元素查找 六、顺序表取元素数据 七、主函数定义 注1. typedef 解释 注2. 链表知识点...
  • 一、顺序表(顺序存储) (一)、定义(如何用代码实现) 线性表是具有相同数据类型的n(n >= 0)个数据元素的有限序列。 顺序表:用顺序存储的方式实现线性表顺序存储。 把逻辑上相邻的元素存储在物理位置上也相邻...
  • 数据结构--线性表与顺序表

    千次阅读 2020-12-08 11:24:31
    线性表是一种在实际中广泛使用的数据结构,常见的线性表:顺序表、链表、栈、队列、字符串… 线性表指的是在逻辑上是线性结构,也就是指连续的一条直线。但在物理结构上并不一定是连续的,线性表在物理上存储时,...
  • 数据结构-顺序表的顺序存储

    千次阅读 2019-11-11 09:54:41
    用一组地址连续的存储单元依次存储线性表中每个数据元素,这种存储结构称为线性表的顺序存储结构,用这种结构表示的线性表称为顺序表。 特点: 用数据元素在计算机内物理位置相邻来表示线性表中数据元素之间的...
  • 顺序表的基本操作(C语言实现,简单易懂!)

    千次阅读 多人点赞 2021-01-24 00:25:10
    一、学习内容:1、 创建顺序表 2、 按数值查找 3、 按位置查找 4、 插入一个数值 5、 删除一个数值 6、 销毁顺序表 7、 求前驱算法 8、 求后继算法
  • 数据结构——顺序表(定义详解及创立顺序表并操作) 顺序表定义:顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,375,970
精华内容 550,388
关键字:

顺序表