【数据结构C语言实现】线性表

最新推荐文章于 2024-07-12 10:45:29 发布
最新推荐文章于 2024-07-12 10:45:29 发布
阅读量517 收藏 4
点赞数 1
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sc2333/article/details/115461914
版权

一、从数据结构的三要素了解线性表

1、逻辑结构

定义：线性表是具有相同数据类型的n（n>=0）个数据元素的有限序列
特点：除第一个元素外，每个元素有且仅有一个直接前趋，除最后一个元素外，每个元素有且仅有一个直接后继
线性表是一种逻辑结构

2、数据的运算

数据的运算即是对数据结构的操作集
以下通过抽象数据类型描述体现线性表

抽象数据类型描述

（参考中国大学mooc浙江大学数据结构）
在这里插入图片描述

3、存储结构

顺序表——顺序存储实现

数据结构与算法题目集（中文）6-2

#include<stdio.h>
#include<stdlib.h>

#define MAXSIZE 5
#define ERROR -1
typedef enum {false, true} bool;
typedef int ElementType;
typedef int Position;
typedef struct LNode *List;//定义一个指向结构体struct LNode的指针变量 
struct LNode {
    ElementType Data[MAXSIZE];
    Position Last;//表示最后一个元素 
};

/* 初始化 */
List MakeEmpty()
{
    List L;

    L = (List)malloc(sizeof(struct LNode));//将该内存空间首地址转换为list结构体指针类型 
    L->Last = -1;//->相当于java中某个方法中引用成员变量 即L.last

    return L;
}

/* 查找 */
Position Find( List L, ElementType X )
{
    Position i = 0;

    while( i <= L->Last && L->Data[i]!= X )
        i++;
    if ( i > L->Last )  return ERROR; /* 如果没找到，返回错误信息 */
    else  return i;  /* 找到后返回的是存储位置 */
}

/* 插入 */
/*注意:在插入位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是存储下标位置（从0开始），两者差1*/
bool Insert( List L, ElementType X, Position P ) 
{ /* 在L的指定位置P前插入一个新元素X */
    Position i;

    if ( L->Last == MAXSIZE-1) {
        /* 表空间已满，不能插入 */
        printf("表满"); 
        return false; 
    }  
    if ( P<0 || P>L->Last+1 ) { /* 检查插入位置的合法性 */
        printf("位置不合法");
        return false; 
    } 
    for( i=L->Last; i>=P; i-- )//从最后一个元素往前 ，如果是从前往后挪，后面的元素会被前一个元素覆盖 
        L->Data[i+1] = L->Data[i]; /* 将位置P及以后的元素顺序向后移动 */
    L->Data[P] = X;  /* 新元素插入 */
    L->Last++;       /* Last仍指向最后元素 */
    return true; 
} 

/* 删除 */
/*注意:在删除位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是存储下标位置（从0开始），两者差1*/
bool Delete( List L, Position P )
{ /* 从L中删除指定位置P的元素 */
    Position i;

    if( P<0 || P>L->Last ) { /* 检查空表及删除位置的合法性 */
        printf("位置%d不存在元素", P ); 
        return false; 
    }
    for( i=P+1; i<=L->Last; i++ )
        L->Data[i-1] = L->Data[i]; /* 将位置P+1及以后的元素顺序向前移动 */
    L->Last--; /* Last仍指向最后元素 */
    return true;   
}

int main()
{
    List L;
    ElementType X;
    Position P;
    int N;

    L = MakeEmpty();//初始化顺序表 
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        if ( Insert(L, X, 0)==false )
            printf(" Insertion Error: %d is not in.\n", X);
    }
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        P = Find(L, X);
        if ( P == ERROR )
            printf("Finding Error: %d is not in.\n", X);
        else
            printf("%d is at position %d.\n", X, P);
    }
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &P);
        if ( Delete(L, P)==false )
            printf(" Deletion Error.\n");
        if ( Insert(L, 0, P)==false )
            printf(" Insertion Error: 0 is not in.\n");
    }
 
    return 0; 
}


输入样例：
6
1 2 3 4 5 6
3
6 5 1
2
-1 6

输出结果：
在这里插入图片描述

链表——链式存储实现

不带头结点的链式表操作集

题源：PTA 数据结构与算法题目集（中文）6-5

#include<stdio.h>
#include<stdlib.h>

#define ERROR NULL 
typedef int ElementType;
typedef struct LNode *PtrTolNode;
struct LNode{
	ElementType Data;
	PtrTolNode Next;//指向下一个 
};
typedef PtrTolNode Position;
typedef PtrTolNode List;

//查找值为X的元素 (返回线性表中首次出现X的位置，若找不到则返回ERROR)
Position Find(List L,ElementType X){
	Position p=L;//p指向L的第一个结点
	while(p&&p->Data!=X){
		p=p->Next;
	}
	if(p){
		return p;
	}else{
		return ERROR;
	}
}

/*
 *不带头结点的插入 
 *将X插入在位置P指向的结点之前，返回链表的表头
 *如果参数P指向非法位置，则打印"Wrong Position for Insertion" 返回ERROR
 */ 
List Insert(List L,ElementType X,Position P){
	if(P==L){
		List Node = (List)malloc(sizeof(List));
		Node->Data=X;
		Node->Next=L;
		return Node;
	}
	Position pre,tmp;
	//查找P的前驱 
	for(pre=L;pre&&pre->Next!=P;pre=pre->Next);
	if(pre==NULL){//P所指结点不在L中 
		printf("Wrong Position for Insertion\n");
		return ERROR;
	}else{//找到了P所指结点前驱
		tmp=(Position)malloc(sizeof(struct LNode));//申请、填装结点 
		tmp->Data=X;
		/*
		修改前： 
		tmp->Next=pre->Next;
		pre->Next=tmp->Next;*/
		//修改后 
		tmp->Next = P;
        pre->Next = tmp;
		return L;
	}
} 
/*
不带头结点的删除 
将X插入在位置P指向的结点之前，返回链表的表头
若参数P指向非法位置，则打印"Wrong Position for Deletion"并返回ERROR 
*/ 
List Delete(List L,Position P){
	if(P==L){
		L=L->Next;
		return L;
	}
	Position pre;
	//查找表中P指向结点的前驱
	for(pre=L;pre&&pre->Next!=P;pre=pre->Next);
	if(pre==NULL){
		printf("Wrong Position for Deletion\n");
		return ERROR;
	}else{
		pre->Next=P->Next;
		free(P);
		return L;
	}
}

int main()
{
    List L;
    ElementType X;
    Position P, tmp;
    int N;

    L = NULL;
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        L = Insert(L, X, L);
        if ( L==ERROR ) printf("Wrong Answer\n");
    }
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        P = Find(L, X);
        if ( P == ERROR )
            printf("Finding Error: %d is not in.\n", X);
        else {
            L = Delete(L, P);
            printf("%d is found and deleted.\n", X);
            if ( L==ERROR )
                printf("Wrong Answer or Empty List.\n");
        }
    }
    L = Insert(L, X, NULL);
    if ( L==ERROR ) printf("Wrong Answer\n");
    else
        printf("%d is inserted as the last element.\n", X);
    P = (Position)malloc(sizeof(struct LNode));
    tmp = Insert(L, X, P);
    if ( tmp!=ERROR ) printf("Wrong Answer\n");
    tmp = Delete(L, P);
    if ( tmp!=ERROR ) printf("Wrong Answer\n");
    for ( P=L; P; P = P->Next ) printf("%d ", P->Data);
    return 0;
}

输入样例：

6
12 2 4 87 10 2
4
2 12 87 5

结果：

2 is found and deleted.
12 is found and deleted.
87 is found and deleted.
Finding Error: 5 is not in.
5 is inserted as the last element.
Wrong Position for Insertion
Wrong Position for Deletion
10 4 2 5
带头结点的链式表操作集

题源：PTA数据结构与算法题目集（中文）6-6

#include <stdio.h>
#include <stdlib.h>

#define ERROR NULL
typedef enum {false, true} bool;
typedef int ElementType;
typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

List MakeEmpty(){
/*
创建并返回一个空的线性表；
*/
	List L;
	L=(List)malloc(sizeof(struct LNode));
	L->Next=NULL;
	return L;
}

Position Find( List L, ElementType X ){
/*
返回线性表中X的位置。若找不到则返回ERROR
*/	
	Position p=L->Next;//第一个结点 
	while(p!=NULL){
		if(p->Data==X) return p;
		p=p->Next;
	}
	return ERROR;
}

bool Insert( List L, ElementType X, Position P ){
/*
将X插入在位置P指向的结点之前，返回true。
如果参数P指向非法位置，则打印“Wrong Position for Insertion”，返回false
*/
	Position tmp,pre;
	for(pre=L;pre&&pre->Next!=P;pre=pre->Next);//找p的前驱
	if(pre==NULL){
		printf("Wrong Position for Insertion\n");
		return false;
	} 
	else{
		tmp=(Position)malloc(sizeof(struct LNode));//分配新的空间给新的结点
		tmp->Data=X;
		tmp->Next=P;
		pre->Next=tmp;
		return true; 
	}
}


bool Delete( List L, Position P ){
/*
将位置P的元素删除并返回true。
若参数P指向非法位置，则打印“Wrong Position for Deletion”并返回false。
*/ 
	Position pre;
	for(pre=L;pre&&pre->Next!=P;pre=pre->Next);//找p的前驱
	if(pre==NULL){
		printf("Wrong Position for Deletion\n");
		return false;
	}
	else{
		pre->Next=P->Next;
		free(P);//释放结点P的空间 
		return true;
	}
}

int main()
{
    List L;
    ElementType X;
    Position P;
    int N;
    bool flag;

    L = MakeEmpty();
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        flag = Insert(L, X, L->Next);
        if ( flag==false ) printf("Wrong Answer\n");
    }
    scanf("%d", &N);
    while ( N-- ) {
        scanf("%d", &X);
        P = Find(L, X);
        if ( P == ERROR )
            printf("Finding Error: %d is not in.\n", X);
        else {
            flag = Delete(L, P);
            printf("%d is found and deleted.\n", X);
            if ( flag==false )
                printf("Wrong Answer.\n");
        }
    }
    flag = Insert(L, X, NULL);
    if ( flag==false ) printf("Wrong Answer\n");
    else
        printf("%d is inserted as the last element.\n", X);
    P = (Position)malloc(sizeof(struct LNode));
    flag = Insert(L, X, P);
    if ( flag==true ) printf("Wrong Answer\n");
    flag = Delete(L, P);
    if ( flag==true ) printf("Wrong Answer\n");
    for ( P=L->Next; P; P = P->Next ) printf("%d ", P->Data);
    return 0;
}

输入样例

6
12 2 4 87 10 2
4
2 12 87 5

输出结果

2 is found and deleted.
12 is found and deleted.
87 is found and deleted.
Finding Error: 5 is not in.
5 is inserted as the last element.
Wrong Position for Insertion
Wrong Position for Deletion
10 4 2 5
sc2333
关注
c语言线性表
huang_c_c的博客
02-20 476
线性表 线性表：零个或多个数据元素的有限序列。 注意： 1线性表有序 元素之间有序列。若元素存在多个，则第一个无前驱，最后一个无后驱，其他元素仅有一个前驱和后驱。 2.线性表有限 数列之内的数据有限。无限的数列只存在于数学概念之中。 所以线性表元素个数n就定义为线性表的长度，当n=0时，为空表。 线性表的两种物理结构： 一.顺序存储结构： 1.定义 用一段地址连续的存储单元依次存储线性表的数据结构...
基于C语言数据结构-线性表
venus321的博客
11-29 356
线性结构 线性表 线性表表示与实现 顺序表的实现 顺序表操作集合 循环链表 两个循环链表的合并 双向链表的实现 双向链表的插入删除的示意图 单链表的置返 线性结构 是指在数据元素的非空有限集合中，存在唯一的一个称为第一个的数据元素（头结点），存在唯一的一个称为最后一个的数据元素（末节点），除了第一个外，集合中每一个数据元素都只有一个直接前驱，除了最后一个外，
c语言的数据结构线性表的实现
一曲无痕奈何
09-18 265
#include <stdlib.h> # include <stdio.h> # include <malloc.h> # define MaxSize 50 typedef char ElemType; typedef struct { ElemType data[MaxSize]; //存放顺序表元素 int length; //存放顺序表的长度...
线性表及其应用C语言实现（数据结构复习最全笔记）（期末复习最新版）
markconca的博客
10-05 6336
引子 线性表 一、顺序表的表示与实现 注意我写的代码和课本的差不多，和PPT的风格还是有些区别的，但本质没啥区别其实，你会哪个都成 1.线性表的顺序结构定义 #define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量 #define LISTINCREMENT 10 //线性表存储空间的分配增量 typedef st......
数据结构——线性表（C语言实现）
最新发布
m0_56399733的博客
07-12 1410
数据结构线性表的内容：顺序表+链表，增删查改，C语言实现，含有运行结果！！！动态顺序变、单链表、双链表，循环链表；
数据结构线性表C语言实现
aquaria_pp的博客
03-22 381
#include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define INITSIZE 100 typedef int Status; typed...
数据结构之线性表及C语言实现
maojiaoliang的博客
04-24 1890
线性表 定义 线性表是具有相同特性数据类型的n个数据元素的有限序列。其中n为表长，n=0为空表。 结构 开始结点 -a1- 前驱结点 - a2-后继结点 - an-终端结点 特点 表中元素的个数有限 表中元素具有逻辑上的顺序性，表中元素有其先后次序 表中元素都是数据元素，每个元素都是单个元素 每个元素占有相同大小的存储空间 注意 线性表是一种逻辑结构，表示元素之间的一对一关系 总结 线性表中地元素的类型可以为简单类型（int char float...），也可...
数据结构——C语言实现线性表篇 稳扎稳打 步步为营！
m0_50997929的博客
04-26 328
一 线性表的定义 线性表是具有相同数据类型的N（N >= 0）个数据元素的有限数列 ①数据类型 :这点类似数组 比较好理解 表示其存放的元素类型唯一，或全部整形，或全是字符型等等。 二 线性表的物理存储结构 用一段地址连续的存储单元依次存储数据结构 这里要注意地址连续的概念 这里的地址连续指的是物理上的连续，也就是在计算机内部，类似于数组，当我们向堆区申请空间时，系统给我们的是一片连续的物理存储空间，我们看到的1和2在一起在计算机内部，他们也实际上是连在一起的 并且要注意 各个元素之间是一个个挨
数据结构c语言实现线性表
10-26
数据结构与算法，c语言实现线性表的顺序存储
数据结构C语言版线性表算法2.4-数据结构c语言版严蔚敏顺序线性表12个基本操作及算法的实现... 定义线性表节点的结构.pdf
04-18
在这个场景中，我们关注的是C语言实现的顺序线性表，由严蔚敏教授的经典教材《数据结构》中的内容作为指导。顺序线性表是指线性表的元素在内存中是连续存储的，便于进行快速访问。 首先，我们需要了解线性表的节点...
c语言实现线性表的算法-数据结构算法代码实现——线性表的定义（一） 定义线性表节点的结构.pdf
04-18
线性表是一种最常用的数据结构，由类型相同的n个（n≥0）数据元素组成的有序序列。线性表的特点是数据元素之间存在“一一对应”（序偶关系）的关系。 线性表的定义可以用二元组的形式表示为：List = (D,R)，其中D是...
线性表（c语言代码）
03-14
数据结构： C语言代码 线性表的创建、插入、查找、删除
c语言实现线性表
06-22
c语言实现线性表
数据结构C语言版线性表的动态分配顺序存储结构表示和实现文库.pdf
10-20
数据结构C语言版线性表的动态分配顺序存储结构表示和实现 本文档主要讲述了C语言版线性表的动态分配顺序存储结构的表示和实现。下面是从给定的文件信息中生成的相关知识点： 一、线性表的动态分配顺序存储结构 ...
【C语言之线性表】
qq_39842609的博客
03-23 4394
C语言之线性表
C语言之线性表
Limit_Fly的博客
06-16 802
文章目录什么是线性表线性表的表现形式线性表的常见操作在顺序表的任何一个地方插入数据在顺序表中任意位置删除要给节点得到整个顺序表的大小将线性表重置为空表销毁顺序线性表判断是否为空表代码测试 什么是线性表 线性表，也叫做顺序表。类似链表，但是里面的数据存储空间是连续的，不像链表是片段的，不连续。 顺序存储，数据连续的存储，中间不能有空值。 如果需要插入数据，在插入的位置之后的数据需要一个一个的往...
C语言线性表
127.0.0.1的博客
11-11 1058
线性表 #include <stdio.h> #include <stdlib.h> #define LIST_INIT_SIZE 100 //线性表存储空间的初始分量 #define LISTINCREMENT 10 //线性表存储空间增量(当存储空间不够时使用) typedef int ElemType;//元素类型 //声明线性表结构 typedef struct sqlists{ ElemType *elem; //其实内存地址 int length;
c语言 线性表
凡事都是靠练习
02-05 299
线性表的创建 数据插入与删除 链表与线性表的对比
用C语言求线性表中元素的最大值的函数代码
03-21
以下是用C语言求线性表中元素的最大值的函数代码： ```c #include <stdio.h> int max(int arr[], int n) { int max = arr[0]; for (int i = 1; i < n; i++) { if (arr[i] > max) { max = arr[i]; } } return max; } int main() { int arr[] = {1, 2, 3, 4, 5}; int n = sizeof(arr) / sizeof(arr[0]); printf("The maximum element in the array is %d", max(arr, n)); return 0; } ``` 希望能够帮到你！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值