/************************************************************************/
/* 数据结构：动态线性顺序表 */
/* 挑灯看剑-shuchangs@126.com 2010-10 */
/* 云歌国际（Cloud Singers International） www.cocoral.com */
/************************************************************************/
#include "core.h"
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define LIST_SIZE sizeof(LIST)
#define LIST_INIT_SIZE 10
#define LIST_INCREMENT 5
typedef struct
{
int* elem; //存储空间基地址
int length; //当前长度
int listsize;//当前分配的存储容量
}SqList;
void main()
{
//******函数原型【开始】***************
Status InitList_Sq(SqList* list);
void printList(SqList list);
void printListElem(SqList list);
Status ListInsert_Sq(SqList* L, int i, int e);
Status ListDelete_Sq(SqList* L, int i, int* e);
void autoList_Sq(SqList* L, int n);
Status compare(int e1, int e2);
Status LocateElem_Sq(SqList* L, int e, int* i, Status(*compare)(int, int));
//******函数原型【结束】***************
SqList L =
{
NULL, NULL, NULL
};
if (InitList_Sq(&L))
{
int i = 0, e = 0;
char tag = 'Y'; //输入其他字符结束输入
/*
//动态创建线性顺序表
puts("请输入插入元素位置和元素值！");
scanf("%d %d %c", &i, &e, &tag);
while (tag == 'Y')
{
if (ListInsert_Sq(&L, i, e))
{
puts("插入成功！");
printList(L);
printListElem(L);
}
else
{
puts("插入失败！");
}
puts("请输入插入元素位置和元素值！");
scanf("%d %d %c", &i, &e, &tag);
}
*/
autoList_Sq(&L, 7); //自动化生成线性顺序表
//执行删除操作
puts("请输入删除元素位置！");
scanf("%d", &i);
if (ListDelete_Sq(&L, i, &e))
{
puts("删除成功！");
printf("当前删除元素e=%d\n", e);
}
else
{
puts("删除失败！");
}
printList(L);
printListElem(L);
puts("请输入要查找的元素！");
scanf("%d", &e);
if (LocateElem_Sq(&L, e, &i, compare))
{
puts("查找成功！");
printf("查找元素e=%d，位于第%d位置！\n", e, i + 1);
}
else
{
puts("查找失败！");
}
}
}
Status InitList_Sq(SqList* list)
{
list->elem = (int *) malloc(LIST_INIT_SIZE * sizeof(int));
if (!(list->elem))
exit(OVERFLOW);
list->length = 0;
list->listsize = LIST_INIT_SIZE;
return OK;
}
void printList(SqList list)
{
printf("线性表基地址：%d，线性表长度：%d，线性表当前分配的存储容量：%d\n",
list.elem, list.length, list.listsize);
}
void printListElem(SqList list)
{
int i = 0, n = list.length;
for (; i < n; i++)
{
printf("elem[%d]= %d\n", i + 1, list.elem[i]);
}
}
//在线性顺序表的第i个位置插入元素e
Status ListInsert_Sq(SqList* L, int i, int e)
{
Status ListEmpty(SqList L); //函数原型
//插入前预备性工作
//如果是空表，就将该元素置为第1个位置
if (ListEmpty(*L))
{
*L->elem = e;
L->length = 1;
puts("插入前线性表为空表，插入元素默认置于第1个位置！");
return OK;
}
//如果插入点i不合要求
if (i<1 || i>L->length + 1)
return ERROR;
//如果当前线性列表的长度等于或大于分配的存储容量
if (L->length >= L->listsize)
{
//重新分配存储空间
int* newbase = (int*) realloc(L->elem,
(L->listsize + LIST_INCREMENT) * sizeof(int));
if (!newbase)
exit(OVERFLOW);
L->elem = newbase;
L->listsize += LIST_INCREMENT;
}
//开始插入操作
int* q = L->elem + (i - 1);
//第i个位置到第n位置上的数据先后移一位
int* p = L->elem + (L->length - 1);
for (; p >= q; p--)
*(p + 1) = *p;
*q = e;
++L->length;//长度加1
return OK;
}
//删除线性链表中第i个位置元素，并用元素e返回之
Status ListDelete_Sq(SqList* L, int i, int* e)
{
Status ListEmpty(SqList L);//函数原型
//删除前判断
//如果是空表
if (ListEmpty(*L))
{
puts("删除失败，线性表是空表！");
return ERROR;
}
//如果i超出范围
if (i<1 || i>L->length)
return ERROR;
//如果i符合删除要求
int* p = L->elem + i - 1; //删除位置指针
int* q = L->elem + L->length - 1; //尾指针
*e = *p;
for (; p < q; p++)
{
*p = *(p + 1);
}
--L->length; //长度减1
return OK;
}
Status ListEmpty(SqList L)
{
//初始条件：线性表L已存在
//操作结果：若L为空表，则返回TRUE,否则返回FALSE。
if (L.length <= 0)
return TRUE;
else
return FALSE;
}
void autoList_Sq(SqList* L, int n)
{
//Status ListInsert_Sq(SqList* L, int i, int e);
void printList(SqList list);
void printListElem(SqList list);
int i = 0;
for (; i < n; i++)
{
ListInsert_Sq(L, i + 1, i + 1);
}
printList(*L);
printListElem(*L);
}
//在线性顺序表L中查找元素e，如果成功用i值返回所在位置，并返回TRUE，否则返回FALSE
Status LocateElem_Sq(SqList* L, int e, int* i, Status(*compare)(int, int))
{
int* p = L->elem; //头指针
int* q = L->elem + L->length - 1; //尾指针
for (*i = 0; p <= q; p++)
{
if ((*compare) (*p, e))
break;
++ * i;
}
if (*i < L->length)
return OK;
else
return ERROR;
}
Status compare(int e1, int e2)
{
if (e1 == e2)
return TRUE;
else
return FALSE;
}
运行结果测试如下：
插入前线性表为空表，插入元素默认置于第1个位置！
线性表基地址：3671976，线性表长度：7，线性表当前分配的存储容量：10
elem[1]= 1
elem[2]= 2
elem[3]= 3
elem[4]= 4
elem[5]= 5
elem[6]= 6
elem[7]= 7
请输入删除元素位置！
5
删除成功！
当前删除元素e=5
线性表基地址：3671976，线性表长度：6，线性表当前分配的存储容量：10
elem[1]= 1
elem[2]= 2
elem[3]= 3
elem[4]= 4
elem[5]= 6
elem[6]= 7
请输入要查找的元素！
2
查找成功！
查找元素e=2，位于第2位置！
Press any key to continue
分享到：
相关推荐
2. C语言实现顺序表： 在C语言中，我们可以定义一个结构体来表示顺序表，结构体中包含一个数组和数组的长度。例如： ```c typedef struct { int* data; int length; int capacity; } SeqList; ``` 这里的`...
线性顺序表是一种基本的数据结构，它在计算机科学和数据结构的学习中占有重要地位。线性顺序表是由一组相同类型元素构成的有限序列，它的主要特点是元素之间存在着一对一的顺序关系，即每个元素都有一个前驱元素和一...
在这个实验中，我们将专注于两种基本的数据结构：链表和顺序表。这两种结构在编程和算法设计中起着至关重要的作用。 首先，我们来看**链表**。链表是一种线性数据结构，与数组不同，它在内存中不是连续存储的。每个...
顺序表是一种线性结构，它的所有元素在内存中连续存放，可以分为静态顺序表和动态顺序表。静态顺序表通常是在编译时就预分配好固定大小的数组，而动态顺序表则可以根据需要动态地调整其容量。 静态顺序表的优点在于...
线性顺序表是数据结构的一种基本形式，尤其在C语言编程中，它是初学者和专业开发者都需要掌握的基础知识。本资料包提供了一个基于C语言实现线性顺序表的实例，包括增删改查以及排序和合表操作。 线性顺序表是一种...
本课程设计专注于“顺序表”的操作，这是一个基础且重要的数据结构。顺序表在内存中以线性方式存储元素，其特点是访问速度快，插入和删除操作相对较慢。下面我们将深入探讨顺序表的原理、操作以及其在实际应用中的...
顺序表是一种基本的数据结构，其中元素按照线性顺序存储在连续的内存位置上。这种存储方式使得我们可以快速访问任意位置的元素，时间复杂度为O(1)。但在插入或删除元素时，如果涉及移动大量元素，效率就会降低，...
本压缩包提供了数据结构实验的源代码，主要涵盖了顺序表、单链表、树和图这四种基本数据结构在C++语言中的实现。下面我们将深入探讨这些知识点。 首先，**顺序表**是最基础的数据结构之一，它在内存中连续存储元素...
顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。对于18级合工大的学生来说，这个实验旨在深化他们对数据结构的理解，提高编程能力。 顺序表的操作主要包括插入、删除和查找等。在顺序...
本主题聚焦于“数据结构C语言中的顺序表操作”，这是一种基础但至关重要的数据结构概念。 顺序表是由一组相同类型的数据元素构成的线性序列，这些元素在内存中按顺序存储。在C语言中，我们通常使用数组来实现顺序表...
顺序表，顾名思义，是一种简单的数据结构，其中元素按照线性顺序存储，就像数组一样。在顺序表中，每个元素都有一个唯一的索引，可以通过索引来直接访问它们。 逆置顺序表，是指将表中的元素顺序反转。例如，如果原...
顺序表是数据结构中最基本的一种，它的概念简单但应用广泛。在本资料包中，你将找到关于数据结构的PPT讲解以及C语言实现顺序表的代码示例，这对于初学者来说是一份非常有价值的资源。 首先，我们来深入理解一下顺序...
数据结构：线性表（顺序存储） 线性表是具有相同属性的数据元素的一个有限序列。线性表中的各元素都具有同种数据类型，表的长度可用 n（n>=0）表示，表中所含元素个数即为线性表的长度。特殊情况 n=0，且线性表的...
顺序表是一种线性数据结构，它的元素在内存中是连续存储的，就像数组一样。每个元素都有一个固定的位置，可以通过索引来访问。顺序表的特点包括直接访问、简单操作以及存储空间预分配等。 顺序表的操作主要包括插入...
顺序表和链表是两种常见的数据结构，分别用于存储和管理顺序排列的数据和链式排列的数据。 顺序表 顺序表是一种线性表，元素按顺序存储在连续的内存空间中。顺序表的优点是可以快速地访问和查找元素，但缺点是插入...
顺序表是一种线性数据结构，其中元素在内存中按顺序存储。这种表的操作通常涉及到数组，因为数组提供了随机访问的能力。在顺序表中，第i个元素的地址可以通过第一个元素的地址加上i乘以每个元素的大小来计算。这使得...
线性顺序表是一种常见的数据结构，它通过一组连续的存储单元来存储数据元素，其中每个元素占据一个位置，并且可以通过其在数组中的下标进行快速访问。线性顺序表的主要优点是支持高效的随机访问，即可以立即获取任何...
在这个实验中，我们专注于一个基础但重要的数据结构——顺序表。顺序表在内存中是线性连续存储的，元素之间的逻辑顺序与物理顺序一致，这使得对顺序表的访问和修改相对简单。 实验1的目标是实现两个功能： 1. 对...
顺序表是一种线性数据结构，其中元素在内存中按顺序存储。在C++中，我们可以使用数组来实现顺序表。这种结构的优点是访问速度快，因为数组的元素可以通过索引直接访问。但其缺点也很明显，即插入和删除操作在一般...
2. 实现顺序表：在这些环境下，可以使用C++的数组或者动态分配的内存来创建顺序表。例如，定义一个类，包含数组作为数据成员，然后提供插入、删除、查找等方法。 3. 编程实现：插入操作可能需要移动元素以腾出空间，...