线性表之顺序表

最新推荐文章于 2024-04-24 21:01:22 发布

yuebaii

最新推荐文章于 2024-04-24 21:01:22 发布

阅读量171

点赞数 1

本文链接：https://blog.csdn.net/qq_19525389/article/details/79378775

版权

我学习数据结构的第一天，从顺序表开始。
线性表是最基本、最简单、也是最常用的一种数据结构，一个线性表是n个具有相同特性的数据元素的有限序列。主要由顺序表示或链式表示。在实际应用中，常以栈、队列、字符串等特殊形式使用。
顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素，称为线性表的顺序存储结构或顺序映像。并且顺序表由数组是否动态分配又分为定长顺序表和不定长顺序表。
顺序表的基本操作实现的代码如下：

      
   C++ Code Seqlist.h 
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#pragma once // 预防头文件重复引用
//定长顺序表
#define SIZE 10

typedef struct SeqList
{
int elem[SIZE]; //存放数据
int length; //有效数字个数
} SeqList, *PSeqList;

void InitSeqList(PSeqList ps);//初始化顺序表

bool Insert(PSeqList ps, int pos, int val); //在某位置插入一个数据元素

bool DeletePos(PSeqList ps, int pos); //删除某位置的数据

int Search(PSeqList ps, int key);//搜索某数据

bool Deleteval_r(PSeqList ps, int key);//删除某数据

void Clear(PSeqList ps); //清除顺序表数据

bool IsEmpty(PSeqList ps); //判断是否为空表

int GetLength(PSeqList ps);//得到顺序表长度

void Destroy(PSeqList ps); //摧毁数据表

void Show(PSeqList ps);//显示数据

      
   C++ Code Seqlist.cpp 
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#include "seqlist.h"
#include
#include

void InitSeqList(PSeqList ps)
{
    assert(ps != NULL ); //只在Debug有效
     if (ps == NULL ) // Debug、Realse均有效
    {
         return ;
    }
    ps->length = 0 ;
}

static bool IsFull(PSeqList ps)
{
     return ps->length == SIZE;
}

//插入数据必须连续
bool Insert(PSeqList ps, int pos, int val)
{
    assert(ps != NULL );

     if (pos < 0 || pos > ps->length || IsFull(ps))
    {
         return false ;
    }

     for ( int i = ps->length - 1 ; i >= pos; i--) //移动原有的数据
    {
        ps->elem[i + 1 ] = ps->elem[i];
    }

    ps->elem[pos]  = val; //插入新数据

    ps->length++; //有效个数增加

     return true ;
}

bool DeletePos(PSeqList ps, int pos) //todo
{
    assert(ps != NULL );

     if (pos < 0 || pos >= ps->length || IsEmpty(ps))
    {
        printf( "删除位置不正确或顺序表已满！\n" );
         return false ;

    }

     for ( int i = pos; i < ps->length - 1 ; i++)
    {
        ps->elem[i] = ps->elem[i + 1 ];
    }
    ps->length--;
     return true ;
}
int Search(PSeqList ps, int key)
{
     for ( int i = 0 ; i < ps->length; i++)
    {
         if (key == ps->elem[i])
        {
             return i;
        }
    }
     return - 1 ;
}

bool Deleteval_r(PSeqList ps, int key)
{
    assert(ps != NULL );
     if (IsEmpty(ps))
    {
        printf( "顺序表为空，不能删除！\n" );
         return false ;
    }

     int i = Search(ps, key);
     if (i == - 1 )
    {
        printf( "删除元素不存在，请重新操作！\n" );
    }
     else
    {
        DeletePos(ps, i);
    }
}

void Clear(PSeqList ps)
{
    ps->length = 0 ;
}

bool IsEmpty(PSeqList ps)
{
     return ps->length == 0 ;
}

int GetLength(PSeqList ps) //todo
{
     return ps->length;
}

void Destroy(PSeqList ps)
{
    Clear(ps);
}

void Show(PSeqList ps)
{
     for ( int i = 0 ; i < ps->length; i++)
    {
        printf( "%d " , ps->elem[i]);
    }
    printf( "\n" );
}

      
   C++ Code Dseqlist.h 
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#pragma once
//不定长顺序表
#define INITSIZE 10

typedef struct DSeqList
{
     int *elem; //指向保存数据数组的地址
     int length; //有效数据个数
     int listsize; //总格子数
} DSeqList, *PDSeqList;

void InitSeqList(PDSeqList ps);

bool Insert(PDSeqList ps, int pos, int val);

bool DeletePos(PDSeqList ps, int pos);

int Search(PDSeqList ps, int key);

bool Deleteval_r(PDSeqList ps, int key);

void Clear(PDSeqList ps);

bool IsEmpty(PDSeqList ps);

int GetLength(PDSeqList ps);

void Destroy(PDSeqList ps);

void Show(PDSeqList ps);

      
   C++ Code Dseqlist.h 
  

#include
#include
#include
#include "dseqlist.h"

void InitSeqList(PDSeqList ps)
{
    assert(ps != NULL );
     if (ps == NULL )
    {
         return ;
    }

    ps->elem = ( int *)malloc(INITSIZE * sizeof ( int ));
    ps->length = 0 ;
    ps->listsize = INITSIZE;
}

static bool IsFull(PDSeqList ps)
{
     return ps->length == ps->listsize; //和定长有区别
}

static void Inc(PDSeqList ps) //将总格子数扩到到原来的2倍
{
    ps->elem = ( int *)realloc(ps->elem, ps->listsize * 2 * sizeof ( int ));
    ps->listsize *= 2 ;
}
//插入数据必须连续
bool Insert(PDSeqList ps, int pos, int val)
{
     if (pos < 0 || pos > ps->length)
    {
         return false ;
    }
     if (IsFull(ps))
    {
         //扩容
        Inc(ps);
    }

     for ( int i = ps->length - 1 ; i >= pos; i--)
    {
        ps->elem[i + 1 ] = ps->elem[i];
    }

    ps->elem[pos] = val;

    ps->length++;

     return true ;
}

bool DeletePos(PDSeqList ps, int pos)
{
     if (pos < 0 || pos >= ps->length)
    {
        printf( "删除位置不正确！\n" );
         return false ;
    }
     for ( int i = pos; i < ps->length - 1 ; i++)
    {
        ps->elem[i] = ps->elem[i + 1 ];
    }
    ps->length--;
     return true ;
}

int Search(PDSeqList ps, int key)
{
     for ( int i = 0 ; i < ps->length; i++)
    {
         if (key == ps->elem[i])
        {
             return i;
        }
    }
     return - 1 ;
}

bool Deleteval_r(PDSeqList ps, int key)
{
     if (IsEmpty(ps))
    {
        printf( "顺序表为空，不能删除！\n" );
         return false ;
    }

     int pos = Search(ps, key);
     if (pos == - 1 )
    {
        printf( "删除元素不存在，请重新操作！\n" );
         return false ;
    }
     else
    {
         for ( int i = pos; i < ps->length - 1 ; i++)
        {
            ps->elem[i] = ps->elem[i + 1 ];
        }
    }
    ps->length--;
     return true ;
}

void Clear(PDSeqList ps)
{
    ps->length = 0 ;

ps->listsize = 0;
}

bool IsEmpty(PDSeqList ps)
{
     return ps->length == 0 ;
}

int GetLength(PDSeqList ps)
{
     return ps->length;
}

void Destroy(PDSeqList ps)
{
    free(ps->elem);

ps->length = 0;

ps->listsize = 0;
}

void Show(PDSeqList ps)
{
     for ( int i = 0 ; i < ps->length; i++)
    {
        printf( "%d " , ps->elem[i]);
    }
    printf( "\n" );
}

      
   C++ Code test.cpp 
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include
#include
//#include "seqlist.h"
#include "dseqlist.h"
using namespace std;

int main()
{
    DSeqList seq;
    InitSeqList(&seq);
     for ( int i = 0 ; i < 15 ; i++)
    {
        Insert(&seq, i, i);
    }

     //Deleteval_r(&seq,3);
     //Deleteval_r(&seq,-1);
     //Deleteval_r(&seq,15);

     //DeletePos(&seq,5);
     //DeletePos(&seq,-1);
    DeletePos(&seq, 10 );
    Show(&seq);

     //SeqList seq;
     //InitSeqList(&seq);
     //for(int i=0;i<15;i++)
     //{
     //  Insert(&seq,i,i);
     //}

     DeletePos(&seq,5);
     DeletePos(&seq,-1);
     //DeletePos(&seq,10);

     Deleteval_r(&seq,3);
     Deleteval_r(&seq,-1);
     Deleteval_r(&seq,10);
     //Show(&seq);
     return 0 ;
}

从以上对于顺序表的操作来看，可知定长与不定长的实现代码基本相同，主要区别在于定长顺序表长度不可改变，而不定长表动态申请内存，在当顺序表满的情况下可动态进行扩容，使得表内存成倍增加，从而进行各种操作，优于定长顺序表。
第一次写博客，内容和形式比较浅显粗俗，还希望大家多多包涵！来日方长，Come on,boy!