5、java实现方式：

5.1、顺序表的抽象结构

  1. package com.xgp.顺序表;
  3. public interface MyList<T> {
  4.     //1. initList(&L)：初始化表。构造一个空的线性表。放回值应该是一个线性表
  5.     MyList<T> initList();
  7.     //2. destroyList(&L)：销毁操作。销毁线性表，并释放线性表L所占的内存空间。放回值为void
  8.     boolean destroyList();
  10.     //3. locateElem(L,e)：按值查找操作。在表中L查找具有给定关键值的元素。放回一个int类型
  11.     int locateElem(T value);
  13.     //5. listInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定的元素e。
  14.     boolean listInsert(int pos,T value);
  16.     //4. getElem(L,i)：按位查找。获取表中第i个位置的元素的值。
  17.     T getElem(int pos);
  19.     //6. listDelete(&L,i,e)：删除操作。删除表L中第i个位置的元素。
  20.     boolean listDelete(int pos);
  22.     //7. PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。
  23.     void PrintList();
  25.     //8. empty(L)：判空操作。若L为空表，则放回true，否则放回false。
  26.     boolean isEmpty();
  28.     //9. length(L)：求表长。放回线性表L的长度，即L中数据元素的个数。
  29.     int getLength();
  30. }

5.2、顺序表的实现类

  1. package com.xgp.顺序表;
  3. public class MyListImpl<T> implements MyList<T> {
  5.     private Object arr[] = null;
  6.     private int size;
  8.     @Override
  9.     public MyList<T> initList() {
  10.         arr = new Object[20];
  11.         size = 0;
  12.         return this;
  13.     }
  15.     @Override
  16.     public boolean destroyList() {
  17.         arr = null;
  18.         size = 0;
  19.         System.gc();
  20.         return true;
  21.     }
  23.     @Override
  24.     public int locateElem(T value) {
  25.         if(arr == null) return 0;
  26.         for(int i = 0;i < size;i++) {
  27.             if(arr[i].equals(value)) return i + 1;
  28.         }
  29.         return 0;
  30.     }
  32.     @Override
  33.     public boolean listInsert(int pos, T value) {
  34.         if(arr == null) return false;
  35.         if(pos < 1 || pos > size + 1) return false;
  37.         if(size >= arr.length) {
  38.             //扩容
  39.             Object[] newarr = new Object[arr.length * 2];
  40.             //拷贝
  41.             for(int i = 0;i < size;i++) {
  42.                 newarr[i] = arr[i];
  43.             }
  44.             //修改指向
  45.             arr = newarr;
  46.             System.gc();
  47.         }
  49.         //插入
  50.         for(int i = size;size >= pos;pos--) {
  51.             arr[i] = arr[i - 1];
  52.         }
  54.         arr[pos - 1] = value;
  55.         size++;
  56.         return true;
  57.     }
  59.     @Override
  60.     public T getElem(int pos) {
  61.         if(arr == null) return null;
  62.         if(pos < 1 || pos > size) return null;
  63.         return (T) arr[pos - 1];
  64.     }
  66.     @Override
  67.     public boolean listDelete(int pos) {
  68.         if(arr == null) return false;
  69.         if(pos < 1 || pos > size) return false;
  71.         for(int i = pos - 1;i < size - 1;i++) {
  72.             arr[i] = arr[i+1];
  73.         }
  75.         size--;
  76.         return true;
  77.     }
  79.     @Override
  80.     public void PrintList() {
  81.         for (int i = 0;i < size;i++) {
  82.             System.out.print(arr[i] + " ");
  83.         }
  84.         System.out.println();
  85.     }
  87.     @Override
  88.     public boolean isEmpty() {
  89.         return arr == null;
  90.     }
  92.     @Override
  93.     public int getLength() {
  94.         return size;
  95.     }
  97. }

5.3、顺序表的测试类

  1. package com.xgp.顺序表;
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         //1、测试初始化操作
  6.         MyList<Integer> list = new MyListImpl<>();
  7.         list.initList();
  9.         //2、测试插入操作
  10.         for(int i = 1;i < 100;i++) {
  11.             if(list.listInsert(i,i*100)) System.out.print( i + "号元素插入成功 ");
  12.         }
  13.         System.out.println();
  15.         //3、测试判空操作
  16.         if(list.isEmpty()) System.out.println("空表");
  17.         else System.out.println("不是空表");
  19.         //4、测试求表长操作
  20.         System.out.println(list.getLength());
  22.         //5、测试按位删除操作
  23.         if(list.listDelete(56)) System.out.println("删除成功");
  25.         //6、测试按位查找的操作
  26.         System.out.println(list.getElem(56));
  28.         //7、测试按值查找的操作
  29.         System.out.println(list.locateElem(1000));
  31.         //8、测试输出操作
  32.         list.PrintList();
  34.         //9、测试销毁操作
  35.         if(list.destroyList()) System.out.println("销毁成功");
  36.     }
  37. }

5.4、输出结果

  1. 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号元素插入成功
  2. 不是空表
  3. 99
  4. 删除成功
  5. 5700
  6. 10
  7. 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900 2000 2100 2200 2300 2400 2500 2600 2700 2800 2900 3000 3100 3200 3300 3400 3500 3600 3700 3800 3900 4000 4100 4200 4300 4400 4500 4600 4700 4800 4900 5000 5100 5200 5300 5400 5500 5700 5800 5900 6000 6100 6200 6300 6400 6500 6600 6700 6800 6900 7000 7100 7200 7300 7400 7500 7600 7700 7800 7900 8000 8100 8200 8300 8400 8500 8600 8700 8800 8900 9000 9100 9200 9300 9400 9500 9600 9700 9800 9900
  8. 销毁成功
  10. 进程完成，退出码 0

6、C++实现方式：

6.1、顺序表类的抽象

  1. #ifndef XGP_STUDY_DEMO40_MYLIST_H
  2. #define XGP_STUDY_DEMO40_MYLIST_H
  4. #include <iostream>
  5. using namespace std;
  7. template <class T>
  8. class MyList {
  9. private:
  10.     T* arr;     //存放数据的地址
  11.     int size;       //当前又多少元素
  12.     int maxSize;     //当前动态数组的最大长度
  13. public:
  14.     //1. initList(&L)：初始化表。构造一个空的线性表。放回值应该是一个线性表
  15.     MyList<T> initList();
  17.     //2. destroyList(&L)：销毁操作。销毁线性表，并释放线性表L所占的内存空间。放回值为void
  18.     bool destroyList();
  20.     //3. locateElem(L,e)：按值查找操作。在表中L查找具有给定关键值的元素。放回一个int类型
  21.     int locateElem(T value);
  23.     //5. listInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定的元素e。
  24.     bool listInsert(int pos,T value);
  26.     //4. getElem(L,i)：按位查找。获取表中第i个位置的元素的值。
  27.     T getElem(int pos);
  29.     //6. listDelete(&L,i,e)：删除操作。删除表L中第i个位置的元素。
  30.     bool listDelete(int pos);
  32.     //7. PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。
  33.     void PrintList();
  35.     //8. empty(L)：判空操作。若L为空表，则放回true，否则放回false。
  36.     bool isEmpty();
  38.     //9. length(L)：求表长。放回线性表L的长度，即L中数据元素的个数。
  39.     int getLength();
  41. };
  43. #endif //XGP_STUDY_DEMO40_MYLIST_H

6.2、顺序表类的实现

  1. #include "MyList.h"
  3. template<class T>
  4. MyList<T> MyList<T>::initList() {
  5.     arr = new T[20];
  6.     size = 0;
  7.     maxSize = 20;
  8.     return *this;
  9. }
  11. template<class T>
  12. bool MyList<T>::destroyList() {
  13.     if(arr == NULL || this == NULL)
  14.         return false;
  15.     delete arr;
  16.     arr = NULL;
  17.     delete this;
  18.     size = 0;
  19.     maxSize = 0;
  20.     return true;
  21. }
  23. template<class T>
  24. int MyList<T>::locateElem(T value) {
  25.     if(arr == NULL) return 0;
  26.     for (int i = 0; i < size; i++) {
  27.         if(arr[i] == value) return i + 1;
  28.     }
  29.     return 0;
  30. }
  32. template<class T>
  33. bool MyList<T>::listInsert(int pos, T value) {
  34.     if(arr == NULL) return false;
  35.     if(pos < 1 || pos > size + 1) return false;
  37.     //看容量是否大
  38.     if(size >= maxSize) {
  39.         T* newArr = new T[maxSize * 2];
  41.         for(int i = 0;i < size;i++) {
  42.             newArr[i] = arr[i];
  43.         }
  45.         delete arr;
  46.         arr = newArr;
  48.         maxSize = maxSize * 2;
  49.     }
  51.     //插入
  52.     for(int i = size;size >= pos;i--) {
  53.         arr[i] = arr[i - 1];
  54.     }
  56.     arr[pos - 1] = value;
  57.     size++;
  58.     return true;
  59. }
  61. template<class T>
  62. T MyList<T>::getElem(int pos) {
  63.     if(arr == NULL) return false;
  64.     if(pos < 1 || pos > size ) return false;
  66.     return arr[pos - 1];
  67. }
  69. template<class T>
  70. bool MyList<T>::listDelete(int pos) {
  71.     if(arr == NULL) return false;
  72.     if(pos < 1 || pos > size ) return false;
  74.     for(int i = pos -1;i < size - 1;i++) {
  75.         arr[i] = arr[i + 1];
  76.     }
  77.     size--;
  78.     return true;
  79. }
  81. template<class T>
  82. void MyList<T>::PrintList() {
  83.     for(int i = 0;i < size;i++) {
  84.         cout<<arr[i]<<" ";
  85.     }
  86.     cout<<endl;
  87. }
  89. template<class T>
  90. bool MyList<T>::isEmpty() {
  91.     return arr == NULL;
  92. }
  94. template<class T>
  95. int MyList<T>::getLength() {
  96.     return size;
  97. }

6.3、测试顺序表

  1. #include "MyList.cpp"
  3. int main() {
  4.     //1、测试初始化操作
  5.     MyList<int> list;
  6.     list.initList();
  8.     //2、测试插入操作
  9.     for(int i = 1;i < 100;i++) {
  10.         if(list.listInsert(i,i*100)) cout<<i<<"号元素等到了插入成功 ";
  11.     }
  13.     cout<<endl;
  15.     //3、测试判空操作
  16.     if(list.isEmpty()) cout<<"空表"<<endl;
  17.     else cout<<"不是空表"<<endl;
  19.     //4、测试求表长操作
  20.     cout<<list.getLength()<<endl;
  22.     //5、测试按位删除操作
  23.     if(list.listDelete(56)) cout<<"删除成功"<<endl;
  25.     //6、测试按位查找的操作
  26.     cout<<list.getElem(56)<<endl;
  28.     //7、测试按值查找的操作
  29.     cout<<list.locateElem(1000)<<endl;
  31.     //8、测试输出操作
  32.     list.PrintList();
  34.     //9、测试销毁操作
  35.     if(list.destroyList()) cout<<"销毁成功"<<endl;
  36.     return 0;
  37. }

6.4、输出结果

  1. 1号元素等到了插入成功 2号元素等到了插入成功 3号元素等到了插入成功 4号元素等到了插入成功 5号元素等到了插入成功 6号元素等
  2. 到了插入成功 7号元素等到了插入成功 8号元素等到了插入成功 9号元素等到了插入成功 10号元素等到了插入成功 11号元素等到了插入
  3. 成功 12号元素等到了插入成功 13号元素等到了插入成功 14号元素等到了插入成功 15号元素等到了插入成功 16号元素等到了插入成功
  4. 17号元素等到了插入成功 18号元素等到了插入成功 19号元素等到了插入成功 20号元素等到了插入成功 21号元素等到了插入成功 22号
  5. 元素等到了插入成功 23号元素等到了插入成功 24号元素等到了插入成功 25号元素等到了插入成功 26号元素等到了插入成功 27号元素
  6. 等到了插入成功 28号元素等到了插入成功 29号元素等到了插入成功 30号元素等到了插入成功 31号元素等到了插入成功 32号元素等到
  7. 了插入成功 33号元素等到了插入成功 34号元素等到了插入成功 35号元素等到了插入成功 36号元素等到了插入成功 37号元素等到了插
  8. 入成功 38号元素等到了插入成功 39号元素等到了插入成功 40号元素等到了插入成功 41号元素等到了插入成功 42号元素等到了插入成
  9. 功 43号元素等到了插入成功 44号元素等到了插入成功 45号元素等到了插入成功 46号元素等到了插入成功 47号元素等到了插入成功 48
  10. 号元素等到了插入成功 49号元素等到了插入成功 50号元素等到了插入成功 51号元素等到了插入成功 52号元素等到了插入成功 53号元
  11. 素等到了插入成功 54号元素等到了插入成功 55号元素等到了插入成功 56号元素等到了插入成功 57号元素等到了插入成功 58号元素等
  12. 到了插入成功 59号元素等到了插入成功 60号元素等到了插入成功 61号元素等到了插入成功 62号元素等到了插入成功 63号元素等到了
  13. 插入成功 64号元素等到了插入成功 65号元素等到了插入成功 66号元素等到了插入成功 67号元素等到了插入成功 68号元素等到了插入
  14. 成功 69号元素等到了插入成功 70号元素等到了插入成功 71号元素等到了插入成功 72号元素等到了插入成功 73号元素等到了插入成功
  15. 74号元素等到了插入成功 75号元素等到了插入成功 76号元素等到了插入成功 77号元素等到了插入成功 78号元素等到了插入成功 79号
  16. 元素等到了插入成功 80号元素等到了插入成功 81号元素等到了插入成功 82号元素等到了插入成功 83号元素等到了插入成功 84号元素
  17. 等到了插入成功 85号元素等到了插入成功 86号元素等到了插入成功 87号元素等到了插入成功 88号元素等到了插入成功 89号元素等到
  18. 了插入成功 90号元素等到了插入成功 91号元素等到了插入成功 92号元素等到了插入成功 93号元素等到了插入成功 94号元素等到了插
  19. 入成功 95号元素等到了插入成功 96号元素等到了插入成功 97号元素等到了插入成功 98号元素等到了插入成功 99号元素等到了插入成
  20. 功
  21. 不是空表
  22. 99
  23. 删除成功
  24. 5700
  25. 10
  26. 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900 2000 2100 2200 2300 2400 2500 2600
  27.  2700 2800 2900 3000 3100 3200 3300 3400 3500 3600 3700 3800 3900 4000 4100 4200 4300 4400 4500 4600 4700 4800 4900 5000
  28.  5100 5200 5300 5400 5500 5700 5800 5900 6000 6100 6200 6300 6400 6500 6600 6700 6800 6900 7000 7100 7200 7300 7400 7500
  29.  7600 7700 7800 7900 8000 8100 8200 8300 8400 8500 8600 8700 8800 8900 9000 9100 9200 9300 9400 9500 9600 9700 9800 9900
  31. 销毁成功
  33. Process finished with exit code 0

五种编程语言解释数据结构与算法——顺序表2（java与C++语言实现）的更多相关文章

  1. 五种编程语言解释数据结构与算法——顺序表1（理论与C语言实现）

    1.线性表的分类 2.线性表的定义及其基本操作 2.1.定义:线性表是具有相同类型的n(n>=0)个元素的有序序列,其中n为表长,当n=0时,该表为空表. 2.3.线性表的逻辑结构为: 2.4. ...

  2. 五种编程语言解释数据结构与算法——顺序表3（JavaScript与Python语言实现）

    7.JavaScript语言实现 7.1.用ES6语法编写顺序表类 //1.创建类 class MyList { //1. initList(&L):初始化表.构造一个空的线性表.放回值应该是 ...

  3. 【数据结构】之顺序表（Java语言描述）

    之前总结过使用C语言描述的顺序表数据结构.在C语言类库中没有为我们提供顺序表的数据结构,因此我们需要自己手写,详细的有关顺序表的数据结构描述和C语言代码请见[我的这篇文章]. 在Java语言的JDK中 ...

  4. C++数据结构学习之顺序表

    顺序表是数据结构中最基本也是应用相当广泛的一种数据结构类型.它通常包含三个私有成分,即指向数据数组的头指针.当前表长以及表的实际容量.表的头指针通常指向数据数组的基地址,通过数组的形式进行访问数据数组 ...

  5. 数据结构 单链表&顺序表

    顺序表: 一般使用数组(C语言中的数组采用顺序存储方式.即连续地址存储)来描述. 优点:在于随机访问元素, 缺点:插入和和删除的时候,需要移动大量的元素. 链表: 优点:插入或删除元素时很方便,使用灵 ...

  6. 【数据结构】之顺序表（C语言描述）

    顺序表是线性表的一种,它将元素存储在一段连续的内存空间中,表中的任意元素都可以通过下标快速的获取到,因此,顺序表适合查询操作频繁的场景,而不适合增删操作频繁的场景. 下面是使用 C语言 编写的顺序表的 ...

  7. 数据结构之动态顺序表(C实现)

    线性表有2种,分为顺序表和链表. 顺序表: 采用顺序存储方式,在一组地址连续的存储空间上存储数据元素的线性表(长度固定) 链表: 有3种,单链表.双向链表.循环链表(长度不固定) seqList.h ...

  8. 数据结构：DHU顺序表ADT模板设计及简单应用：找匹配

    顺序表ADT模板设计及简单应用:找匹配 时间限制: 1S类别: DS:线性表->线性表应用 问题描述: 输入范例: 100000100000 99999 99998 99997 99996 99 ...

  9. C++ 数据结构学习一(顺序表)

    //SequentialList.h 顺序表模板类 #ifndef SEQUENTIAL_LIST_HXX#define SEQUENTIAL_LIST_HXX using std::cout; us ...

随机推荐

  1. CentOS 6.6 下源码编译安装MySQL 5.7.5

    版权声明:转自:http://www.linuxidc.com/Linux/2015-08/121667.htm 说明:CentOS 6.6 下源码编译安装MySQL 5.7.5 1. 安装相关工具# ...

  2. Kafka系列1：Kafka概况

    Kafka系列1:Kafka概况 Kafka是当前分布式系统中最流行的消息中间件之一,凭借着其高吞吐量的设计,在日志收集系统和消息系统的应用场景中深得开发者喜爱.本篇就聊聊Kafka相关的一些知识点. ...

  3. python sqlalchemy mysql 自动映射

    SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作 简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果 ...

  4. tomcat 持久区溢出

    知识点:堆内存设置(JVM堆内存)java的堆内存分为两块:permantspace(持久带) 和 heap spaceOOM1.年老代溢出,表现为:java.lang.OutOfMemoryErro ...

  5. c和c++中读取数据的方式总结

    目录 c 输出 printf() 输入 scanf getchar(), putchar() gets(), puts() c++ 输入 cin() getline() get() 输出 cout 最 ...

  6. js小练习---实现红绿灯

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  7. ubuntu 如何搭建svn 服务器

    1.在终端中直接输入  sudo apt-get install subversion,选择安装即可 来这个subversion同时包含了服务端和客户端. 2.(可选)看版本命令 svnserve - ...

  8. （七）mybatis批量操作，分页插件

    首先使用方式很简单: SqlSession sqlSession = sessionFactory.openSession(ExecutorType.BATCH); 批量操作核心:改变执行sql的方式 ...

  9. 5G为人工智能与工业互联网赋能 高清79页PPT

    人工智能和5G是时下最热门的科技领域之一,两者都是能改变社会,推进下一代工业革命的颠覆性技术. 工业互联网是利用基础科学.工业.信息技术.互联网等领域的综合优势,从大数据应用等软服务切入,注重软件.网 ...

  10. 分布式SnowFlakeID（雪花ID）原理和改进优化

    最近在研究分布式框架的组件和整体设计思路.所有的问题,一旦涉及分布式难度就呈几何倍数的提升.包括最常见的ID生成也是,单机情况下,使用数据库自增ID.UUID都是简单易行的选择 但在分布式环境下,就需 ...