C/C++线性表---顺序表算法全解析

最新推荐文章于 2024-03-13 15:46:15 发布
最新推荐文章于 2024-03-13 15:46:15 发布
阅读量912 收藏
点赞数
分类专栏： C语言 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013355826/article/details/78645358
版权

课程笔记来源：

MOOC网

郝斌数据结构

之前学过一遍数据结构，面试时候真的忘光了，之前去华环让写一个简单的链表删除算法也是没有写出来，想做CS，必须把数据结构学好了，还是再来一遍吧。

--------------------------------------------------------------------------------------------------------------------------------------------------------------------

顺序表定义

顺序表就是把线性表中的所有元素按照逻辑顺序，依次存储到从计算机存储器中指定存储位置开始的一块连续存储空间中。

顺序表的存储类型：线性表的首地址，线性表的总长度，线性表的有效长度。

优点：任意元素可以随机存取

缺点：插入和删除操作时候，需要移动大量元素

typedef struct Arr
{
    int *pBase; //线性表基地址相当于数组首地址
    int len;  //线性表的总长度
    int cnt;  //线性表总有效元素
}SqList;

顺序表的基恩算法
初始化顺序表
构造一个空的顺序表，给线性表分配 len 个长度，有效长度 cnt 为0个。
注意：malloc分配时候，要进行成功与否的判断。 
void InitArr(SqList *pArr,int len)
{
  pArr->pBase = (int*)malloc(sizeof(int)*len);
  if(NULL == pArr)
  {
      printf("分配失败\n");
      exit(-1);
  }
  pArr->cnt = 0;
  pArr->len = len;
}
判断顺序表是否为空
如果线性表的有效长度为 0 ，则线性表为空。 
int is_empty(SqList *pArr)
{
    if( 0 == pArr->cnt)
        return true;
    else
        return false;
}
判断线性表是否为满
如果线性表的有效长度为 len ，则线性表为满。 
int is_full(SqList *pArr)
{
    if(pArr->cnt == pArr->len)
        return true;
    else
        return false;
}
线性表的遍历
如果线性表为空，则无需输出，否则用 for 循环遍历输出。 
void showArr(SqList *pArr)
{
    int i;
    if( true ==is_empty(pArr))
    {
        printf("线性表元素为空\n");
    }
    else
    {
        for(i=0;i<pArr->cnt;i++)
            printf("%d\t",pArr->pBase[i]);
            puts("\n");
    }
}
线性表追加元素
如果线性表已经满了，则无法添加；否则，添加元素，有效元素加1。
注意：添加完元素后，有效位加1。
  
void appendArr(SqList *pArr,int ele)
{
    if(is_full(pArr))
        printf("线性表已经满了\n");
    else
    {
        pArr->pBase[pArr->cnt] = ele;
        pArr->cnt++;

    }
}
删除指定位置元素
判断是否为空，逻辑位置必须大于等于1，还必须小于等于cnt。从指定位置pos到cnt，依次向前移动一位。
注意：输入的是逻辑位置，必须和ele下标位置区分开。可以举个例子很好的区分开。 

void deleteArr(SqList *pArr,int pos)
{
    int i;
    if(true == is_empty(pArr))
        printf("线性表是空\n");
    if(pos < 1 || pos > pArr->cnt)
        printf("输入位置无效\n");
    else
    {
        for(i=pos;i<pArr->cnt;i++)
           pArr->pBase[i-1] = pArr->pBase[i];
        pArr->cnt--;
    }

}

指定位置添加元素

判断是否为满，位置必须在1和cnt+1 

void insertEle(SqList *pArr,int pos,int ele)
{
   int i;
   if(is_full(pArr))
        printf("线性表已满\n");
   if(pos<1 || pos > pArr->cnt+1)
        printf("删除的位置无效\n");
   else
   {
       for(i= pArr->cnt-1;i>=pos-1;i--)
            pArr->pBase[i+1] = pArr->pBase[i];
       pArr->pBase[pos-1] =ele;
       pArr->cnt++;
   }
}


总体的C代码： 
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include <time.h>

#define ListMax 10
#define true     1
#define false    0

typedef struct Arr
{
    int *pBase; //线性表基地址相当于数组首地址
    int len;  //线性表的总长度
    int cnt;  //线性表总有效元素
}SqList;

//线性表初始化
void InitArr(SqList *pArr,int len)
{
  pArr->pBase = (int*)malloc(sizeof(int)*len);
  if(NULL == pArr)
  {
      printf("分配失败\n");
      exit(-1);
  }
  pArr->cnt = 0;
  pArr->len = len;
}
//判断是否为空
int is_empty(SqList *pArr)
{
    if( 0 == pArr->cnt)
        return true;
    else
        return false;
}
//判断是否满了
int is_full(SqList *pArr)
{
    if(pArr->cnt == pArr->len)
        return true;
    else
        return false;
}
//线性表元素遍历
void showArr(SqList *pArr)
{
    int i;
    if( true ==is_empty(pArr))
    {
        printf("线性表元素为空\n");
    }
    else
    {
        for(i=0;i<pArr->cnt;i++)
            printf("%d\t",pArr->pBase[i]);
            puts("\n");
    }
}
//线性表追加
void appendArr(SqList *pArr,int ele)
{
    if(is_full(pArr))
        printf("线性表已经满了\n");
    else
    {
        pArr->pBase[pArr->cnt] = ele;
        pArr->cnt++;

    }
}
//删除线性表
void deleteArr(SqList *pArr,int pos)
{
    int i;
    if(true == is_empty(pArr))
        printf("线性表是空\n");
    if(pos < 1 || pos > pArr->cnt)
        printf("输入位置无效\n");
    else
    {
        for(i=pos;i<pArr->cnt;i++)
           pArr->pBase[i-1] = pArr->pBase[i];
        pArr->cnt--;
    }

}
//指定位置pos添加元素ele
//元素pos的位置是从 1 到 pArr->len
void insertEle(SqList *pArr,int pos,int ele)
{
   int i;
   if(is_full(pArr))
        printf("线性表已满\n");
   if(pos<1 || pos > pArr->cnt+1)
        printf("删除的位置无效\n");
   else
   {
       for(i= pArr->cnt-1;i>=pos-1;i--)
            pArr->pBase[i+1] = pArr->pBase[i];
       pArr->pBase[pos-1] =ele;
       pArr->cnt++;
   }
}
//得到指定位置的值
int getArr(SqList *pArr,int pos)
{
    if(true == is_empty(pArr))
        printf("线性表是空\n");
    if(pos < 1 || pos > pArr->cnt)
        printf("输入位置无效\n");
    return pArr->pBase[pos-1];
}
//查找第一个元素等于ele的逻辑号
int locateEle(SqList *pArr, int ele)
{
    int i=0;
    while(i<pArr->cnt && pArr->pBase[i]!= ele) i++;
    if(i >=pArr->cnt) return 0;
    else   return i+1;
}
//线性表元素倒置
void inversionArr(SqList *pArr)
{
    int i=0;
    int j=pArr->cnt-1;
    int temp;
    while(i<j)
    {
        temp = pArr->pBase[i];
        pArr->pBase[i] = pArr->pBase[j];
        pArr->pBase[j] = temp;
        i++;
        j--;
    }
}
//线性表排序
void sortArr(SqList *pArr,int m)
{
    switch(m)
    {
        case 1:  //冒泡排序
        {
            int i,j,temp;
            for(i=0;i<pArr->cnt-1;i++)
            {
                for(j=i+1;j<pArr->cnt;j++)
                {
                    if(pArr->pBase[i] > pArr->pBase[j])
                    {
                          temp = pArr->pBase[i];
                          pArr->pBase[i] = pArr->pBase[j];
                          pArr->pBase[j] = temp;
                    }
                }
            }

            break;
        }
        case 2:  //选择排序
        {
          int n = pArr->cnt;
           while(n >1)
           {
              int i,temp,pos=0;
              int max=pArr->pBase[0];
              for(i=0;i<n;i++)
              {
                  if(max < pArr->pBase[i])
                  {
                      max = pArr->pBase[i];
                      pos = i;
                  }
              }
              temp = pArr->pBase[pos];
              pArr->pBase[pos] = pArr->pBase[n-1];
              pArr->pBase[n-1] = temp;
              n--;
           }
           break;
        }
        case 3: //插入排序
        {
            int i;
            for(i=1;i<pArr->cnt;i++)
            {
                int temp = pArr->pBase[i];
                while(i>0 && pArr->pBase[i-1] > temp)
                {
                   pArr->pBase[i] = pArr->pBase[i-1];
                   i--;
                }
                pArr->pBase[i] = temp;
            }

        }
    }
}
void main()
{

    int i;
    SqList arr;
    srand( (unsigned)time( NULL ) );
    InitArr(&arr, ListMax);
    for(i=0;i<7;i++)
        appendArr(&arr,rand()%100+1);
    showArr(&arr);
    insertEle(&arr,8,11);
    showArr(&arr);
    deleteArr(&arr,6);
    showArr(&arr);
    printf("%d\n",getArr(&arr,5));
    printf("%d\n",locateEle(&arr,4));
    inversionArr(&arr);
    sortArr(&arr,3);
    showArr(&arr);
}

C++代码：

使用了模板类，实现泛函，增强代码的重复性。 
#include<iostream>
#include<stdlib.h>
#include<time.h>

#define MAXSIZE 20
using namespace std;

//使用模板类是为了实现泛型，
//使用模板类可以使用不同的数据类型
template <class T>
class SqList
{
public:
    SqList(){cnt = 0;}//无参构造函数
    SqList(T a[],int len);//有参构造函数
    ~SqList(){} //析构函数
    bool isEmpty();//是否为空
    bool isFull(); //是否满了
    void showArr();  //顺序表遍历
    T    getArr(int pos); //得到指定位置元素 ele
    void appendArr(T ele);//顺序表追加
    void deleteArr(int pos);//删除指定位置元素
    void insertEle(int pos,T ele); //指定位置添加元素ele
private:
    T data[MAXSIZE]; //顺序表首地址
    int cnt; //顺序表的有效长度
};
//顺序表的无参初始化
template <class T>
SqList<T>::SqList(T a[],int len)
{
    if(len>MAXSIZE)
        cout<<"参数无效"<<endl;
    for(int i =0 ;i<len;i++)
        data[i] = a[i];
    cnt = len;
}

template <class T>
void SqList<T>::showArr()
{
    for(int i=0;i<cnt;i++)
        cout<<data[i]<<" ";
    cout<<endl;
}
template <class T>
bool SqList<T>::isEmpty()
{
    if(cnt == 0)
        return true;
    else
        return false;
}
template <class T>
bool SqList<T>::isFull()
{
    if(cnt == MAXSIZE)
        return true;
    else
        return false;
}
template <class T>
void SqList<T>::appendArr(T ele)
{
    if(isFull())
        cout<<"顺序表已经满了"<<endl;
    else
    {
     data[cnt] = ele;
     cnt++;
    }

}
template <class T>
void SqList<T>::deleteArr(int pos)
{
    if(isEmpty())
        cout<<"顺序表为空"<<endl;
    if(pos<1||pos>cnt)
        cout<<"输入无效"<<endl;
    else
    {
        for(int i=pos;i<cnt;i++)
        {
            data[i-1] = data[i];
        }
        cnt--;
    }
}
template <class T>
T SqList<T>::getArr(int pos)
{
    if(pos<1 || pos>cnt)
    {
        cout<<"位置无效"<<endl;
        return -1;
    }

    else
    {
        return data[pos-1];  //逻辑位置和ele下标相互转化
    }
}
template <class T>
void SqList<T>:: insertEle(int pos,T ele)
{
    if(isEmpty())
        cout<<"顺序表为空"<<endl;
    if(pos<1||pos>cnt)
        cout<<"输入无效"<<endl;
    else
    {
        for(int i =cnt;i>=pos; i--)
        {
            data[i] = data[i-1];
        }
        data[pos-1] = ele;
        cnt++;
    }
}
int main()
{
    int a[10];
    for(int i=0;i<10;i++)
        a[i]=rand()%100+1;
    SqList<int> arr(a,10);
    arr.showArr();
    arr.appendArr(9);
    arr.appendArr(39);
    arr.showArr();
    arr.deleteArr(12);
    arr.deleteArr(1);
    arr.showArr();
    cout<<arr.getArr(8)<<endl;
    arr.insertEle(10,0);
    arr.insertEle(11,20);
    arr.showArr();
    return 0;
}


















逐夸父
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构线性表--顺序表
11-17
使用软件为dev c++，使用c语言，用计算机类书籍《数据结构》中介绍的线性表中的顺序存储结构，建立了一个学生年龄表，可以实现基本的 插入 查找 删除 遍历，各个功能函数写有注释，方便阅读。
数据结构与算法基础篇1-线性表-顺序表的基本操作C++
2301_76210003的博客
04-23 483
线性表的顺序存储结构是指用一组地址连续的存储单元依次存储线性表的数据元素，使得线性表中在逻辑结构上相邻的数据元素存储在连续的物理单元中，即线性表中元素的逻辑次序与存储器中的物理次序一一对应，采用顺序存储结构的线性表通常简称为顺序表。本篇，我们介绍线性表的顺序存储结构 - 顺序表的一些基本操作的实现与其效果 展示！
【数据结构C++】线性表/顺序表-实战：通信录
最新发布
JingYan_Chan的博客
03-13 634
这篇blog面向刚入门学习数据结构的小伙伴们，参考第二章的函数模板可以实现这个通信录的项目。按照下面步骤，不需任何修改就可以顺利编译。
数据结构 c++ 顺序表/线性表的基本操作
z_zssss的博客
09-17 820
数据结构 c++ 线性表/数据表的基本结构的实现 初始化操作、删除操作，插入操作，存取元素、合并两个有序顺序表、求顺序表长、释放顺序表
数据结构-线性表（顺序表）（c++版）
理科男同学
09-02 265
目录 1，顺序表的基本概念及特点： 1.1静态存储： 1.2动态存储表示 2，顺序表的基本操作（动态） 3，顺序表的应用演示： 3.1 集合的并运算，合并集合LA与LB，结果存于LA中，重复元素只留一个。 3.2 求顺序表LA与LB中公共的元素，结果存于LA中 1，顺序表的基本概念及特点： 1，把线性表中元素按照其逻辑顺序依次存储在一块连续的存储空间中，就得到了顺序表，它是用一维...
数据结构线性表的基本操作c++
qq_72712912的博客
06-15 177
线性表基本操作，包括顺序表基本操作，链表基本操作。
顺序表（算法与数据结构）
qq_48757526的博客
05-11 512
1.顺序表 顺序表的特点是逻辑连序，物理连序 即开辟一块连续的内存空间，相当于数组arr 在定义的时候，定义一个length记录下标 所以在尾插和尾删的时候，下标就是length，可以直接进行插入和删除（时间复杂度O（1）） 但是 但是 但是 在其他位置插入和删除的时候，需要挪动数据（时间复杂度O（n）） 在查找的时候时间复杂度也是O（n）因为需要将顺序表遍历到需要查找的位置 2.链表 特点：逻辑连续，物理不一定连续 2.1单链表 ...
[数据结构](线性表之顺序表)
qq_54883034的博客
08-05 372
文章目录1.什么是线性表？2.什么是顺序表？增删查改 1.什么是线性表？ 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串等 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2.什么是顺序表？ 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改
数据结构 -- 顺序表、图的遍历
weixin_57472404的博客
12-07 929
数据结构
数据结构：c/c++顺序表的基本操作
03-14
数据结构：（C/C++版）顺序表的创建，初始化与，输入，输出，插入，删除，排序，顺序插入等基础操作
头歌C++数据结构与算法 - 线性表
03-04
头歌C++数据结构与算法 - 线性表
（源代码）C++实现严蔚敏数据结构所有算法（一）线性表-顺序表 (VS2013)
03-13
（源代码）C++实现严蔚敏数据结构所有算法（一）线性表-顺序表 (VS2013)
数据结构与算法c++实现 删除顺序表中大于x的元素
06-04
数据结构与算法c++实现 删除顺序表中大于x的元素 可直接运行 适合初学数据结构与算法大二学生
算法之顺序表
JIAWEA的博客
11-08 386
顺序表 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关系。 这样的一组序列元素的组织形式，我们可以将其抽象为...
线性表-顺序表遍历
lujiangui的专栏
09-22 543
public class App { public static void main( String[] args ){ SequenceList<String> list = new SequenceList<>(10); list.insert("aaa"); list.insert("bbb"); list.insert("ccc"); list.insert("ddd"); .
顺序表详解——遍历、增添、查找、删除、修改、清除
C、Java知识分享
08-10 2251
Java数据结构顺序表的功能及实现
顺序表的建立及遍历（C语言）
热门推荐
l870358133的博客
09-28 2万+
读入n值及n个整数，建立顺序表并遍历输出。 输入格式: 读入n及n个整数 输出格式: 输出n个整数，以空格分隔（最后一个数的后面没有空格）。 输入样例: 在这里给出一组输入。例如： 4 -3 10 20 78 输出样例: 在这里给出相应的输出。例如： -3 10 20 78 #include<stdio.h> #include<stdlib.h&g...
顺序表数组的遍历
Cowcqw的博客
02-10 1734
一：最大最小值问题a&gt;在一个数据集合中（a[10]），没有重复值，有正有负。求正数中的次大次小；求负数中的次大次小int max1，max2，fmax1，fmax2,i; max1=max2=fmax1=max2=0; for(i=0;i&lt;10;i++){ if(a[i]&gt;0){ if(a[i]&gt;max1){ max2=max1; max...
2.数据结构与算法——顺序表
weixin_57696317的博客
02-09 549
线性表的顺序存储结构
顺序表的算法实现c++
09-17
顺序表是一种线性表的存储结构，它使用一段连续的存储空间来存储数据，并利用元素在物理地址上的相邻关系来表示元素间的逻辑关系。下面是顺序表的算法实现C语言示例： ```c #include<stdio.h> #include<stdlib.h> #define MaxSize 100 // 顺序表的最大容量 typedef struct { int data[MaxSize]; // 存储元素的数组 int length; // 顺序表当前长度 } SeqList; // 初始化顺序表 void InitSeqList(SeqList *L) { L->length = 0; } // 插入元素 void Insert(SeqList *L, int pos, int elem) { if(L->length == MaxSize) { printf("顺序表已满，无法插入元素\n"); return; } if(pos < 1 || pos > L->length + 1) { printf("插入位置不合法\n"); return; } for(int i = L->length; i >= pos; i--) { L->data[i] = L->data[i-1]; // 后移元素 } L->data[pos-1] = elem; L->length++; } // 删除元素 void Delete(SeqList *L, int pos) { if(L->length == 0) { printf("顺序表为空，无法删除元素\n"); return; } if(pos < 1 || pos > L->length) { printf("删除位置不合法\n"); return; } for(int i = pos; i < L->length; i++) { L->data[i-1] = L->data[i]; // 前移元素 } L->length--; } // 查找元素 int Find(SeqList L, int elem) { for(int i = 0; i < L.length; i++) { if(L.data[i] == elem) { return i+1; // 返回元素位置 } } return -1; // 若查找失败，则返回-1 } // 输出顺序表 void PrintSeqList(SeqList L) { for(int i = 0; i < L.length; i++) { printf("%d ", L.data[i]); } printf("\n"); } int main() { SeqList L; InitSeqList(&L); // 插入元素 Insert(&L, 1, 10); Insert(&L, 2, 20); Insert(&L, 3, 30); // 输出顺序表 PrintSeqList(L); // 删除元素 Delete(&L, 2); // 输出顺序表 PrintSeqList(L); // 查找元素 int pos = Find(L, 30); if(pos == -1) { printf("未找到该元素\n"); } else { printf("元素30的位置为：%d\n", pos); } return 0; } ``` 以上是用C语言实现顺序表的算法。其中包括了初始化顺序表、插入元素、删除元素、查找元素和输出顺序表的操作。示例中演示了初始化顺序表后，插入了三个元素，并分别输出了顺序表的内容。之后删除了位置为2的元素，并再次输出顺序表的内容。最后查找了元素30的位置，若查找成功则输出该元素的位置，若查找失败则输出未找到该元素。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值