线性表的相关操作

最新推荐文章于 2024-05-17 23:32:03 发布

qq_57355321

最新推荐文章于 2024-05-17 23:32:03 发布

阅读量859

点赞数 1

分类专栏：数据结构与算法文章标签：数据结构算法

本文链接：https://blog.csdn.net/qq_57355321/article/details/120795190

版权

数据结构与算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

实验1

实验题目

（1）设计一个有序顺序表类，即表中的数据元素按数据元素值递增有序。实现以下函

数：

（a）把给定值 e 插入有序表中。

（b）删除值为 e 的所有数据元素。

（c）合并两个有序表，得到一个新的有序表。

（d）从有序顺序表中删除其值在给定值 s 与 t 之间（

s＜t）的所有元素，如果 s≥t 或

顺序表为空，则显示出错信息，并退出运行。

（2）针对带头结点的单链表，试编写下列函数：

（a）定位函数：在单链表中寻找给定值的结点。若找到，则返回该结点的地址（返回位序即可，并非实际地址），否则返回空。

（b）统计函数：统计单链表中等于给定值 e 的元素个数。

二、 实验目的

（1）理解与掌握线性表的顺序存储和链式存储的表示与操作方法。

（2）通过解决线性表应用的相关问题，训练学生解决实际编程问题的分析、设计等思维能力

三、 算法设计

1. 数据结构的定义和说明

1）对于实验（1），为设计一个有序顺序表类，定义一个Int类型ElemType结构体，用于顺序表存储数据；定义Sqlist顺序表结构体，包含length（数据长度），data[]（数据），listsize(申请给顺序表最大长度）。

2）对于实验（2），为设计一个单链表，定义node单链表结构体，包含data数据和next指针。

2. 主要功能函数的详细设计（以文字描述形式给出算法的实现步骤）

-实验（1）

--void sortlist(SqList& L)

将L数据排升序，利用选择排序法

--int ListInsert(SqList* L, Elemtype e)

向顺序表L插入元素e。判断如果L的length等于零，length++，再存数据；else，length++，将e插入表尾，再用冒泡排序将顺序表有序化。

--int ListElemDelete(SqList* L, int x)

删除顺序表中所有相同的元素。判断如果L的length小于等于0，返回-1；再for循环判断！L->data[i]=x，将data[i]=x的数据剔除，再记录未被删除的个数k，length就等于k。

--int ListRangeDelete(SqList* L, int start, int stop)

删除在一个数据范围类的所有数据。声明int k=0先判断如果范围不存在，返回-1；判断如果L的length小于等于0，返回-1；再for循环判断L->data[i]是否在范围内，true则将数据传给L->data[k]，k++；最后L的length等于k。

--Listhebing(SqList* L1, SqList* L2, SqList* L3)

将两个有序表L2，L1进行合并，得到新的有序表L3。判断L2，L1长度和是否大于L3，true则返回-1；定义i，j，k=0利用while循环先判断ij分别小于L1L2的length，true则进行循环：如果L1->data[i]小于L2->data[j]，将L1->data[i++]赋给L3->data[k++]，else相反。

-实验（2）

--int compare(ElemType c1, ElemType c2)

比较两个元素，true则返回1

--int LocateElem_L(LinkList L,ElemType e, int(*compare)(ElemType, ElemType))

寻找元素位置。利用while：循环条件：p->next,非空，再判断利用compare，打印位置返回位置，结束；否则打印未找到，返回0；

--int CountXnum(LinkList L, int e)

统计在单链表中e的个数。利用while：循环条件：p，非空，再判断p->data == e，真，number++，打印number。

运行结果及分析

实验（1）

说明：输入9个数据进有序表，将数据e=5插入有序表，并输出表。

说明：输入6个数据进有序表，将数据x=88删除，并输出删除后的有序表。

（c）

说明：输入8个数据进有序表，删除范围在（30,500）的数据，并输出表。

（d）

说明：建立了两个有序表，合并，并输出合并后的有序表。

实验（2）

情况一

说明：输入了六个数据进单链表，查找未在数据里的1，不存在；统计未在数据里的3的个数为0。

情况二：

输入了六个数据进单链表，查找在数据里的12，存在，且位置正确；统计未在数据里的45的个数为2。正确！

源程序

——实验1

#include<stdio.h>

#include<stdlib.h>

#define InitSize 100 //顺序表的初始表长

typedef int Elemtype;

typedef struct {

Elemtype* data;//存放数据

int length; //顺序表的长度

int listsize;

}SqList; //顺序表的类型定义

void InitList(SqList &L) {

L.data = (Elemtype*)malloc(InitSize * sizeof(Elemtype));

if (L.data == NULL) {

printf("存储分配失败！\n");

exit(1);

}

L.length = 0;

}

void creatlist(SqList& L, int n) {

int i;

L.listsize = InitSize;

L.length = n;

printf("输入%d个数据\n", n);

for (i = 0; i < n; i++) {

scanf_s("%d", &L.data[i]);

}

}

void sortlist(SqList& L) {

int n = L.length;

int i, j;

for (i = 0; i < n; i++) {

int index = i;



for (int j = i + 1; j < n; j++)

{

if (L.data[j] <= L.data[index]) {

index = j;

}

}

if (index == i)

continue;

else

{

int temp;

temp = L.data[index];

L.data[index] = L.data[i];

L.data[i] = temp;

}



}

}

void printlist(SqList& L) {

int i;

for (i = 0; i < L.length; i++) {

printf("%d  |", L.data[i]);

}

printf("\n");

}

int ListInsert(SqList* L, Elemtype e)    // 插入数据

{

if (!L->length)

{

L->length++;

L->data[0] = e;

}

else

{

L->length++;

int a = 0;

a = L->length - 1;

L->data[a] = e;              // 插入的数据放在最后一位

int i, j, m = 0;                  // 对插入之后的顺序表进行排序

for (i = 0; i <= L->length - 2; i++)

{

for (j = 0; j <= L->length - 2 - i; j++)

{

if (L->data[j] > L->data[j + 1])

{

m = L->data[j];

L->data[j] = L->data[j + 1];

L->data[j + 1] = m;

}

}

}

}

return 1;

}



int ListElemDelete(SqList* L, int x)//ListElemDelete 删除顺序表中所有相同的元素

{

int k = 0;

int delNUm = 0;

if (L->length <= 0)

{

return -1;

}



for (int i = 0; i < L->length; i++)

{

if (L->data[i] != x)



{

L->data[k] = L->data[i];

k++;

}



}

delNUm = L->length - k;

L->length = k;

return delNUm;



}

int ListRangeDelete(SqList* L, int start, int stop){

int k = 0;

    int delNUm = 0;

if (start > stop)

{

return -1;



}

if (L->length <= 0)

{

return -1;



}

for (int i = 0; i < L->length; i++)

{

if (L->data[i] < start || L->data[i] > stop)



{

L->data[k] = L->data[i];

k++;

}



}



delNUm = L->length - k;

L->length = k;

return delNUm;

}

int Listhebing(SqList* L1, SqList* L2, SqList* L3)//Listhebing 将两个有序表进行合并，并且将合并后的有序表返回

{



if (L1->length + L2->length > L3->listsize)

{

return -1;



}

int i = 0;

int j = 0;

int k = 0;

while (i < L1->length && j < L2->length)

{

if (L1->data[i] < L2->data[j])

{

L3->data[k++] = L1->data[i++];

}

else {

L3->data[k++] = L2->data[j++];



}



}

while (i < L1->length)

{

L3->data[k++] = L1->data[i++];

}

while (j < L2->length)

{

L3->data[k++] = L2->data[j++];



}

L3->length = k;

return 1;



}

int main() {

SqList L;

InitList(L);

int n,e,x;

int start, stop;

printf("输入顺序表数据个数：\n");

scanf_s("%d", &n);

creatlist(L, n);

sortlist(L);

printf("有序表为：\n");

printlist(L);



/*

printf("输入想要插入的数据e：\n");

scanf_s("%d", &e);

ListInsert(&L,e);

printf("插入后有序表为：\n");

printlist(L);*///插入元素



/*

printf("输入想要删除的数据x：\n");

scanf_s("%d", &x);

ListElemDelete(&L, x);

printf("删除后有序表为：\n");

printlist(L);*///删除元素



/*

printf("输入想要删除的数据范围：\n");

scanf_s("%d%d", &start,&stop);

ListRangeDelete(&L, start, stop);

printf("删除后有序表为：\n");

printlist(L);*///删除范围内元素



/*

SqList M;

InitList(M);

int n2;

printf("输入顺序表2数据个数：\n");

scanf_s("%d", &n2);

creatlist(M, n2);

sortlist(M);

printlist(M);

SqList N;

InitList(N);

N.listsize = InitSize;

N.length = L.length+M.length;

Listhebing(&L, &M, &N);

printf("合并后的有序表为：\n");

printlist(N);*///合并俩有序表

}

——

——实验1

#include<stdio.h>

#include<stdlib.h>

#define InitSize 100 //顺序表的初始表长

typedef int Elemtype;

typedef struct {

Elemtype* data;//存放数据

int length; //顺序表的长度

int listsize;

}SqList; //顺序表的类型定义

void InitList(SqList &L) {

L.data = (Elemtype*)malloc(InitSize * sizeof(Elemtype));

if (L.data == NULL) {

printf("存储分配失败！\n");

exit(1);

}

L.length = 0;

}

void creatlist(SqList& L, int n) {

int i;

L.listsize = InitSize;

L.length = n;

printf("输入%d个数据\n", n);

for (i = 0; i < n; i++) {

scanf_s("%d", &L.data[i]);

}

}

void sortlist(SqList& L) {

int n = L.length;

int i, j;

for (i = 0; i < n; i++) {

int index = i;



for (int j = i + 1; j < n; j++)

{

if (L.data[j] <= L.data[index]) {

index = j;

}

}

if (index == i)

continue;

else

{

int temp;

temp = L.data[index];

L.data[index] = L.data[i];

L.data[i] = temp;

}



}

}

void printlist(SqList& L) {

int i;

for (i = 0; i < L.length; i++) {

printf("%d  |", L.data[i]);

}

printf("\n");

}

int ListInsert(SqList* L, Elemtype e)    // 插入数据

{

if (!L->length)

{

L->length++;

L->data[0] = e;

}

else

{

L->length++;

int a = 0;

a = L->length - 1;

L->data[a] = e;              // 插入的数据放在最后一位

int i, j, m = 0;                  // 对插入之后的顺序表进行排序

for (i = 0; i <= L->length - 2; i++)

{

for (j = 0; j <= L->length - 2 - i; j++)

{

if (L->data[j] > L->data[j + 1])

{

m = L->data[j];

L->data[j] = L->data[j + 1];

L->data[j + 1] = m;

}

}

}

}

return 1;

}



int ListElemDelete(SqList* L, int x)//ListElemDelete 删除顺序表中所有相同的元素

{

int k = 0;

int delNUm = 0;

if (L->length <= 0)

{

return -1;

}



for (int i = 0; i < L->length; i++)

{

if (L->data[i] != x)



{

L->data[k] = L->data[i];

k++;

}



}

delNUm = L->length - k;

L->length = k;

return delNUm;



}

int ListRangeDelete(SqList* L, int start, int stop){

int k = 0;

    int delNUm = 0;

if (start > stop)

{

return -1;



}

if (L->length <= 0)

{

return -1;



}

for (int i = 0; i < L->length; i++)

{

if (L->data[i] < start || L->data[i] > stop)



{

L->data[k] = L->data[i];

k++;

}



}



delNUm = L->length - k;

L->length = k;

return delNUm;

}

int Listhebing(SqList* L1, SqList* L2, SqList* L3)//Listhebing 将两个有序表进行合并，并且将合并后的有序表返回

{



if (L1->length + L2->length > L3->listsize)

{

return -1;



}

int i = 0;

int j = 0;

int k = 0;

while (i < L1->length && j < L2->length)

{

if (L1->data[i] < L2->data[j])

{

L3->data[k++] = L1->data[i++];

}

else {

L3->data[k++] = L2->data[j++];



}



}

while (i < L1->length)

{

L3->data[k++] = L1->data[i++];

}

while (j < L2->length)

{

L3->data[k++] = L2->data[j++];



}

L3->length = k;

return 1;



}

int main() {

SqList L;

InitList(L);

int n,e,x;

int start, stop;

printf("输入顺序表数据个数：\n");

scanf_s("%d", &n);

creatlist(L, n);

sortlist(L);

printf("有序表为：\n");

printlist(L);



/*

printf("输入想要插入的数据e：\n");

scanf_s("%d", &e);

ListInsert(&L,e);

printf("插入后有序表为：\n");

printlist(L);*///插入元素



/*

printf("输入想要删除的数据x：\n");

scanf_s("%d", &x);

ListElemDelete(&L, x);

printf("删除后有序表为：\n");

printlist(L);*///删除元素



/*

printf("输入想要删除的数据范围：\n");

scanf_s("%d%d", &start,&stop);

ListRangeDelete(&L, start, stop);

printf("删除后有序表为：\n");

printlist(L);*///删除范围内元素



/*

SqList M;

InitList(M);

int n2;

printf("输入顺序表2数据个数：\n");

scanf_s("%d", &n2);

creatlist(M, n2);

sortlist(M);

printlist(M);

SqList N;

InitList(N);

N.listsize = InitSize;

N.length = L.length+M.length;

Listhebing(&L, &M, &N);

printf("合并后的有序表为：\n");

printlist(N);*///合并俩有序表

}

qq_57355321

关注

1
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
线性表的相关操作

实验1实验题目（1）设计一个有序顺序表类，即表中的数据元素按数据元素值递增有序。实现以下函数：（a）把给定值 e 插入有序表中。（b）删除值为 e 的所有数据元素。（c）合并两个有序表，得到一个新的有序表。（d）从有序顺序表中删除其值在给定值 s 与 t 之间（s＜t）的所有元素，如果 s≥t 或顺序表为空，则显示出错信息，并退出运行。（2）针对带头结点的单链表，试编写下列函数：（a）定位函数：在单链表中寻找给定值的结点。若找到，则返回该结点的地址（返回位序即可..
复制链接

扫一扫