线性表之顺序表的实现

最新推荐文章于 2022-09-20 10:15:23 发布
最新推荐文章于 2022-09-20 10:15:23 发布
阅读量464 收藏
点赞数
分类专栏： 数据结构实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kang_TJU/article/details/52841365
版权

本文针对顺序表，总结其相应的常用操作。主要是给出代码实现。

结构、常量声明

common.h

#ifndef common_H
#define common_H

/* 函数结果状态码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
//#define OVERFLOW -2

/* 类型定义 */
typedef int Status;     // Status是函数的类型，其值是函数结果状态码
typedef int ElemType;   // ElemType是数据类型

#endif

顺序表常用操作接口声明

SeqList.h

#ifndef SeqList_H
#define SeqList_H
#include "common.h"

Status print( const ElemType* arr, int n );             // 顺序表打印
Status find_x( const ElemType* arr, int n, ElemType x );// 顺序表查找
Status insert_x( ElemType* arr, int& n, ElemType x );   // 有序顺序表插入
Status delete_x( ElemType* arr, int& n, ElemType x );   // 顺序表删除
Status delete_allx( ElemType* arr, int& n, ElemType x );// 删除顺序表所有x元素 
Status delete_allxy( ElemType* arr, int& n, ElemType x, ElemType y ); // // 删除顺序表所有位于x与y之间的元素 O(n)实现
Status delete_same( ElemType* arr, int& n );            // 删除顺序表中的重复元素

Status reverse( ElemType* arr, int n );             // 置逆
Status is_palindrome( const ElemType* arr, int n ); // 判断回文

Status move_left( ElemType* arr, int n, int k );    // 循环左移k位
Status move_left1( ElemType* arr, int n, int k );   // 循环左移k位

Status move_right( ElemType* arr, int n, int k );   // 循环右移k位
Status move_right1( ElemType* arr, int n, int k );  // 循环右移k位
Status move_right2( ElemType* arr, int n, int k );  // 循环右移k位

Status adjust( ElemType* arr, int n, Status (*compare)(ElemType) ); // 将满足compare()的元素调整到数组的前面，不满足的调整到数组的后面

ElemType* merge( ElemType* arr1, int n1, ElemType* arr2, int n2 );  // 归并两个有序表
ElemType* merge1( ElemType* arr1, int n1, ElemType* arr2, int n2 ); // 归并两个有序表，不含重复元素

#endif

顺序表常用操作实现（SeqList.cpp）

  • 打印
    思路：枚举
Status print( const ElemType* arr, int n )
{
    if( NULL == arr || n <= 0 )
    {
        std::cerr << "Invalid arguments !" << std::endl;
        return ERROR;
    }

    for( int i = 0; i < n; ++i )
    {
        std::cout << arr[i] << std::endl;
    }

    return OK;
}
  • 查找
    思路：枚举
int find( const ElemType* arr, int n, ElemType x )
{
    if( NULL == arr || n <= 0 )
    {   
        std::cerr << "Invalid arguments !" << std::endl;
        return ERROR;
    }

    for( int i = 0; i < n; ++i )
    {
        if( arr[i] == x )
            return i;
    }

    return OK;
}
  • 有序表插入
    思路：寻找插入位置，向后移动，插入元素值
Status insert_x( ElemType* arr, int& n, ElemType x )
{
    if( NULL == arr || n <= 0 )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return ERROR;
    }

    int loc = 0;
    while( loc<n && arr[loc] < x ) ++loc;

    if( loc < n )
    {
        for( int i = n-1; i >= loc; --i )
            arr[i+1] = arr[i];
        arr[loc] = x;
    }
    else
        arr[loc] = x;

    ++n;

    return OK;
}
  • 顺序表删除
    思路：查找删除元素，移动后面元素向前一个位置覆盖
Status delete_x( ElemType* arr, int& n, ElemType x )
{
    if( NULL == arr || n <= 0 )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return ERROR;
    }
    int loc = 0;
    while( loc < n && arr[loc] != x ) ++loc;

    if( loc < n )
    {
        for( int i = loc+1; i < n; ++i )
            arr[i-1] = arr[i];

        --n;
        return OK;
    }
    else
    {
        std::cerr << x << " not in the SeqList" << std::endl;
        return ERROR;
    }
}
  • 顺序表删除所有值为x的元素
    思路：枚举顺序表，cnt_x记录元素值为x的出现次数。对于不是x的元素，向前移动cnt_x的位置。O(n)复杂度。
Status delete_allx( ElemType* arr, int& n, ElemType x )
{
    if( NULL == arr || n <= 0 )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return ERROR;
    }
    int cnt_x = 0; // 元素值为x的数量
    for( int i = 0; i < n; ++i )
    {
        if( arr[i] == x )
        {   
            ++cnt_x;
            continue;
        }

        arr[i - cnt_x] = arr[i];
    }
    n -= cnt_x;

    return OK;
}
  • 删除顺序表所有位于x与y之间的元素
    思路：方法同上。cnt_xy记录值在x与y之间的元素个数，向前移动即可。
Status delete_allxy( ElemType* arr, int& n, ElemType x, ElemType y )
{
    if( NULL == arr || n <= 0 || x > y )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return ERROR;
    }

    int cnt_xy = 0;
    for( int i = 0; i < n; ++i )
    {
        if( x <= arr[i] && arr[i] <= y )
        {
            ++cnt_xy;
            continue;
        }

        arr[i - cnt_xy] = arr[i];
    }
    n -= cnt_xy;

    return OK;
}
  • 删除顺序表中重复元素
    思路：方法大致同上。需要O(N)的空间复杂度。用hash表做。设置cnt_same记录重复元素的格式。如果不是重复元素，向前移动cnt_same个位置。
Status delete_same( ElemType* arr, int& n )
{
    if( NULL == arr || n <= 0 )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return ERROR;
    }

    std::map< ElemType, bool > hash ;

    int cnt_same = 0;

    for( int i = 0; i < n; ++i )
    {
        if( hash.find( arr[i] ) == hash.end() )
        {
            hash[arr[i]] = true;
            arr[i - cnt_same] = arr[i];
        }
        else
        {
            ++cnt_same;
            continue;
        }
    }

    n -= cnt_same;


    return OK;
}
  • 置逆
    思路：枚举，中轴
Status reverse( ElemType* arr, int n )
{
    if( NULL == arr || n <= 0 )
    {   
        std::cerr << "Invalid arguments !" << std::endl;
        return ERROR;
    }

    int mid = n/2; // 中轴
    for( int i = 0; i < mid; ++i )
    {
        ElemType t = arr[i];
        arr[i] = arr[n - 1 - i];
        arr[n - 1 - i] = t;
    }

    return OK;
}
  • 判断回文
    思路：枚举，中轴
Status move_left( ElemType* arr, int n, int k )
{
    if( NULL == arr || n <= 0 || k < 0 || k >= n )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return ERROR;
    }

    ElemType* tmp = new ElemType[k];
    if( NULL == tmp )
    {
        std::cout << "Not enough space!" << std::endl;
        return ERROR;
    }

    for( int i = 0; i < k; ++i )
    {
        tmp[i] = arr[i];
    }
    for( int i = k; i < n; ++i ) 
    {
        arr[i-k] = arr[i];
    }
    for( int i = n - 1, j = k - 1; i >= n-k; --i, --j )
    {
        arr[i] = tmp[j];
    }

    delete tmp;
    return OK;
}
  • 循环左移k位
    思路：保留左侧k位，将右侧n-k位依次左移，然后将保留的左侧k位放置的右侧k位
Status move_left( ElemType* arr, int n, int k )
{
    if( NULL == arr || n <= 0 || k < 0 || k >= n )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return ERROR;
    }

    ElemType* tmp = new ElemType[k];
    if( NULL == tmp )
    {
        std::cerr << "Not enough space!" << std::endl;
        return ERROR;
    }

    for( int i = 0; i < k; ++i )
    {
        tmp[i] = arr[i];
    }
    for( int i = k; i < n; ++i ) 
    {
        arr[i-k] = arr[i];
    }
    for( int i = n - 1, j = k - 1; i >= n-k; --i, --j )
    {
        arr[i] = tmp[j];
    }

    delete tmp;
    return OK;
}

改进算法：
这个问题可以看做把数组ab转换为数组ba(a代表前k个元素，b代表后n-k个元素)
arr[k|n-k] 转化为 arr[ n-k|k ]
1.a置逆得到 a−1b
2.b置逆得到 a−1b−1
3.最后将整个数组置逆得到 ba
本质是公式： (a−1b−1)−1=ba 。一维数组置逆在前面已经实现。

Status move_left1( ElemType* arr, int n, int k )
{
    if( NULL == arr || n <= 0 || k < 0 || k >= n )
    {
        std::cout << "Invalid arguments!" << std::endl;
        return ERROR;
    }

    reverse( arr, k );
    reverse( arr + k, n-k );
    reverse( arr, n );

    return OK;
}
  • 循环右移k位（本质是循环左移n-k位）
    思路：同上面的第一种办法。先保留右侧k位，将左侧n-k位向右移动k位。最后将保留的k位顺序填充到左侧。
Status move_right( ElemType* arr, int n, int k )
{
    if( NULL == arr || n <= 0 || k >= n )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return -1;
    }

    ElemType* tmp = new ElemType[k];
    if( NULL == tmp )
    {
        std::cerr << "Not enough space!" << std::endl;
        return ERROR;
    }
    for( int i = n-k, j = 0; i < n; ++i, ++j )
    {
        tmp[j] = arr[i];
    }
    for( int i = n-k-1; i >= 0; --i )
    {
        arr[i+k] = arr[i];
    }
    for( int i = 0, j = 0; i < k; ++i, ++j )
    {
        arr[i] = tmp[j];
    }

    delete tmp;
    return OK;
}

思路：
右移k位本质是左移n-k位，方法和上面第二种一样。不做过多说明。

Status move_right1( ElemType* arr, int n, int k )
{
    if( NULL == arr || n <= 0 || k >= n )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return -1;
    }

    reverse( arr, n-k );
    reverse( arr + n-k, k );
    reverse( arr, n );

    return OK;
}

思路：直接调用左移算法

Status move_right2( ElemType* arr, int n, int k )
{
    if( NULL == arr || n <= 0 || k >= n )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return ERROR;
    }

    Status ret = move_right( arr, n, n-k );

    return ret;
}
  • 将满足compare()的元素调整到数组的前面，不满足的调整到数组的后面
    思路：类似partition算法，分别从前，后寻找mismatch，找到一个发生交换即可。
Status adjust( ElemType* arr, int n, Status (*compare)(ElemType) )
{
    if( NULL == arr || n <=0 || NULL == compare )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return ERROR;
    }

    int i = 0;
    int j = n - 1;
    while( i < j ) // 调整没有结束
    {
        while( i < j && compare(arr[i]) ) ++i;
        while( i < j && !compare(arr[j]) ) --j;
        if( i < j )
        {
            ElemType t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;

            ++i; --j;
        }
    }

    return OK;
}
  • 归并操作
    思路：每次取较小结果存入归并结果。
ElemType* merge( ElemType* arr1, int n1, ElemType* arr2, int n2 )
{
    if( NULL == arr1 || n1 <= 0 || NULL == arr2 || n2 <= 0 )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return NULL;
    }

    ElemType* arr3 = new ElemType[ n1 + n2 ];
    if( NULL == arr3 )
    {
        std::cerr << "Not enough space!" << std::endl;
        return NULL;
    }

    int i = 0;
    int j = 0;
    int k = 0;
    while( i < n1 && j < n2 )
    {
        if( arr1[i] < arr2[j] )
        {
            arr3[k++] = arr1[i++];
        }
        else
        {
            arr3[k++] = arr2[j++];
        }
    }
    while( i < n1 ) 
        arr3[k++] = arr1[i++];
    while( j < n2 )
        arr3[k++] = arr2[j++];

    return arr3;
}
  • 归并操作，不含重复元素
ElemType* merge1( ElemType* arr1, int n1, ElemType* arr2, int n2 )
{

    if( NULL == arr1 || n1 <= 0 || NULL == arr2 || n2 <= 0 )
    {
        std::cerr << "Invalid arguments!" << std::endl;
        return NULL;
    }

    ElemType* arr3 = new ElemType[ n1 + n2 ];
    if( NULL == arr3 )
    {
        std::cerr << "Not enough space!" << std::endl;
        return NULL;
    }

    int i = 0;
    int j = 0;
    int k = 0;
    while( i < n1 && j < n2 )
    {
        if( arr1[i] < arr2[j] )
        {
            arr3[k++] = arr1[i++];
        }
        else if( arr1[i] > arr2[j] )
        {
            arr3[k++] = arr2[j++];
        }
        else
        {
            arr3[k++] = arr1[i++];
            j++;
        }
    }
    while( i < n1 ) 
        arr3[k++] = arr1[i++];
    while( j < n2 )
        arr3[k++] = arr2[j++];

    return arr3;
}
Kang_TJU
关注
专栏目录
线性表和顺序表
Ll_R_lL的博客
04-25 2516
1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构 常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。 但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2.顺序表 2.1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。（要求：数据必须从第一个位置开始，
顺序表逆置
10-04
这个可以应用于顺序表逆置，查找，或者删除，顺序表作为存储结构，实现将线性表(a0,a1,a2,…an-1)就地逆置的操作，所谓“就地”，是指辅助空间应为O(1)。
顺序表的编程题及完整代码（顺序表逆置、删除、合并、查找等）
薛定谔的猫的博客
04-16 4410
文章目录顺序表逆置将循序表L中的所有元素逆置将两个顺序表的位置互换删除操作删除顺序表L中所有值为x的数据元素删除有序顺序表L中所有值重复的元素合并操作将两个有序顺序表合并成一个新的有序顺序表查找操作找两个等长升序序列的中位数说明 顺序表逆置 将循序表L中的所有元素逆置 问题描述： 将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)。 算法思想： 扫描顺序表L的前半部分元素，对于元素L.data[i]（0<=i<L.length/2），将其与后半部分对应元素L.data[L.length-1
【数据结构|线性表】顺序表的查找以及顺序表反转操作实现
爱喝冰红茶的方舟的博客
09-20 653
本题包括基础线性表的实现
2021-10-25 数据结构顺序表算法题（逆置、查找值、负值在正值前、循环移动）
m0_52461904的博客
10-25 1721
先声明：本人是个初学者，本博客全为我自己写的，只是作为个人学习记录使用，很有可能不够规范或漏洞百出，请多包涵。 ps：有个小目标，大概就是之后输入数据能通过产生随机数实现，到时候再钻研，本博客还是手动输入的简单样例数据。 首先先简单定义一个用动态存储分配的顺序表以及初始化以及根据长度打印表的函数： #include<stdio.h> #include<malloc.h> #define initSize 100 typedef int ElemType; typedef s
顺序表就地逆置
03-26
数据结构中的顺序表就地逆置源代码，亲测可用。
C语言_线性表之顺序表
01-16
线性表是最基础的数据结构之一，顺序表则是线性表的一种常见实现。本文将深入探讨C语言实现顺序表的相关知识点，包括其定义、操作以及具体实现。 顺序表是一种特殊的线性表，它的所有元素在内存中是连续存放的，...
线性表之顺序表
03-28
在数据结构的领域里，线性表有多种实现方式，其中顺序表是最简单也是最直观的一种。顺序表是指表中的元素在内存中是连续存放的，就像数组一样，可以通过下标直接访问任意位置的元素。 顺序表的优点在于其访问速度快...
线性表之顺序表合并.cpp
03-30
两个不同长度的线性表的合并，在合并过程中，两个线性表中共有的元素会自动删掉，合并后的线性表没有排序，如需排序，请看我之前发的线性表之顺序表实验
线性表之顺序表实验.cpp
03-30
数据结构中的线性表实验之顺序表
顺序表的插入删除已近逆序跟找元素位置
04-19
刚学了，自己瞎写的，希望多多指教。。。。。。。。
顺序表的应用——逆置问题
CairBin的博客
09-25 356
顺序表应用——逆置问题 问题描述 给定一个顺序表，将其中的元素逆置 例子 给定一个顺序表，其中有0至10共11个元素从小至大排列，请将这11个元素逆置使其从大到小排列 以下是解题代码 代码 #include <iostream> #define MAXSIZE 100 typedef struct{ int data[MAXSIZE]; int length; }Sqlist; //输出元素 void printList(Sqlist L) { for(int n = 0;
顺序表中的逆置操作
xiagao000的博客
12-08 1万+
顺序表逆置方法：可以先建立一个新的顺序表b，把顺序表a中的元素逆序输出，但是这种空间复杂度为O（n）,浪费空间资源，所以我们从两头分别交换元素，即下标i=0,j=length-1相互交换，然后i++,j--，这样空间的复杂度为O（1）。 这里我采用了两个例子，第一个是经典顺序表逆置算法，讲解比较详细，第二种是进行三次逆置，举一反三，也容易理解。 例1：设计一个高效的算法，将顺序表L中所有元素逆置，空间复杂度为O（1）。 思想：因为要求空间的复杂度为1，所以扫描顺序表的前半部分元素，将其与后半部分元素对
数据结构算法之---顺序表逆置
知识在于理解,运用在于总结,高阶在于巩固!
09-29 4084
思路： 此种算法较为经典，可扫描该线性表的前半部分，然后把前半部分的每一个元素和后半部分进行交换。具体算法如下： void reverse(sqList s,int length)//传入一个线性表，length该表的长度 { int temp; for(int i=0;i<length/2;i++)//只扫描表的前半部分 { temp=s[i]; int s[i]=s[length-1-i]; s[length-i-1]=s[i
线性表的顺序实现
Samuelho0303的博客
02-24 268
代码： #include <stdio.h> #include <malloc.h> #define MaxSize 50 typedef char ElemType; typedef struct { ElemType elem[MaxSize]; int length; } SqList;/*顺序表类型定义*/ ...
顺序表2：顺序表的逆置
qq_43591406的博客
12-03 8928
一、顺序表逆置基本逻辑和实现 1.顺序表逆置的逻辑 将顺序表丛中间一分为二。 如果这个顺序表元素个数为i； 让第一个元素和最后一个元素互换， 第二个和倒数第二个元素互换； … 第i/2个元素和第i/2+1个元素互换。 交换结束以后，这就是个逆序的表了。 2.代码实现 void Reverse(Sqlist &L) { int temp;//辅助变量 //这里L.Length/2会自动保留整数部分，所以，如果是奇数就没有任何影响了 for (i = 0; i < L.Length/2; i
顺序表的逆置
热门推荐
Wonz
08-31 2万+
暑假都快结束了，才想起来把数据结构的笔记补一下。 题目 编写程序实现对顺序表的逆置。 部分代码 void Inverse(SeqList *L, int mSize) { int i, temp; for (i = 0; i &lt; mSize / 2; i++) { temp = L-&gt;element[i]; L...
数据结构之线性表---顺序表的逆置
逆天的博客
08-02 2万+
问题：试写一算法，实现顺序表的就地逆置，即利用原表的存储空间将线性表(a1,a2,...,an)逆置为(an,an-1,...,a1) 算法思想：观察原表和新表顺序，逆置后的线性表是将原表相应位置的元素进行交换，即交换第一个和最后一个，第二个和倒数第二个，依此类推 源码
线性表（顺序表）的逆置（完整程序）
理工科的杜小甫的博客
06-22 1万+
#include<stdio.h> #include<stdlib.h>#define OK 1 #define ERROR -1 #define MAX_SIZE 100typedef int Status; typedef int ElemType;typedef struct sqlist { ElemType Elem_array[MAX_SIZE]; int length;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值