数据结构之线性表

最新推荐文章于 2024-01-28 00:46:47 发布
最新推荐文章于 2024-01-28 00:46:47 发布
阅读量790 收藏
点赞数
分类专栏： 学习笔记 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chaim998/article/details/121317972
版权

数据结构之线性表(加强版)

一、顺序表

1、头文件

#ifndef LINEHEAD_H_INCLUDED
#define LINEHEAD_H_INCLUDED

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



//---------------------------------------------------------------------

//1.1静态线性表数据类型
#define Maxsize 30
typedef struct
{
    int data[Maxsize];
    int length;
}SqList;

//1.2静态线性表初始化
void InitList(SqList &L);

//1.3.1初始化静态线性表的遍历
void InitPrintSqList(SqList &L);

//1.3.2赋值后静态线性表的遍历
void PrintSqList(SqList &L);

//1.4给顺序表赋值
void Voluation(SqList &L);
//1.4.2给顺序表自定义赋值
void Vol_Custom(SqList &L);

//1.5.1删除顺序表中的值
bool Del_Min(SqList &L,int &value);

//1.5.2删除顺序表中特定的值
void Del_x(SqList &L,int x);

//1.5.3给有序顺序表赋值
void VoluationOrder(SqList &L);

//1.5.4.1从有序顺序表中删除范围值
bool Del_s_t(SqList &L,int s,int t);

//1.5.4.2从顺序表中删除范围值
bool Del_s_t2(SqList &L,int s,int t);

//5.5删除有序顺序表中重复的值
void Del_Same(SqList &L);

//1.6改变顺序表中的值
void Reverse(SqList &L);

//7、增加顺序表中的值
bool Merge(SqList L1,SqList L2,SqList &L3);

//--------------------------------------------------------------------

//2.1动态线性表数据结构
#define InitSize 10//表长度的初始定义
typedef struct
{
    int *data;
    int maxsize,length;//动态线性表最大容量和当前个数
}SeqList;

//2.2动态线性表初始化
void InitSeqList(SeqList& L);
void InitData(SeqList &L);

//2.3动态增加
void IncreaseSize(SeqList& L,int len);

//2.4动态线性表的遍历
void PrintSeqList(SeqList &L);




//---------------------------------------------------------------------
//10.1随机生成0到10的随机树
int Random0_10();


#endif // LINEHEAD_H_INCLUDED

2、静态线性表

#include"LineHead.h"

//1、静态线性表数据类型


//2、静态线性表初始化
/*
数组初始化是因为没有初始化的数组里面有一些脏数据
*/
void InitList(SqList &L)
{
    for(int i=0;i<Maxsize;i++)
    {
        L.data[i]=0;//元素全为零
    }
    L.length=0;//静态线性表长度为零
}

//3.1初始化静态线性表的遍历
void InitPrintSqList(SqList &L)
{
    for(int i=0;i<Maxsize;i++)
    {
        printf("%d\t",L.data[i]);
    }
}
//3.2赋值后静态线性表的遍历
void PrintSqList(SqList &L)
{
    for(int i=0;i<L.length;i++)
    {
        printf("%d\t",L.data[i]);
    }
}


//4、给顺序表赋值
void Voluation(SqList &L)
{
    srand((unsigned)time(NULL));
    for(int i=0;i<Maxsize;i++)
    {
        L.data[i]=Random0_10();
    }
    L.length=Maxsize;
}

//4.2给顺序表自定义赋值
void Vol_Custom(SqList &L)
{
    int b[]={1,2,2,3,4,5,5,5,6,7,7,8,8,9,9};
    for(int i=0;i<sizeof(b)/sizeof(b[0]);i++)
        L.data[i]=b[i];
    L.length=sizeof(b)/sizeof(b[0]);
}

//----------------------------------------------------------------------------

//5、删除顺序表中的值
//5.1删除顺序表中的最小值
/*
从顺序表中删除最小元素并返回删除的值，空出的位置由最后一个元素填补，
若顺序表为空，则显示错误信息并退出
*/
bool Del_Min(SqList &L,int &value)
{
    //若删除成功则返回true，否则返回false
    if(L.length==0)
    {
        return false;
    }
    value = L.data[0];
    int pos = 0;
    for(int i=0;i<L.length;i++)
    {
        if(value > L.data[i])
        {
            value = L.data[i];
            pos = i;
        }
    }
    L.data[pos] = L.data[L.length-1];
    L.length--;
    return true;

}
//5.2删除顺序表中特定的值
/*
删除顺序表中特定值,要求时间复杂度为n，空间复杂度为1
*/
void Del_x(SqList &L,int x)
{
    int k=0;//记录不等于x的元素个数
    for(int i=0;i<L.length;i++)
    {
        if(L.data[i] != x)
        {
            L.data[k]=L.data[i];//k的值永远小于或等于i（i，k不同速）
            k++;
        }
    }
    L.length=k;
}

//5.3给有序顺序表赋值
void VoluationOrder(SqList &L)
{
    for(int i=0;i<Maxsize-10;i++)
    {
        L.data[i]=i;
    }
    L.length=Maxsize-10;
}

//5.4.1从有序顺序表中删除范围值
/*
删除有序顺序表从s到t的值，s<t，若s，t不合理或者表为空返回错误信息
*/
bool Del_s_t(SqList &L,int s,int t)
{
    int i,j;
    if(s>=t||L.length==0)
        return false;
    for(i=0;i<L.length&&L.data[i]<s;i++);
    if(i>=L.length)
        return false;
    for(j=i;j<L.length&&L.data[j]<=t;j++);//这里是易错点，我们要找的是大于t的值的下标，但是条件是小于等于t
    if(j>=L.length)
        return false;
    for(;j<L.length;i++,j++)
    {
        L.data[i]=L.data[j];
    }
    L.length=i;
    return true;
}

//5.4.2从顺序表中删除范围值
/*
删除顺序表从s到t的值，s<t，若s，t不合理或者表为空返回错误信息
*/
bool Del_s_t2(SqList &L,int s,int t)
{
    int i,k=0;//k记录不在范围内的元素的个数
    for(i=0;i<L.length;i++)
    {
        if(L.data[i]>=s&&L.data[i]<=t)
            continue;
        else
        {
            L.data[k]=L.data[i];//再一次利用i，k不同速
            k++;
        }
    }
    L.length=k;
    return true;
}

//5.5删除有序顺序表中重复的值
/*
从有序顺序表中删除其重复的值，使所有元素的值均不同
*/
void Del_Same(SqList &L)
{
    if(L.length==0)
        return;
    int i,k;//k是不重复元素的个数
    for(k=0,i=1;i<L.length;i++)
    {
        if(L.data[k]!=L.data[i])
            L.data[++k]=L.data[i];//第三次使用i，k不同速
    }
    L.length=k+1;
}


//6、改变顺序表中的值
/*
逆置顺序表，要求空间复杂度为1
*/
void Reverse(SqList &L)
{
    int temp;
    for(int i=0;i<L.length/2;i++)
    {
        temp = L.data[i];
        L.data[i] = L.data[L.length-1-i];
        L.data[L.length-1-i] = temp;
    }
}

//7、增加顺序表中的值
/*
将两个有序表合并为一个有序表
*/
bool Merge(SqList L1,SqList L2,SqList &L3)
{
    if(L1.length+L2.length>L3.length)
        return false;
    int i=0,j=0,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 true;
}

4、动态线性表

#include"LineHead.h"

//1、动态线性表数据结构

//2、动态线性表初始化
//InitSize 10  表长度的初始定义
void InitSeqList(SeqList &L)
{
    L.data=(int*)malloc(InitSize * sizeof(int));
    L.length=0;
    L.maxsize=InitSize;
    InitData(L);
}
void InitData(SeqList &L)
{
    for(int i=0;i<L.maxsize;i++)
    {
        L.data[i]=0;//元素全为零
    }
    L.length=0;//动态线性表当前长度为零
}


//3、动态增加
void IncreaseSize(SeqList &L,int len)
{
    int *P = L.data;
    L.data = (int*)malloc((L.maxsize+len)*sizeof(int));
    for(int i=0;i<L.length;i++)
    {
        L.data[i]=P[i];
    }
    L.maxsize=L.maxsize+len;
    free(P);
    InitData(L);
}

//3、动态线性表的遍历
void PrintSeqList(SeqList &L)
{
    for(int i=0;i<L.maxsize;i++)
    {
        printf("%d\t",L.data[i]);
    }
}

5、随机函数

#include"LineHead.h"

//随机生成0到10的随机树
int Random0_10()
{
    //srand((unsigned)time(NULL));随机函数放在被调用的方法体里面无效

    return rand()%10;
}

6、main方法

#include"LineHead.h"


int main()
{

    //1、静态线性表
    SqList L;
    printf("未初始化的静态线性表:\n");
    InitPrintSqList(L);
    InitList(L);
    printf("\n初始化的静态线性表:\n");
    InitPrintSqList(L);
    Voluation(L);
    printf("\n赋值后的静态线性表:\n");
    PrintSqList(L);
    //-----------------操作----------------
    printf("\n删除最小元素后的静态线性表\n");
    int value = 0;
    bool a=Del_Min(L,value);
    printf("是否删除最小值%d:",value);
    if(a)
        printf("True");
    else
        printf("False");
    printf("\n删除最小元素以后的静态线性表:\n");
    PrintSqList(L);

    printf("\n逆序后的静态线性表：\n");
    Reverse(L);
    PrintSqList(L);

    printf("\n删除顺序表中的特定值5：\n");
    Del_x(L,5);
    PrintSqList(L);

    //-------------有序表-----------------
    SqList LOrder;
    printf("\n给有序顺序表赋值:\n");
    VoluationOrder(LOrder);
    PrintSqList(LOrder);

    bool a1 = Del_s_t(LOrder,5,7);
    printf("\n是否删除5-7的值:\n");
    if(a1)
        printf("True");
    else
        printf("False");
    printf("\n删除有序顺序表5到7的值：\n");
    PrintSqList(LOrder);

    bool a2 = Del_s_t2(L,5,7);
    printf("\n是否删除5-7的值:\n");
    if(a2)
        printf("True");
    else
        printf("False");
    printf("\n删除顺序表5到7的值：\n");
    PrintSqList(L);

    SqList LOrder2;
    Vol_Custom(LOrder2);
    printf("\n自定义有序顺序表：\n");
    PrintSqList(LOrder2);
    printf("\n去掉有序顺序表中重复的值：\n");
    Del_Same(LOrder2);
    PrintSqList(LOrder2);

    printf("\n\n有序顺序表1：\n");
    PrintSqList(LOrder);
    printf("\n有序顺序表2：\n");
    PrintSqList(LOrder2);
    SqList LOrder3;
    int a3 = Merge(LOrder,LOrder2,LOrder3);
    printf("----%d------",LOrder3.length);
    printf("\n是否将两个有序顺序表合并：\n");
    if(a3)
        printf("True");
    else
        printf("False");
    printf("\n将两个有序顺序表合并：\n");
    PrintSqList(LOrder3);


//-------------------------------------------------------------------
    //2、动态线性表
    SeqList L1;
    printf("\n\n----------------------------------------------------------------------------------------\n");
    printf("初始化的动态线性表:\n");
    InitSeqList(L1);
    PrintSeqList(L1);
    printf("\n\n动态增加的动态线性表:\n");
    IncreaseSize(L1,5);
    PrintSeqList(L1);
    return 0;
}
Chaim998
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构线性表的基本函数
AirBlue的专栏
11-15 1189
#include #include #include #define TURE 1 #define FLASE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 //不可行 #define OVERFLOW -1 #define LIST_INIT_SIZE 50 //
动态线性表基础操作
qq_67303660的博客
12-31 176
动态线性表基础操作
C语言顺序表及其实现
ygy555的博客
07-29 644
顺序表
数据结构之线性表.rar
04-07
使用数组完成线性表的编写 有增删修改查找的操作使用数组完成线性表的编写
Java数据结构之线性表
08-31
线性表是其组成元素间具有线性关系的一种数据结构，对线性表的基本操作主要有，获取元素，设置元素值，遍历，插入，删除，查找，替换，排序等。而线性表可以采用顺序储存结构和链式储存结构，本节主要讲解顺序表、...
数据结构之线性表的实现.rar
07-27
数据结构之线性表的实现，参照数据结构严蔚敏版进行开发，对代码进行修改可以进行更简单的操作。基于VS2010，可直接运行。
数据结构之线性表教程3.zip
01-02
数据结构：数据结构之线性表教程3.zip
用C#学习数据结构之线性表
12-22
　线性表是简单、基本、常用的数据结构。线性表是线性结构的抽象(Abstract)，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。这种一对一的关系指的是数据元素之间的位置关系，即：（1）除第一个位置的...
【数据结构-C语言实现】线性表及其操作函数
希望你会喜欢
01-10 1043
#include<stdio.h> #include<stdlib.h> #define Status int // 可定义为任意数据类型 #define INIT_SIZE 20 //线性表存储空间的初始分配量 #define LISTINCREMENT 10 //线性表存储空间的分配增量 //数据类型 typedef struct { int number; }ElemType; //顺序表存储结构 typedef struct { ElemType *pstu; //存
单链表宇宙最全基础操作
comcc44的博客
01-31 869
   单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +[ 指针](https://baike.baidu.com/item/ 指针/2878304)(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。接下来我们来学习如何用C语言写单链表。 一、单链表与单链表结点的创建函数   我们需要在C语言最基础的主函数中进行 #include <stdio.h> #inc
数据结构之线性表（1）
A3118552122的博客
03-23 199
线性表的基本操作
数据结构1 - 线性表
Janet的博客
09-03 496
一、算法 1.算法的时间复杂度 在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随n的变化情况并确定T(n)的数量级。算法的时间复杂度，也就是算法的时间度量，记作：**T(n)=O(f(n))。**它表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐进时间复杂度，简称为时间复杂度。其中f(n)是问题规模n的某个函数。 1.1常见的时间...
c语言线性表知识点,线性表结构一——顺序表初始化，插入，删除，查找。typedef 解释，链表知识点总结...
weixin_39869733的博客
05-26 719
目录一、顺序表定义及特点1.顺序表定义2.顺序表特点二、顺序表定义三、顺序表插入运算四、顺序表删除运算五、顺序表元素查找六、顺序表取元素数据七、主函数定义注1. typedef 解释注2. 链表知识点总结一、顺序表定义及特点1.顺序表定义用数组存储线性表，称作线性表的顺序存储结构或顺序映像，用这种方法存储的线性表称作顺序表。2.顺序表特点1)逻辑上相邻，对应物理地址相邻2)任一元素可以随机存取3)...
线性表单链表的基本操作：添加、插入、删除、查找（非常全面，C语言实现）
weixin_61125362的博客
11-11 509
​链表的创建；插入（头插、尾插）；删除（头删、尾删、指点元素删除）；查找元素；注销链表 ​
C语言主函数的形式
最新发布
jdm_sam的博客
01-28 503
C语言主函数main()的形式
main函数
LindenTao
01-22 334
C函数总是从main函数开始执行，main函数的原型是：//argc是命令行参数的数目，argv是指向参数的各个指针所构成的数组 int main(int argc,char *argv[]);示例代码：/***************************************** > File Name : print_argc.cpp > Description : main函数解析示例代
数据结构（C语言）——线性表（定义，基本操作）
weixin_62677583的博客
12-14 5324
数据结构（C语言）——线性表（定义，基本操作）一、 线性表的定义二、线性表的基本操作什么时候要传入引用“==&==”————对参数的修改结果需要“==带回来==”为什么要实现数据结构的基本操作？ 一、 线性表的定义 线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为 L=（a1,a2,a3,…,ai,ai+1，…,an) 注：每个数据元素所占空间相等，有次序。 几个概念： （1）ai是线性表中的“第i个”元素
数据结构c语言线性表
10-26
C语言中的线性表是一种常见的数据结构，它是由一组相同数据类型的元素组成的有限序列。线性表中的元素按照线性的顺序排列，每个元素都有一个前驱和一个后继，除了第一个元素没有前驱，最后一个元素没有后继。 在C语言中，线性表可以使用数组或者链表来实现。使用数组实现的线性表称为顺序表，使用链表实现的线性表称为链表。 顺序表是一种连续存储的数据结构，它可以随机访问任意位置的元素。在顺序表中，每个元素占用一个固定大小的存储单元，可以通过下标来访问元素。但是，顺序表的插入和删除操作比较耗时，因为需要移动大量元素。 链表是一种非连续存储的数据结构，它通过指针将各个元素连接起来。在链表中，每个元素包含两个部分：数据域和指针域。数据域用于存储元素的值，指针域用于指向下一个元素的地址。链表的插入和删除操作比较快速，但是访问任意位置的元素需要从头开始遍历链表。 线性表在实际应用中非常广泛，例如数组、队列、栈等都是线性表的特殊形式。在C语言中，可以使用结构体来定义线性表的数据结构，然后通过函数来实现线性表的各种操作，例如插入、删除、查找等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值