数据结构顺序表

数据结构顺序表
千次阅读 2016-04-26 16:52:07
数据结构顺序表
```
数据结构顺序表
```
收起
展开全文

数据结构顺序表

千次阅读 2018-12-09 01:54:14

顺序表的实现方法线性表顺序存储结构的建立 顺序表的基本操作 1、顺序表的初始化 2、在 pos 位置插入 val 值 3、从pos位置开始查找 key 值 4、删除 pos 位置的值 5、删除一个 key 值 6、得到pos位置的元素...

目录

线性表的顺序存储结构

顺序表的实现方法

线性表顺序存储结构的建立

顺序表的基本操作

1、顺序表的初始化

2、在 pos 位置插入 val 值

3、从pos位置开始查找 key 值

4、删除 pos 位置的值 

5、删除一个 key 值

6、得到pos位置的元素值

7、求顺序表长度

8、清空顺序表

9、打印顺序表

具有动态扩容的线性表顺序存储结构的建立

1、顺序表的初始化

2、判断顺序表是否为满

3、为顺序表动态扩容

4、在 pos 位置插入 val 值

5、释放动态开辟的存储空间

complete code

普通顺序表：

具有动态扩容的顺序表：

求两个顺序表的交集

求两个顺序表的并集

线性表的顺序存储结构

顺序存储结构是存储结构类型中的一种，该结构是把逻辑上相邻的结点存储在物理位置上相邻的存储单元中，结点之间的逻辑关系由存储单元的邻接关系来体现。


也就是说，逻辑上具有线性关系的数据按照前后的次序全部存储在一整块连续的内存空间中，之间不存在空隙，这样的存储结构称为顺序存储结构。


在计算机中用一组地址连续的存储单元依次存储线性表的各个数据元素，称作线性表的顺序存储结构。



使用顺序存储结构存储的数据，第一个元素所在的地址就是这块存储空间的首地址。通过首地址，可以轻松访问到存储的所有的数据。

顺序存储结构的主要优点是节省存储空间，因为分配给数据的存储单元全用存放结点的数据，结点之间的逻辑关系没有占用额外的存储空间。采用这种方法时，可实现对结点的随机存取，即每一个结点对应一个序号，由该序号可以直接计算出来结点的存储地址。但顺序存储方法的主要缺点是不便于修改，对结点的插入、删除运算时，可能要移动一系列的结点。



顺序表的实现方法

顺序表中存放数据的特点和数组这种数据类型完全吻合，所以顺序表的实现使用的是数组。

数组实现顺序表的存储结构时，一定要注意预先申请足够大的内存空间，避免因存储空间不足，造成数据溢出，导致不必要的程序错误甚至崩溃。

线性表顺序存储结构的建立

#define SIZE 100   //存储空间初始分配量
typedef struct Sqlist
{
    int elem[SIZE];   //数组存储数据元素，最大长度为SIZE
    int usedsize;     //线性表当前长度
}Sqlist,*PSqlist;


说明：描述顺序存储结构需要三个属性

存储空间的起始位置：数组elem，它的存储位置就是存储空间的存储位置。
	线性表的最大存储容量：数组长度SIZE
	线性表的当前长度：usedsize


顺序表的基本操作

1、顺序表的初始化

顺序表的初始化就是把顺序表初始化为空的顺序表，只需把顺序表的长度usedsize置为0即可

void InitSqlist(PSqlist Psq)
{
	assert(Psq != NULL);
	if(Psq == NULL)
	{
		return;
	}
	Psq->usedsize = 0;
}

2、在 pos 位置插入 val 值

在顺序表的第pos个位置插入元素val，首先将顺序表第pos个位置的元素依次向后移动一个位置，然后将元素val插入第pos个位置，移动元素要从后往前移动元素，即：先移动最后一个元素，在移动倒数第二个元素，依次类推；插入元素之前要判断插入的位置是否合法，顺序表是否已满，在插入元素之后要将表长 usedsize++

bool Insert(PSqlist Psq,int pos ,int val)
{
	assert(Psq != NULL);
	if (pos < 0 || pos > Psq->usedsize || IsFull(Psq) )
	{
		return false;
	}
	for (int i = Psq->usedsize-1; i >= pos; i--)
	{
		Psq->elem[i+1] = Psq->elem[i];
	}
	Psq->elem[pos] = val;
	Psq->usedsize++;
	return true;
}

3、从pos位置开始查找 key 值

查找数据元素 key 在表中的位置，从pos开始一直遍历表中元素，如果找到与要查找元素key相等的元素，则返回元素在表中的位置，没有找到则返回-1

int Search(PSqlist Psq,int pos,int key)
{
	assert(Psq != NULL);
	if (pos < 0 || pos > Psq->usedsize || IsEmpty(Psq))
	{
		return -1;
	}
	for (int i = pos; i < Psq->usedsize; i++)
	{
		if (Psq->elem[i] == key)
		{
			return i;
		}
	}
	return -1;
}

4、删除 pos 位置的值 

删除表中的第pos个元素，需要将表中第pos个元素之后的元素依次向前移动一位，将前面的元素覆盖掉。进行删除操作之前要判断顺序表是否为空，删除元素之后，将表长 usedsize--

bool DeletePos(PSqlist Psq,int pos,int *rtv)
{
	assert(Psq != NULL);
	if (pos < 0 || pos >= Psq->usedsize || IsEmpty(Psq))
	{
		return false;
	}
	if (rtv != NULL)
	{
		*rtv = Psq->elem[pos];
	}
	for (int i = pos; i < Psq->usedsize; i++)
	{
		Psq->elem[i] = Psq->elem[i+1];
	}
	Psq->usedsize--;
	return true;
}

5、删除一个 key 值

首先调用 Search() 函数 找到元素key在顺序表中的位置index，若未找到则Search()返回-1，若找到，则调用DeletePos()函数 删除index位置(即key所在的位置) 。

bool Delete(PSqlist Psq,int pos,int key) 
{
	assert(Psq != NULL);
	int index = Search(Psq,pos,key);
	if (index == -1)
	{
		return false;
	}
	return DeletePos(Psq,index,NULL);
}

6、得到pos位置的元素值

bool GetElem(PSqlist Psq,int pos,int *rtv)
{
	assert(Psq != NULL);
	if (pos < 0 || pos >= Psq->usedsize || IsEmpty(Psq))
	{
		return false;
	}
	if (rtv != NULL)
	{
		*rtv = Psq->elem[pos];
		return true;
	}
	return false;
}

 7、求顺序表长度

int GetLength(PSqlist Psq)
{
	assert(Psq != NULL);
	return Psq->usedsize;
}


8、清空顺序表

清空顺序表就是将表中的元素删除。删除表中的元素只需将表的长度usedsize置为0。

void Clear(PSqlist Psq)
{
	assert(Psq != NULL);
	Psq->usedsize = 0;
}

 9、打印顺序表

void Show(PSqlist Psq)
{
	assert(Psq != NULL);
	for (int i = 0; i < Psq->usedsize; i++)
	{
		printf("%d ",Psq->elem[i]);
	}
	printf("\n");
}

具有动态扩容的线性表顺序存储结构的建立

上述可实现顺序表的基本操作，但是顺序表的大小依赖于存储空间的初始分配量 SIZE，要想解决此问题，需要在顺序表存储空间不足时进行动态扩容

#define INIT_SIZE 10  // 存储空间的初始分配量
typedef struct Dsqlist
{ 
	int *elem;     // 数组存储数据元素,需在初始化时动态开辟内存
	int usedsize;  // 顺序表的当前长度
	int size;      // 顺序表存储空间的大小
}Dsqlist,*PDSqlist; 

具有动态扩容顺序表的基本操作均与普通顺序表相同，不同的操作有以下几种：

 1、顺序表的初始化

顺序表的初始化就是把顺序表初始化为空的顺序表，需为数组elem动态开辟存储空间，并把顺序表的长度usedsize置为0，size置为初始分配量INIT_SIZ即可

void InitList(PDSqlist Psq)
{
	assert(Psq != NULL);
	Psq->elem = (int *)malloc(INIT_SIZE * sizeof(int));
	assert(Psq->elem != NULL);
	Psq->usedsize = 0;
	Psq->size = INIT_SIZE;
}

2、判断顺序表是否为满

static bool IsFull(PDSqlist Psq)
{
	return Psq->usedsize == Psq->size;
}

3、为顺序表动态扩容

当顺序表为满时，需要调用动态扩容函数对顺序表的elem数组进行动态扩容，这里采用二倍扩容的方式

static void Inc(PDSqlist Psq)
{
	int *p = (int *)realloc(Psq->elem,Psq->size *2 *sizeof(int));
	assert(p != NULL);
	if (p != NULL)
	{
		Psq->elem = p;
	}
	assert(Psq->elem != NULL);
	Psq->size *= 2;
}

4、在 pos 位置插入 val 值

与之前的 Insert()函数 不同的是，当顺序表为满时，需要调用动态扩容函数对顺序表的elem数组进行动态扩容

bool Insert(PDSqlist Psq,int pos,int val)
{
	assert(Psq != NULL);
	if (pos < 0 || pos > Psq->usedsize)
	{
		return false;
	}
	if (IsFull(Psq))
	{
		Inc(Psq);
	}
	for (int i = Psq->usedsize-1; i >= pos; i--)
	{
		Psq->elem[i+1] = Psq->elem[i];
	}
	Psq->elem[pos] = val;
	Psq->usedsize++;
	return true;
}

5、释放动态开辟的存储空间

由于elem数组是动态开辟的，因此具有动态扩容顺序表与普通顺序表不同的是需要专门设立一个函数对动态开辟的存储空间进行释放，否则会在程序运行过程中产生内存泄露。

void Destroy(PDSqlist Psq)
{
	assert(Psq != NULL);
	free(Psq->elem);
	Psq->elem = NULL;
	Psq->size = 0;
	Psq->usedsize = 0;
}

complete code

普通顺序表：

sqlist.h:

#define SIZE 10
typedef struct Sqlist
{
    int elem[SIZE];
    int usedsize;
}Sqlist,*PSqlist;

void InitSqlist(PSqlist Psq);

bool Insert(PSqlist Psq,int pos ,int val);

int Search(PSqlist Psq,int pos,int key);

bool DeletePos(PSqlist Psq,int pos,int *rtv);

bool Delete(PSqlist Psq,int pos,int key);

bool GetElem(PSqlist Psq,int pos,int *rtv);

int GetLength(PSqlist Psq);

void Clear(PSqlist Psq);

void Show(PSqlist Psq);

sqlist.cpp:

#include "sqlist.h"
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
void InitSqlist(PSqlist Psq)//初始化,Psq为结构体指针类型
{
	assert(Psq != NULL);
	if (Psq == NULL)
	{
		return;
	}
	Psq->usedsize = 0;
}

static bool IsFull(PSqlist Psq)
{
	return Psq->usedsize == SIZE;
}

bool Insert(PSqlist Psq,int pos ,int val)  // 在 pos 位置插入 val 值
{
	assert(Psq != NULL);
	if (pos < 0 || pos > Psq->usedsize || IsFull(Psq) )
	{
		return false;
	}
	for (int i = Psq->usedsize-1; i >= pos; i--)
	{
		Psq->elem[i+1] = Psq->elem[i];
	}
	Psq->elem[pos] = val;
	Psq->usedsize++;
	return true;
}

static bool IsEmpty(PSqlist Psq)
{
	return Psq->usedsize == 0;
}


int Search(PSqlist Psq,int pos,int key) // 从pos位置开始查找 key 值
{
	assert(Psq != NULL);
	if (pos < 0 || pos > Psq->usedsize || IsEmpty(Psq))
	{
		return -1;
	}
	for (int i = pos; i < Psq->usedsize; i++)
	{
		if (Psq->elem[i] == key)
		{
			return i;
		}
	}
	return -1;
}

bool DeletePos(PSqlist Psq,int pos,int *rtv) // 删除 pos 位置的值
{
	assert(Psq != NULL);
	if (pos < 0 || pos >= Psq->usedsize || IsEmpty(Psq))
	{
		return false;
	}
	if (rtv != NULL)
	{
		*rtv = Psq->elem[pos];
	}
	for (int i = pos; i < Psq->usedsize; i++)
	{
		Psq->elem[i] = Psq->elem[i+1];
	}
	Psq->usedsize--;
	return true;
}

bool Delete(PSqlist Psq,int pos,int key)  // 删除一个 key 值
{
	assert(Psq != NULL);
	int index = Search(Psq,pos,key);
	if (index == -1)
	{
		return false;
	}
	return DeletePos(Psq,index,NULL);
}

bool GetElem(PSqlist Psq,int pos,int *rtv)
{
	assert(Psq != NULL);
	if (pos < 0 || pos >= Psq->usedsize || IsEmpty(Psq))
	{
		return false;
	}
	if (rtv != NULL)
	{
		*rtv = Psq->elem[pos];
		return true;
	}
	return false;
}

int GetLength(PSqlist Psq)
{
	assert(Psq != NULL);
	return Psq->usedsize;
}


void Clear(PSqlist Psq)
{
	assert(Psq != NULL);
	Psq->usedsize = 0;
}


void Show(PSqlist Psq)
{
	assert(Psq != NULL);
	for (int i = 0; i < Psq->usedsize; i++)
	{
		printf("%d ",Psq->elem[i]);
	}
	printf("\n");
}

test.cpp

#include<stdio.h>
#include"sqlist.h"
int main()
{
	Sqlist sq;
	InitSqlist(&sq);
	for (int i = 0; i < 10; i++)
	{
		Insert(&sq,i,i);
	}
	Show(&sq);	
	printf("%d\n",GetLength(&sq));
	Delete(&sq,0,2);
	Delete(&sq,0,0);	
	Delete(&sq,0,9);
	Show(&sq);	
	return 0;
}

具有动态扩容的顺序表：

dsqlist.h:

#pragma once
#define INIT_SIZE 10
typedef struct Dsqlist
{
	int *elem;
	int usedsize;
	int size;
}Dsqlist,*PDSqlist; 

void InitList(PDSqlist Psq);

bool Insert(PDSqlist Psq,int pos,int val);

int Search(PDSqlist Psq,int pos,int key);

bool DeletePos(PDSqlist Psq,int pos,int *rtv);

bool Delete(PDSqlist Psq,int pos,int key);

bool GetElem(PDSqlist Psq,int pos,int *rtv); 

int GetLength(PDSqlist Psq);

void Clear(PDSqlist Psq);

void Destroy(PDSqlist Psq);

void Show(PDSqlist Psq);

dsqlist.cpp:

#include "dsqlist.h"
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>

void InitList(PDSqlist Psq)
{
	assert(Psq != NULL);
	Psq->elem = (int *)malloc(INIT_SIZE * sizeof(int));
	assert(Psq->elem != NULL);
	Psq->usedsize = 0;
	Psq->size = INIT_SIZE;
}


static void Inc(PDSqlist Psq)
{
	int *p = (int *)realloc(Psq->elem,Psq->size *2 *sizeof(int));
	assert(p != NULL);
	if (p != NULL)
	{
		Psq->elem = p;
	}
	assert(Psq->elem != NULL);
	Psq->size *= 2;
}

static bool IsFull(PDSqlist Psq)
{
	return Psq->usedsize == Psq->size;
}


bool Insert(PDSqlist Psq,int pos,int val)
{
	assert(Psq != NULL);
	if (pos < 0 || pos > Psq->usedsize)
	{
		return false;
	}
	if (IsFull(Psq))
	{
		Inc(Psq);
	}
	for (int i = Psq->usedsize-1; i >= pos; i--)
	{
		Psq->elem[i+1] = Psq->elem[i];
	}
	Psq->elem[pos] = val;
	Psq->usedsize++;
	return true;
}

static bool IsEmpty(PDSqlist Psq)
{
	return Psq->usedsize == 0;
}

int Search(PDSqlist Psq,int pos,int key)
{
	assert(Psq != NULL);
	if (pos < 0 || pos > Psq->usedsize || IsEmpty(Psq))
	{
		return -1;
	}
	for (int i = pos; i < Psq->usedsize; i++)
	{
		if (Psq->elem[i] == key)
		{
			return i;
		}
	}
	return -1;

}

bool DeletePos(PDSqlist Psq,int pos,int *rtv)
{
	assert(Psq != NULL);
	if (pos < 0 || pos >= Psq->usedsize || IsEmpty(Psq))
	{
		return false;
	}
	if (rtv != NULL)
	{
		*rtv = Psq->elem[pos];
	}
	for (int i = pos; i < Psq->usedsize; i++)
	{
		Psq->elem[i] = Psq->elem[i+1];
	}
	Psq->usedsize--;
	return true;

}

bool Delete(PDSqlist Psq,int pos,int key)
{
	assert(Psq != NULL);
	int index = Search(Psq,pos,key);
	if (index == -1)
	{
		return false;
	}
	return DeletePos(Psq,index,NULL);
}

bool GetElem(PDSqlist Psq,int pos,int *rtv)
{
	assert(Psq != NULL);
	*rtv = Psq->elem[pos];
	return true;
}

int GetLength(PDSqlist Psq)
{
	assert(Psq !=NULL);
	return Psq->usedsize;
}

void Clear(PDSqlist Psq)
{
	assert(Psq != NULL);
	Psq->usedsize = 0;
}

void Destroy(PDSqlist Psq)
{
	assert(Psq != NULL);
	free(Psq->elem);
	Psq->elem = NULL;
	Psq->size = 0;
	Psq->usedsize = 0;
}

void Show(PDSqlist Psq)
{
	assert(Psq !=NULL);
	for (int i = 0; i < Psq->usedsize; i++)
	{
		printf("%d ",Psq->elem[i]);
	}
	printf("\n");
}

test.cpp

#include<stdio.h>
#include<vld.h>
#include "dsqlist.h"
int main()
{
	Dsqlist ds;
	InitList(&ds);
	for (int i = 0; i < 70; i++)
	{
		Insert(&ds,i,i);
	}
	Show(&ds);
	Delete(&ds,0,2);
	Delete(&ds,0,9);
	Delete(&ds,0,0);
	Show(&ds);
	Destroy(&ds);
	return 0;
}


求两个顺序表的交集

/*
**思路：
**新开辟一个顺序表存放交集
**如果遍历两个顺序表，查找相同元素写入交集中，并记录长度
*/
void Intersection(PSqlist sq1,PSqlist sq2,PSqlist sq3)
{
	int k = 0;  // 计数器
	for (int i = 0; i < sq1->length; i++)
	{
		int j = 0;
		while (j < sq2->length && sq2->elem[j] != sq1->elem[i])
		{
			j++;
		}
		if (j < sq2->length)
		{
			sq3->elem[k++] = sq1->elem[i];
		}
	}
	sq3->length = k;
}


求两个顺序表的并集

/*
**思路：
**新开辟一个顺序表存放并集
**由于是并集，所以结果中至少包含了一个顺序表中的所有元素
**因此首先将第一个顺序表写入并集，然后遍历第二个的顺序表
**第二个顺序表中的该元素与第一个顺序表的所有元素均不相同，则写入新表
*/
void Union(PSqlist sq1,PSqlist sq2,PSqlist sq4)
{
	for (int i = 0; i < sq1->length; i++)
	{
		sq4->elem[i] = sq1->elem[i];
	}
	sq4->length = sq1->length;

	int k = sq4->length;

	for (int i = 0; i < sq2->length; i++)
	{
		int j = 0;
		while (j < sq1->length && sq1->elem[j] != sq2->elem[i])
		{
			j++;
		}
		if (j >= sq1->length)
		{
			sq4->elem[k++] = sq2->elem[i];
		}
	}
	sq4->length = k;
}

收起

展开全文

数据结构顺序表创建及操作

千次阅读 2015-11-06 09:53:39

数据结构顺序表的创建及操作

数据结构顺序表的创建及操作

结构体创建(两种结构体定义方式) 

方式一:给结构体Sqlist定义了个别名
    typedef struct Sqlist{
        int elem[MAXSIZE];
        int length;
    }Sqlist_t;

方式二:定义一个名字为Sqlist的结构体



    struct Sqlist{
        int elem[MAXSIZE];
        int length;
    };

区别之处在于第一种方式给结构体定义了个别名 

注释:  

int elem[MAXSIZE]:表示定义一个数据类型为int的数组用于存储int型数据(根据你要存储的数据类型可自由修改)，MAXSIZE代表数组长度 

int length:表示结构体的另一个属性(用于表示从第几个数据开始为空)

2.初始化赋值

    void create(Sqlist &L){
        int n;
        printf("要输入数据的个数:");
        scanf("%d",&n);
        fflush(stdin);
        while(n > MAXSIZE){
            printf("越界、请从新输入:");
            scanf("%d",&n);
            fflush(stdin);
        }
        L.length = 0;//表示第几个数据开始为空
        for(int i = 0; i < n; i++){
            L.elem[L.length]=i;
            L.length++;
        }
    }

3.数据展示

    void show(Sqlist L){
        int i = 0;
        while(i<L.length){
            printf("%d\n",L.elem[i]);
            i++;
        }
    }

4.数据删除

    void delData(Sqlist &L,int id){
        if(id < 0 || id >= L.length){
            printf("输入有误!");
        }else{
            for(int i = id; i < L.length; i++){
                L.elem[i-1] = L.elem[i];
            }
            L.elem[L.length]=NULL;
            L.length--;
        }
    }

注释: 

id:表示要删除的位置(要做判断避免越界)； 

从第id个位置开始将后面的数据都往前提一位(for循环的功能)； 

L.elem[L.length]=NULL;表示将最后一位设为NULL(空)； 

L.length–;表示第几个位置开始为空；

5.添加数据

    void addData(Sqlist &L,int id,int data){
        if(id < 0 || id > L.length){
            printf("输入有误!");
        }else{
            for(int i = L.length; i >= id; i--){
                L.elem[i] = L.elem[i-1];
            }
            L.elem[id-1] = data;
            L.length++;
        }
    }

注释: 

id:表示位置、位置必须连续 

从第id个位置开始将后面的数据都往后一位(for循环的功能)； 

L.elem[id-1]=data;表示将第id位设为data； 

L.length++;表示第几个位置开始为空；

6.取数据(按位置取、并返回值)

    int selectData(Sqlist L,int id){
        if(id < 0 || id >= L.length){
            printf("输入有误!");
            return -1;
        }else{
            int data = L.elem[id-1];
            return data;
        }
    }

7.数据匹配(按值匹配，返回第一次出现的位置)

    int findId(Sqlist L,int data){
        for(int i = 0; i < L.length; i++){
            if(L.elem[i] == data){
                return i+1;
            }
        }
        return -1;
    }

注释: 

遍历每一个位置进行匹配、匹配成功，则返回位置。否则返回-1

8.主方法

    void main(){
            Sqlist La;//定义一个名字为La的结构体变量
            create(La);//初始化赋值
            show(La);//数据展示
            addData(La,4,20);//在第四个位置添加数据20
            show(La);
            delData(La,7);//删除第七个位置数据
            show(La);
            int data = selectData(La,2);//查找第二位置的数据
            printf("%d\n",data);
            int id = findId(La,8);//匹配数据8的第一个位置
            printf("%d\n",id);
    }

谢谢大家、欢迎补充！大家一起学习。

收起

展开全文

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

千次阅读 多人点赞 2019-10-22 23:23:01

数据结构顺序表基本操作（C/C++实现）涉及基本运算初始化顺序表L 依次插入abcde元素输出顺序表L 输出顺序表L的长度判断顺序表L是否为空输出顺序表L的第3个元素输出元素a的位置在第4个元素位置上插入f元素 ...

数据结构顺序表基本操作（C/C++实现）
注意：本代码为了测试运行默认含有操作所需数据，如有需要可自己增删改相关数据
涉及基本运算

初始化顺序表
依次插入元素
输出顺序表
输出顺序表的长度
判断顺序表是否为空
输出顺序表的第n个元素
输出元素x的位置
在第n个元素位置上插入x元素
输出顺序表
删除顺序表的第n个元素
输出顺序表
释放顺序表

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;
}

收起

展开全文

基本操作

数据结构顺序表的指针（C语言）简单实现
千次阅读 2020-07-07 09:44:37
数据结构顺序表的指针（C语言）简单实现思来想去决定向嵌入式系统方向靠拢。虽然本科是电子信息科学与技术，但是从未学过数据结构、操作系统等计算机方面的专业课。故最近开始学习数据结构，使用严蔚敏老师的第二版...
收起
嵌入式Linux 指针
数据结构顺序表（栈的操作问题）
2015-06-02 07:40:47
数据结构顺序表（栈的操作问题） x='@'; 在数据结构中有什么意义？
收起
C语言算法与数据结构 顺序表 基本操作及实验案例
千次阅读 2019-11-14 11:04:32
C语言算法与数据结构 顺序表 基本操作及实验案例实验要求： 1．(80%)完成顺序表的基本运算：初始化、显示、求长度、判空、判满、插入、删除、取元素等，并编写主函数测试算法。 2.(90%)设计算法：将一个元素插入到...
收起
C语言 array
数据结构 顺序表各种基本运算的实现
2018-12-27 23:39:14
数据结构 顺序表各种基本运算的实现 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define MaxSize 10 typedef struct { char data[MaxSize]; int length; }SqList; ...
收起
数据结构顺序表C语言实现
2019-10-10 16:05:29
数据结构算法实现 顺序表顺序储存结构C语言实现版 #include <stdio.h> #define MAXSIZE 100 #define OVERFLOW 0 #define OK 1 #define ERROR 0 int main(){ } //顺序表顺序储存结构，这里泛型定义为整形 ...
收起
数据结构顺序表动态分配
2021-01-17 13:52:50
数据结构动态分配实现一些基本的功能:查找数据（按值和按位）、删除数据（通常按位）、插入元素（按位）、输出表的长度以及打印表。 1>定义结构体定义数据时尽量有很高的可读性对于引用符号&的...
收起
链表
数据结构顺序表实验
2017-09-19 16:20:17
顺序表实验
收起
C++
数据结构顺序表和链表的比较
2019-11-09 20:24:50
顺序表和链表的比较
收起
数据结构顺序表和链表的实现原理
千次阅读 2018-07-07 16:38:32
java数据结构与算法之顺序表与链表深入分析2016年11月05日 16:24:30阅读数：14829 转载请注明出处（万分感谢！）： http://blog.csdn.net/javazejian/article/details/52953190 出自【zejian的博客】关联文章:java...
收起
数据结构顺序表小应用——学生成绩管理查询
千次阅读 2018-03-24 23:49:03
数据结构顺序表实用练习都是基本的函数调用和排序，加了点小小的选项。就算对顺序表的结构熟悉练练手吧。。。。 #include<string.h> #include<malloc.h> #include<stdio.h&...
收起
数据结构 顺序表 时间复杂度
千次阅读 2019-05-26 15:14:46
1.顺序表：数据逻辑有连续性，物理存储上也具有连续性（中间不能空，要紧紧相连这点和数组区别） 2.链表：数据逻辑有连续性，物理存储上不一定具有连续性 3.顺序表：创建/销毁增删查改增：头插/尾插/插入...
收起
数据结构顺序表的插入算法
2019-10-24 16:43:51
数据结构：顺序表的插入算法 public void insert(int index,object element) throws Exception{ if(size == maxSize){ throws new Exception(“顺序表已满无法插入！”)} if(index<0||index>maxSize){ ...
收起
数据结构顺序表应用5：有序顺序表归并
2017-01-16 21:09:01
已知顺序表A与B是两个有序的顺序表，其中存放的数据元素皆为普通整型，将A与B表归并为C表，要求C表包含了A、B表里所有元素，并且C表仍然保持有序。 Input 输入分为三行：第一行输入m、n（1,n）的值，即为表A、B...
收起
c语言
数据结构顺序表应用6：有序顺序表查询
千次阅读 2017-01-16 21:15:22
顺序表应用6：有序顺序表查询 Time Limit: 7MS Memory Limit: 700KB Problem Description 顺序表内按照由小到大的次序存放着n个互不相同的整数（1)，任意输入一个整数，判断该整数在顺序表中是否存在。如果在顺序...
收起
PTA 数据结构顺序表操作集
千次阅读 2018-10-10 18:47:38
6-1 顺序表---插入结点 ... 顺序表结构定义如下： typedef char ElemType; typedef struct { ElemType data[MaxSize]; int length; } SqList; 要求写出： void DispList(SqList *L); //输出顺序表,每个...
收起
顺序表基本操作
数据结构 顺序表 移位算法
2018-08-13 14:32:10
顺序表应用3：元素位置互换之移位算法 Time Limit: 1000 ms Memory Limit: 570 KiB ...=1000000)的顺序表，数据元素的类型为整型，将该表分成两半，前一半有m个元素，后一半有len-m个元素（1<=m&lt...
收起
货物管理系统（数据结构顺序表）
千次阅读 2013-11-10 12:58:28
/*货物管理系统（数据结构顺序表）*/ #include #include #include #define MAXSIZE 100 typedef struct { char name[11],no[11]; int num; }goods; typedef struct { goods data[MAXSIZE]; int len; }SeqList; ...
收起
c语言
C语言数据结构顺序表的查找算法
千次阅读 2019-06-04 11:58:46
*顺序表结构体里面包含数据数组和数组长度 *采用两种查找方法哨兵设置普通查找 *哨兵排序算法的设置的好处是可以降低时间的复杂度节省 for循环的次数 *程序的步骤分为初始化顺序表 创建顺序表 查找输出 ...
收起
数据结构顺序表及链表实验
千次阅读 2016-09-20 13:19:05
顺序表和链表，使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 根据指定的位置可返回相应的学生...
收起
数据结构顺序表查找操作
2017-03-21 12:45:01
``` Status LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType)) { ElemType *p; int i=1; p = L.elem ; while(i!compare(*p++,e)) ++i; if(i) return i; else return Error;...
收起
c c
数据结构 顺序表的删除操作
2020-04-20 21:53:58
本题要求实现一个函数，要求将顺序表的第i个元素删掉，成功删除返回1，否则返回0；函数接口定义： int ListDelete(SqList &L,int i); 其中SqList结构定义如下： typedef struct{ ElemType *elem; int ...
收起
数据结构 顺序表—插入删除最大值
千次阅读 2020-07-12 21:21:15
考研笔记 数据结构代码本人小白一个，考研的科目是数据结构 就用此博客来记录练习的代码。借鉴了别人的很多地方和天勤书上的内容。 顺序表 构建一个顺序表 实现以一下功能 1.找出最大值 2.正序输出 3.插入一个元素 ...
收起
C语言数据结构顺序表的顺序查找和折半查找的功能
千次阅读 2020-05-31 20:07:54
优点：对顺序表中数据元素的存储没有要求，顺序存储链式存储均可。需注意：对于线性表的链式存储只能使用顺序查找. 折半查找，又称二分查找，它仅适用于有序的顺序表 首先将给定值key与表中间位置元素的关键字比较...
收起
c语言

数据结构顺序表

数据结构 顺序表

线性表的顺序存储结构

顺序表的实现方法

线性表顺序存储结构的建立

顺序表的基本操作

1、顺序表的初始化

2、在 pos 位置插入 val 值

3、从pos位置开始查找 key 值

4、删除 pos 位置的值

5、删除一个 key 值

6、得到pos位置的元素值

7、求顺序表长度

8、清空顺序表

9、打印顺序表

具有动态扩容的线性表顺序存储结构的建立

1、顺序表的初始化

2、判断顺序表是否为满

3、为顺序表动态扩容

4、在 pos 位置插入 val 值

5、释放动态开辟的存储空间

complete code

普通顺序表：

具有动态扩容的顺序表：

求两个顺序表的交集

求两个顺序表的并集

数据结构顺序表创建及操作

数据结构顺序表的创建及操作

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

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

涉及基本运算

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

源代码（经VS2015、devC++编译器运行通过）

数据结构顺序表的指针（C语言）简单实现

数据结构顺序表（栈的操作问题）

C语言 算法与数据结构 顺序表 基本操作及实验案例

数据结构 顺序表各种基本运算的实现

数据结构顺序表C语言实现

数据结构顺序表动态分配

数据结构顺序表实验

数据结构顺序表和链表的比较

数据结构顺序表和链表的实现原理

数据结构顺序表小应用——学生成绩管理查询

数据结构 顺序表 时间复杂度

数据结构顺序表的插入算法

数据结构顺序表应用5：有序顺序表归并

数据结构顺序表应用6：有序顺序表查询

PTA 数据结构顺序表操作集

数据结构 顺序表 移位算法

货物管理系统（数据结构顺序表）

C语言数据结构顺序表的查找算法

数据结构顺序表及链表实验

数据结构顺序表查找操作

数据结构 顺序表的删除操作

数据结构 顺序表—插入 删除 最大值

C语言数据结构顺序表的顺序查找和折半查找的功能

数据结构顺序表

数据结构顺序表

C语言算法与数据结构顺序表基本操作及实验案例

数据结构顺序表各种基本运算的实现

数据结构顺序表时间复杂度

数据结构顺序表移位算法

数据结构顺序表的删除操作

数据结构顺序表—插入删除最大值