数据结构-线性表顺序存储(c++)

数据结构-线性表顺序存储(c++) 2018-09-06

List.h  //头文件

 1 #define OK 1
 2 #define ERRO0R 0
 3 #define TRUE 1
 4 #define FALSE 0
 5 #define MAXSIZE 20  //存储空间初始分配量
 6
 7 typedef int Status;  //Status 函数结果状态码
 8 typedef int ElemType;  //ElemType 据具体情况而定
 9
10 class SqList
11 {
12 public:
13     SqList();  //构造函数
14     ~SqList();  //析构函数
15     ElemType m_data[MAXSIZE];  //线性表数据
16     int m_nLength;  //线性表长度
17     Status Visit(ElemType c);  //输出c
18     Status InitList();  //初始化线性表长度
19     Status ListEmpty();  //判断线性表是否为空
20     Status ClearList();  //设置线性表长度为0
21     int ListLength();  //线性表长度
22     Status GetElem(int i,ElemType *e);  //取i位子元素到e
23     int LocateElem(ElemType e);  //元素e的位子
24     Status ListInsert(int i,ElemType e);  //在i处插入e
25     Status ListDelete(int i,ElemType *e);  //删除i处元素,元素赋值到e
26     Status ListTraverse();  //遍历输出链表
27     void UnionL(SqList Lb);  //链表并集
28 }

List.h  //源文件

  1 #include <iostream>
  2 #include "List.h"
  3
  4 using namespace std;
  5 SqList::SqList()
  6 {
  7     m_nLength=0;
  8 }
  9
 10 SqList::~SqList()
 11 {
 12
 13 }
 14
 15 Status SqList::Visit(ElemType c)
 16 {
 17     cout<<c<<endl;
 18     return OK;
 19 }
 20
 21 Status SqList::InitList()
 22 {
 23     m_nLength=0;
 24     return OK;
 25 }
 26
 27 Status SqList::ListEmpty()
 28 {
 29     if(m_nLength==0)
 30         return TRUE;
 31     else
 32         return FALSE;
 33 }
 34
 35 Status SqList::ClearList()
 36 {
 37     m_nLength=0;
 38     return OK;
 39 }
 40
 41 Status SqList::ListLength()
 42 {
 43     return m_nLength;
 44 }
 45
 46 Status SqList::GetElem(int i,ElemType *e)
 47 {
 48     if(m_nLength==0||i<1||i>m_nLength)
 49         return FALSE;
 50     *e=m_data[i-1];
 51     return OK;
 52 }
 53
 54 Status SqList::LocateElem(ElemType e)
 55 {
 56     int i;
 57     if(m_nLength==0)
 58         return 0;
 59     for(i=0;i<m_nLength;i++)
 60     {
 61         if(m_data[i]==e)
 62             break;
 63     }
 64     if(i>=m_nLength)
 65         return 0;
 66     return i+1;
 67 }
 68
 69 Status SqList::ListInsert(int i,ElemType e)
 70 {
 71     int k;
 72     if(m_nLength==MAXSIZE)
 73         return FALSE;
 74     if(i<1||i>m_nLength+1)
 75         return FALSE;
 76     if(i<=m_nLength)
 77     {
 78         for(k=m_nLength-1;k>=i-1;k--)
 79             m_data[k+1]=m_data[k];
 80     }
 81     m_data[i-1]=e;
 82     m_nLength++;
 83     return OK;
 84 }
 85
 86 Status SqList::ListDelete(int i,ElemType *e)
 87 {
 88     int k;
 89     if(m_nLength==0)
 90         return FALSE;
 91     if(i<1||i>m_nLength)
 92         return FALSE;
 93     *e=m_data[i-1];
 94     if(i<m_nLength)
 95     {
 96         for(k=i;i<m_nLength;k++)
 97             m_data[k-1]=m_data[k];
 98     }
 99     m_nLength--;
100     return OK;
101 }
102
103 Status SqList::ListTraverse()
104 {
105     int i;
106     for(i=0;i<m_nLength;i++)
107         Visit(m_data[i]);
108     cout<<"\n"<<endl;
109     return OK;
110 }
111
112 void SqList::UnionL(SqList Lb)
113 {
114     int La_len,Lb_len,i;
115     ElemType e;
116     La_len=ListLength();
117     Lb_len=Lb.ListLength();
118     for(i=1;i<=Lb_len;i++)
119     {
120         Lb.GetElem(i,&e);
121         if(!LocateElem(e))
122             ListInsert(++La_len,e);
123     }
124 }

实例:

 1 #include "List.h"
 2 #include <iostream>
 3
 4 using namespace std;
 5
 6 void main()
 7 {
 8     SqList L;
 9     ElemType e;
10     Status i;
11     int j,k;
12     i=L.InitList();
13     cout<<"初始化L后:L.length="<<L.m_nLength<<endl;
14     for(j=1;j<5;j++)
15         i=L.ListInsert(1,j);
16     cout<<"在L的表头依次插入 1-5后:L.m_data="<<endl;
17     L.ListTraverse();
18     cout<<L.m_nLength<<endl;
19     i=L.ListEmpty();
20     cout<<"L是否空 i="<<i<<"(1:是 0:否)"<<endl;
21     i=L.ClearList();
22     cout<<"清空L后L.m_length="<<L.m_nLength<<endl;
23     L.ListEmpty();
24     for(j=1;j<=5;j++)
25         i=L.ListInsert(j,j);
26     cout<<"在L的表尾依次插入 1-10后:L.m_data="<<endl;
27     L.ListTraverse();
28     L.GetElem(5,&e);
29     SqList Lb;
30     for(j=0;j<10;j++)
31         i=Lb.ListInsert(1,j);
32     cout<<"在L的表头依次插入 1-15后:L.m_data="<<endl;
33     Lb.ListTraverse();
34     L.UnionL(Lb);
35     L.ListTraverse();
36     system("pause");
37 }

原文地址:https://www.cnblogs.com/XZDSF/p/9600031.html

时间: 2024-08-14 02:55:14

数据结构-线性表顺序存储(c++)的相关文章

数据结构——线性表顺序存储结构

 关于线性表 线性表是零个或者多个数据元素的集合.它主要有以下三个特征: 1:线性表的数据元素之间是有顺序的. 2:线性表中数据元素个数是有限的. 3:线性表中数据元素数据类型是相同的. 关于线性表的操作,主要有 创建线性表.销毁线性表.清空线性表.将元素插入线性表.将元素从线性表中删除.获取线性表中某个位置的元素.获取线性表的长度. 线性表主要有两种存储结构: 1:线性表的顺序存储结构,c语言中的数组及采用这种方式. 2:线性表的链式存储结构. 关于顺序存储结构 定义: 是指用一段地址连续的内

数据结构 - 线性表顺序存储结构

线性表 线性表是一种典型的线性结构.其基本特点是线性表中的数据元素是有序且是有限的.在这种结构中: ① 存在一个唯一的被称为"第一个"的数据元素: ② 存在一个唯一的被称为"最后一个"的数据元素: ③ 除第一个元素外,每个元素均有唯一一个直接前驱: ④ 除最后一个元素外,每个元素均有唯一一个直接后继. 线性表(Linear List) :是由n(n≧0)个数据元素(结点)a1,a2, -an组成的有限序列.该序列中的所有结点具有相同的数据类型. 线性表中的数据元素

数据结构---线性表---顺序存储结构

头文件 header.h #ifndef _LIST_H #define _LIST_H #include <stdio.h> #include <stdlib.h> #include <memory.h> #define MY_TYPE int /*0:int 1:double 2:float 3:char*/ #define _MY_TYPE_ 0 #define LIST_INIT_SIZE 3 /*单位:MY_TYPE*/ #define LIST_INCRE_

线性表顺序存储结构的c语言实现

线性表顺序存储结构用C实现的操作 <1>声明一个线性表的顺序存储结构 <2> 初始化顺序线性表 <3>判断是否为空 <4>清空列表 <5>返回当前长度(线性表内元素个数) <6>返回L中第i个数据元素的值,注意i是指位置,第1个位置的数组是从0开始 <7>返回L中第1个与e满足关系的数据元素的位序.若这样的数据元素不存在,则返回值为0 <8>在L中第i个位置之前插入新的数据元素e,L的长度加1 <9>

数据结构例程——线性表顺序存储的应用

本文是数据结构基础系列网络课程(2):线性表中第6课时线性表顺序存储的应用中所讲的例程. 例:删除元素 问题:已知长度为n的线性表A采用顺序存储结构,设计算法,删除线性表中所有值为x的数据元素. 要求:时间复杂度为O(n).空间复杂度为O(1)的算法 解法0:用基本运算实现,不满足复杂度要求 (注:本文中所需要的list.h和list.cpp见点击参照-) #include "list.h" #include <stdio.h> void delnode1(SqList *

数据结构之线性表-顺序存储

本人文笔较差,语文从来不及格,基础不好,写此类文章仅供自己学习,理解队列及其他知识,高手大神请略过.参考书籍 <数据结构与算法分析-Java语言描述> 1.1 线性表简介 线性表是0个或多个元素的有限序列.即元素之间有顺序且有限.假设表中有元素A1,A2,A3,....,AN,若存在1<i<N,则 Ai 是 Ai-1的直接后继,Ai-1 是Ai的直接前驱.作为线性表,必须满足A1没有前驱,AN没有后继(有限性).N是线性表的长度.当N=0时,即表中没有任何元素也即空表. 1.2 线

数据结构与算法-线性表顺序存储结构删除操作的实现

这一章节我们来看一下线性表顺序存储结构删除操作的简单实现 package com.ray.testobject; public class Test { private Object[] list; public Object[] getList() { return list; } /** * 初始化list * * @param num * 元素个数 */ private void iniList(int num) { list = new Object[num]; for (int i =

数据结构与算法-总结线性表顺序存储结构的优缺点

这一章节主要总结线性表顺序存储结构的优缺点. 在总结之前,我们来讨论一下线性表顺序存储结构的执行方法的时间复杂度: 存储.读取:O(1) 插入.删除:O(n) 优点: 1.无需为表中的逻辑关系增加额外的存储空间 2.可以快速存取表中对象 缺点: 1.插入和删除需要移动大量的对象 2.存储设备的碎片化 3.当线性表过大的时候,很难确定长度 版权声明:本文为博主原创文章,未经博主允许不得转载.

数据结构——线性表之顺序存储结构

概念: 线性表顺序存储结构中的元素拥有一个直接前驱元素,和一个直接后继元素:线性表的第一个元素只有直接后继元素,最后一个元素只有直接前驱元素 线性表一旦创建,长度一般都是固定的,这是它的最大容量 线性表中元素个数只能小于等于线性表长度 线性表的基本操作: 1 public class SeqList { 2 3 final int defaultSize=10; 4 int maxSize;// 顺序表的最大长度 5 int size;// 线性表的当前长度 6 static Object[]