zoukankan html css js c++ java

五种编程语言解释数据结构与算法——顺序表（总）

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

1、线性表的分类

2、线性表的定义及其基本操作

2.1、定义：线性表是具有相同类型的n(n>=0)个元素的有序序列，其中n为表长，当n=0时，该表为空表。

2.3、线性表的逻辑结构为：

2.4、线性表的特点：

表中的元素个数有限
表中的元素居具有逻辑上的顺序性，在序列中各个元素排列顺序有其先后次序
表中的元素都是数据元素，每个元素都是单个元素
表中的元素的数据类型都相同，每个元素都是单个元素
表中的元素具有抽象性，即讨论元素之间一对一的逻辑关系，而不考虑元素究竟表示的内容
线性表是一种逻辑结构，表示元素之间一对一相邻的关系

2.5、线性表的九种基本操作：

initList(&L)：初始化表。构造一个空的线性表。
destroyList(&L)：销毁操作。销毁线性表，并释放线性表L所占的内存空间。
locateElem(L,e)：按值查找操作。在表中L查找具有给定关键值的元素。
getElem(L,i)：按位查找。获取表中第i个位置的元素的值。
listInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定的元素e。
listDelete(&L,i,e)：删除操作。删除表L中第i个位置的元素，并用e放回删除元素的值。
PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。
empty(L)：判空操作。若L为空表，则放回true，否则放回false。
length(L)：求表长。放回线性表L的长度，即L中数据元素的个数。

3、顺序表

3.1、线性表的顺序存储又称为顺序表。

3.2、顺序表中逻辑顺序与物理顺序是相同的

一组相邻连续存放的存储单元依次的存放线性表的元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。

3.3、数组和顺序表的区别

数组下标从0开始，而顺序表是从1开始的
数组长度固定，而顺序表的长度的可变的
数据可以是多维的，而顺序表只能是一维的。

3.4、在已知线性表第一个元素的地址时，可以求得任意一个表中元素得地址。

第i个元素的地址为：LOC(A)+(i-1)*sizeof(ElemType)，其中：LOC(A)为第一个元素的地址。

3.5、描述顺序表的方法：

数组的静态分配
数组的动态分配

4、顺序表的C语言表述：（数组的动态分配来表示）

4.1、准备顺序表的头文件（MyList.h），定义顺序表的抽象结构。

#ifndef XGP_STUDY_DEMO37_MYLIST_H
#define XGP_STUDY_DEMO37_MYLIST_H
include <stdio.h>
include <stdlib.h>
include <string.h>
//动态数组的结构体

typedef struct MyList {

int* pAddr;     //存放数据的地址

int size;       //当前又多少元素

int maxSize;   //容量，容器当前的最大能容纳的元素

} myList;
//1. initList(&L)：初始化表。构造一个空的线性表。放回值应该是一个线性表

myList* initList();
//2. destroyList(&L)：销毁操作。销毁线性表，并释放线性表L所占的内存空间。放回值为void

int destroyList(myList* list);
//3. locateElem(L,e)：按值查找操作。在表中L查找具有给定关键值的元素。放回一个int类型

int locateElem(myList* list,int value);
//4. getElem(L,i)：按位查找。获取表中第i个位置的元素的值。

int getElem(myList* list, int pos);
//5. listInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定的元素e。

int listInsert(myList* list, int pos,int value);
//6. listDelete(&L,i,e)：删除操作。删除表L中第i个位置的元素，并用e放回删除元素的值。

int listDelete(myList* list,int pos);
//7. PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。

void PrintList(myList* list);
//8. empty(L)：判空操作。若L为空表，则放回true，否则放回false。

int isEmpty(myList* list);
//9. length(L)：求表长。放回线性表L的长度，即L中数据元素的个数。

int getLength(myList* list);
endif //XGP_STUDY_DEMO37_MYLIST_H

4.2、实现插入方法

插入操作的示意图：

插入操作的代码演示：

//5. listInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定的元素e。
int listInsert(myList* list, int pos,int value) {   //插入成功放回1，否则放回0
    //如果插入的元素的位置比1小或者大于顺序表的长度 + 1，则插入失败，放回0
    if(pos < 1 || pos > list->size + 1) return 0;
    //判断该顺序表的空间是否满，满了则需要扩容
    if(list->size >= list->maxSize) {
        //扩容
        //第一步：申请一块更大的内存空间 新空间是旧空间的两倍
        int* newSpace = (int*)malloc(sizeof(int) * list->maxSize * 2);
        //第二步：拷贝数据到新的空间
        memcpy(newSpace,list->pAddr,list->maxSize * sizeof(int));
        //第三步：释放旧空间的内存
        free(list->pAddr);
        //更新容量
        list->maxSize = list->maxSize * 2;
        //更新指针指向
        list->pAddr = newSpace;
    }
//执行插入操作
for(int i = list-&gt;size;i &gt;= pos;i--) {
    list-&gt;pAddr[i] = list-&gt;pAddr[i -1];
}

list-&gt;pAddr[pos -1] = value;
list-&gt;size++;
return 1;

}

动态图模拟该过程：

时间复杂度分析：最好O(1)、最坏O(n)、平均O(n)

4.3、实现删除操作

删除操作的示意图：

删除操作的代码演示：

//6. listDelete(&L,i,e)：删除操作。删除表L中第i个位置的元素，并用e放回删除元素的值。
int listDelete(myList* list,int pos) {
    if(pos < 1 || pos > list->size) return 0;
    int temp = list->pAddr[pos -1];
    for(int i = pos -1;i < list->size - 1;i++) {
        list->pAddr[i] = list->pAddr[i + 1];
    }
    list->size--;
    return temp;
}

动态图模拟该过程：

时间复杂度分析：最好O(1)、最坏O(n)、平均O(n)

4.3、实现按值查找的方法

按值查找操作的示意图：

按值查找操作的代码演示：

//3. locateElem(L,e)：按值查找操作。在表中L查找具有给定关键值的元素。放回一个int类型
int locateElem(myList* list,int value) {
    for(int i = 0;i < list->size;i++) {
        if(list->pAddr[i] == value) return i+1;
    }
    return 0;
}

时间复杂度分析：最好O(1)、最坏O(n)、平均O(n)

4.4、顺序表的其他函数代码如下（完整版）

#include "MyList.h"
//1. initList(&L)：初始化表。构造一个空的线性表。放回值应该是一个线性表

myList* initList() {

myList* list = (myList*)malloc(sizeof(myList));

list->maxSize = 20;

list->size = 0;
list-&gt;pAddr = (int*)malloc(sizeof(int) * list-&gt;maxSize);
return list;

}
//2. destroyList(&L)：销毁操作。销毁线性表，并释放线性表L所占的内存空间。放回值为void

int destroyList(myList* list) {

if(list == NULL) return 0;

//释放指向的内存区域

if(list->pAddr != NULL) {

free(list->pAddr);

list->pAddr = NULL;

}

//释放线性表

free(list);

list = NULL;

return 1;

}
//3. locateElem(L,e)：按值查找操作。在表中L查找具有给定关键值的元素。放回一个int类型

int locateElem(myList* list,int value) {

for(int i = 0;i < list->size;i++) {

if(list->pAddr[i] == value) return i+1;

}

return 0;

}
//4. getElem(L,i)：按位查找。获取表中第i个位置的元素的值。

int getElem(myList* list, int pos) {

if(pos < 1 || pos > list->size) return 0;

return list->pAddr[pos - 1];

}
//5. listInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定的元素e。

int listInsert(myList* list, int pos,int value) {   //插入成功放回1，否则放回0

//如果插入的元素的位置比1小或者大于顺序表的长度 + 1，则插入失败，放回0

if(pos < 1 || pos > list->size + 1) return 0;

//判断该顺序表的空间是否满，满了则需要扩容

if(list->size >= list->maxSize) {

//扩容

//第一步：申请一块更大的内存空间 新空间是旧空间的两倍

int* newSpace = (int*)malloc(sizeof(int) * list->maxSize * 2);

//第二步：拷贝数据到新的空间

memcpy(newSpace,list->pAddr,list->maxSize * sizeof(int));

//第三步：释放旧空间的内存

free(list->pAddr);

//更新容量

list->maxSize = list->maxSize * 2;

//更新指针指向

list->pAddr = newSpace;

}
//执行插入操作
for(int i = list-&gt;size;i &gt;= pos;i--) {
    list-&gt;pAddr[i] = list-&gt;pAddr[i -1];
}

list-&gt;pAddr[pos -1] = value;
list-&gt;size++;
return 1;

}
//6. listDelete(&L,i,e)：删除操作。删除表L中第i个位置的元素，并用e放回删除元素的值。

int listDelete(myList* list,int pos) {

if(pos < 1 || pos > list->size) return 0;

int temp = list->pAddr[pos -1];

for(int i = pos -1;i < list->size - 1;i++) {

list->pAddr[i] = list->pAddr[i + 1];

}

list->size--;

return temp;

}
//7. PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。

void PrintList(myList* list) {

for(int i = 0;i < list->size;i++) {

printf("%d ",list->pAddr[i]);

}

printf("
");

}
//8. empty(L)：判空操作。若L为空表，则放回true，否则放回false。

int isEmpty(myList* list) {

if(list == NULL || list->pAddr == NULL) return 1;

return 0;

}
//9. length(L)：求表长。放回线性表L的长度，即L中数据元素的个数。

int getLength(myList* list) {

return list->size;

}

4.5、测试我们的顺序表

#include "MyList.h"
void test() {

//1、测试初始化操作

myList* list = initList();
//2、测试插入操作
for(int i = 1;i &lt; 100;i++) {
    int flag = listInsert(list, i, i * 100);
    if(flag == 1) printf(&quot;%d号元素插入成功 &quot;,i);
}

//3、测试判空操作
int flag3 = isEmpty(list);
if(flag3 == 1)
    printf(&quot;该表为空表&quot;);
else
    printf(&quot;该表不为空表&quot;);

//4、测试求表长操作
printf(&quot;该顺序表的表长为：%d
&quot;,getLength(list));

//5、测试按位删除操作
int flag = listDelete(list, 56);
printf(&quot;被删除的元素为%d
&quot;,flag);

//6、测试按位查找的操作
int res = getElem(list, 56);
printf(&quot;56号元素为:%d
&quot;,res);

//7、测试按值查找的操作
int count = locateElem(list, 1000);
printf(&quot;1000所在的位置为：%d
&quot;,count);

//8、测试输出操作
PrintList(list);

//9、测试销毁操作
int flag2 = destroyList(list);
if(flag2 == 1) printf(&quot;销毁成功
&quot;);

}
int main() {

test();

return 0;

}

4.6、运行结果

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号元素插入成功该表不为空表该顺序表的表长为：99 被删除的元素为5600 56号元素为:5700 1000所在的位置为：10 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 销毁成功

Process finished with exit code 0

五种编程语言解释数据结构与算法——顺序表2（java与C++语言实现）

5、java实现方式：

5.1、顺序表的抽象结构

package com.xgp.顺序表;
public interface MyList<T> {

//1. initList(&L)：初始化表。构造一个空的线性表。放回值应该是一个线性表

MyList<T> initList();
//2. destroyList(&amp;L)：销毁操作。销毁线性表，并释放线性表L所占的内存空间。放回值为void
boolean destroyList();

//3. locateElem(L,e)：按值查找操作。在表中L查找具有给定关键值的元素。放回一个int类型
int locateElem(T value);

//5. listInsert(&amp;L,i,e)：插入操作。在表L中的第i个位置上插入指定的元素e。
boolean listInsert(int pos,T value);

//4. getElem(L,i)：按位查找。获取表中第i个位置的元素的值。
T getElem(int pos);

//6. listDelete(&amp;L,i,e)：删除操作。删除表L中第i个位置的元素。
boolean listDelete(int pos);

//7. PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。
void PrintList();

//8. empty(L)：判空操作。若L为空表，则放回true，否则放回false。
boolean isEmpty();

//9. length(L)：求表长。放回线性表L的长度，即L中数据元素的个数。
int getLength();

}

5.2、顺序表的实现类

package com.xgp.顺序表;
public class MyListImpl<T> implements MyList<T> {
private Object arr[] = null;
private int size;

@Override
public MyList&lt;T&gt; initList() {
    arr = new Object[20];
    size = 0;
    return this;
}

@Override
public boolean destroyList() {
    arr = null;
    size = 0;
    System.gc();
    return true;
}

@Override
public int locateElem(T value) {
    if(arr == null) return 0;
    for(int i = 0;i &lt; size;i++) {
        if(arr[i].equals(value)) return i + 1;
    }
    return 0;
}

@Override
public boolean listInsert(int pos, T value) {
    if(arr == null) return false;
    if(pos &lt; 1 || pos &gt; size + 1) return false;

    if(size &gt;= arr.length) {
        //扩容
        Object[] newarr = new Object[arr.length * 2];
        //拷贝
        for(int i = 0;i &lt; size;i++) {
            newarr[i] = arr[i];
        }
        //修改指向
        arr = newarr;
        System.gc();
    }

    //插入
    for(int i = size;size &gt;= pos;pos--) {
        arr[i] = arr[i - 1];
    }

    arr[pos - 1] = value;
    size++;
    return true;
}

@Override
public T getElem(int pos) {
    if(arr == null) return null;
    if(pos &lt; 1 || pos &gt; size) return null;
    return (T) arr[pos - 1];
}

@Override
public boolean listDelete(int pos) {
    if(arr == null) return false;
    if(pos &lt; 1 || pos &gt; size) return false;

    for(int i = pos - 1;i &lt; size - 1;i++) {
        arr[i] = arr[i+1];
    }

    size--;
    return true;
}

@Override
public void PrintList() {
    for (int i = 0;i &lt; size;i++) {
        System.out.print(arr[i] + &quot; &quot;);
    }
    System.out.println();
}

@Override
public boolean isEmpty() {
    return arr == null;
}

@Override
public int getLength() {
    return size;
}

}

5.3、顺序表的测试类

package com.xgp.顺序表;
public class Main {

public static void main(String[] args) {

//1、测试初始化操作

MyList<Integer> list = new MyListImpl<>();

list.initList();
    //2、测试插入操作
    for(int i = 1;i &lt; 100;i++) {
        if(list.listInsert(i,i*100)) System.out.print( i + &quot;号元素插入成功 &quot;);
    }
    System.out.println();

    //3、测试判空操作
    if(list.isEmpty()) System.out.println(&quot;空表&quot;);
    else System.out.println(&quot;不是空表&quot;);

    //4、测试求表长操作
    System.out.println(list.getLength());

    //5、测试按位删除操作
    if(list.listDelete(56)) System.out.println(&quot;删除成功&quot;);

    //6、测试按位查找的操作
    System.out.println(list.getElem(56));

    //7、测试按值查找的操作
    System.out.println(list.locateElem(1000));

    //8、测试输出操作
    list.PrintList();

    //9、测试销毁操作
    if(list.destroyList()) System.out.println(&quot;销毁成功&quot;);
}

}

5.4、输出结果

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号元素插入成功不是空表 99 删除成功 5700 10 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 销毁成功

进程完成，退出码 0

6、C++实现方式：

6.1、顺序表类的抽象

#ifndef XGP_STUDY_DEMO40_MYLIST_H
#define XGP_STUDY_DEMO40_MYLIST_H
include <iostream>
using namespace std;
template <class T>

class MyList {

private:

T* arr;     //存放数据的地址

int size;       //当前又多少元素

int maxSize;     //当前动态数组的最大长度

public:

//1. initList(&L)：初始化表。构造一个空的线性表。放回值应该是一个线性表

MyList<T> initList();
//2. destroyList(&amp;L)：销毁操作。销毁线性表，并释放线性表L所占的内存空间。放回值为void
bool destroyList();

//3. locateElem(L,e)：按值查找操作。在表中L查找具有给定关键值的元素。放回一个int类型
int locateElem(T value);

//5. listInsert(&amp;L,i,e)：插入操作。在表L中的第i个位置上插入指定的元素e。
bool listInsert(int pos,T value);

//4. getElem(L,i)：按位查找。获取表中第i个位置的元素的值。
T getElem(int pos);

//6. listDelete(&amp;L,i,e)：删除操作。删除表L中第i个位置的元素。
bool listDelete(int pos);

//7. PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。
void PrintList();

//8. empty(L)：判空操作。若L为空表，则放回true，否则放回false。
bool isEmpty();

//9. length(L)：求表长。放回线性表L的长度，即L中数据元素的个数。
int getLength();

};
endif //XGP_STUDY_DEMO40_MYLIST_H

6.2、顺序表类的实现

#include "MyList.h"
template<class T>

MyList<T> MyList<T>::initList() {

arr = new T[20];

size = 0;

maxSize = 20;

return *this;

}
template<class T>

bool MyList<T>::destroyList() {

if(arr == NULL || this == NULL)

return false;

delete arr;

arr = NULL;

delete this;

size = 0;

maxSize = 0;

return true;

}
template<class T>

int MyList<T>::locateElem(T value) {

if(arr == NULL) return 0;

for (int i = 0; i < size; i++) {

if(arr[i] == value) return i + 1;

}

return 0;

}
template<class T>

bool MyList<T>::listInsert(int pos, T value) {

if(arr == NULL) return false;

if(pos < 1 || pos > size + 1) return false;
//看容量是否大
if(size &gt;= maxSize) {
    T* newArr = new T[maxSize * 2];

    for(int i = 0;i &lt; size;i++) {
        newArr[i] = arr[i];
    }

    delete arr;
    arr = newArr;

    maxSize = maxSize * 2;
}

//插入
for(int i = size;size &gt;= pos;i--) {
    arr[i] = arr[i - 1];
}

arr[pos - 1] = value;
size++;
return true;

}
template<class T>

T MyList<T>::getElem(int pos) {

if(arr == NULL) return false;

if(pos < 1 || pos > size ) return false;
return arr[pos - 1];

}
template<class T>

bool MyList<T>::listDelete(int pos) {

if(arr == NULL) return false;

if(pos < 1 || pos > size ) return false;
for(int i = pos -1;i &lt; size - 1;i++) {
    arr[i] = arr[i + 1];
}
size--;
return true;

}
template<class T>

void MyList<T>::PrintList() {

for(int i = 0;i < size;i++) {

cout<<arr[i]<<" ";

}

cout<<endl;

}
template<class T>

bool MyList<T>::isEmpty() {

return arr == NULL;

}
template<class T>

int MyList<T>::getLength() {

return size;

}

6.3、测试顺序表

#include "MyList.cpp"
int main() {

//1、测试初始化操作

MyList<int> list;

list.initList();
//2、测试插入操作
for(int i = 1;i &lt; 100;i++) {
    if(list.listInsert(i,i*100)) cout&lt;&lt;i&lt;&lt;&quot;号元素等到了插入成功 &quot;;
}

cout&lt;&lt;endl;

//3、测试判空操作
if(list.isEmpty()) cout&lt;&lt;&quot;空表&quot;&lt;&lt;endl;
else cout&lt;&lt;&quot;不是空表&quot;&lt;&lt;endl;

//4、测试求表长操作
cout&lt;&lt;list.getLength()&lt;&lt;endl;

//5、测试按位删除操作
if(list.listDelete(56)) cout&lt;&lt;&quot;删除成功&quot;&lt;&lt;endl;

//6、测试按位查找的操作
cout&lt;&lt;list.getElem(56)&lt;&lt;endl;

//7、测试按值查找的操作
cout&lt;&lt;list.locateElem(1000)&lt;&lt;endl;

//8、测试输出操作
list.PrintList();

//9、测试销毁操作
if(list.destroyList()) cout&lt;&lt;&quot;销毁成功&quot;&lt;&lt;endl;
return 0;

}

6.4、输出结果

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号元素等到了插入成功不是空表 99 删除成功 5700 10 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 销毁成功

Process finished with exit code 0

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

7、JavaScript语言实现

7.1、用ES6语法编写顺序表类

//1、创建类
class MyList {
//1. initList(&amp;L)：初始化表。构造一个空的线性表。放回值应该是一个线性表
initList() {
    //1.1、创建数组，本身就可变长
    this.arr = [];
    //1.2、线性表的元素多少
    this.size = 0;
}

//2. destroyList(&amp;L)：销毁操作。销毁线性表，并释放线性表L所占的内存空间。放回值为void
destroyList() {
    this.arr = null;
    this.size = 0;
    return true;
}

//3. locateElem(L,e)：按值查找操作。在表中L查找具有给定关键值的元素。放回一个int类型
locateElem(value) {
    if(this.arr == null) return 0;
    for(var i = 0;i &lt; this.size;i++) {
        if(this.arr[i] == value) return i+1;
    }
    return 0;
}

//5. listInsert(&amp;L,i,e)：插入操作。在表L中的第i个位置上插入指定的元素e。
listInsert(pos,value) {
    if(this.arr == null) return false;
    if(pos &lt; 1 || pos &gt; this.size + 1) return false;

    //插入
    for(var i = this.size;this.size &gt;= pos;i--) {
        this.arr[i] = this.arr[i - 1];
    }

    this.arr[pos - 1] = value;
    this.size++;
    return true;
}

//4. getElem(L,i)：按位查找。获取表中第i个位置的元素的值。
getElem(pos) {
    if(this.arr == null) return false;
    if(pos &lt; 1 || pos &gt; this.size) return false;

    return this.arr[pos -1];
}

//6. listDelete(&amp;L,i,e)：删除操作。删除表L中第i个位置的元素。
listDelete(pos) {
    if(this.arr == null) return false;
    if(pos &lt; 1 || pos &gt; this.size) return false;

    for(var i = pos -1;i &lt; this.size - 1;i++) {
        this.arr[i] = this.arr[i + 1];
    }

    this.size--;
    return true;
}

//7. PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。
PrintList() {
    if(this.arr != null) {
        var str = &quot;&quot;;
        for(var i = 0;i &lt; this.size;i++) {
            str += this.arr[i] + &quot; &quot;;
        }
        console.log(str);
    }
}

//8. empty(L)：判空操作。若L为空表，则放回true，否则放回false。
isEmpty() {
    return this.arr == null;
}

//9. length(L)：求表长。放回线性表L的长度，即L中数据元素的个数。
getLength() {
    return this.size;
}

}

7.2、编写网页进行输出测试

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="./MyList.js"></script>
</head>
<body>
    <script>
        //1、测试初始化操作
        var list = new MyList();
        list.initList();
    //2、测试插入操作
    var str = &quot;&quot;;
    for(var i = 1;i &lt; 100;i++) {
        if(list.listInsert(i,i*100)) str += i + &quot;号元素插入成功&quot;;
    }
    console.log(str);

    //3、测试判空操作
    if(list.isEmpty()) console.log(&quot;空表&quot;);
    else console.log(&quot;非空表&quot;);

    //4、测试求表长操作
    console.log(list.getLength());

    //5、测试按位删除操作
    if(list.listDelete(56)) console.log(&quot;删除成功&quot;);

    //6、测试按位查找的操作
    console.log(list.getElem(56));

    //7、测试按值查找的操作
    console.log(list.locateElem(1000));

    //8、测试输出操作
    list.PrintList();
    //9、测试销毁操作
    if(list.destroyList()) console.log(&quot;销毁成功&quot;);

&lt;/script&gt;

</body>

</html>

7.3、输出结果

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号元素插入成功 MyList.html:20:17
非空表 MyList.html:24:22
99 MyList.html:27:17
删除成功 MyList.html:30:41
5700 MyList.html:33:17
10 MyList.html:36:17
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 MyList.js:71:21
销毁成功 MyList.html:41:40

8、Python语言实现

8.1、编写顺序表类

# 定义一个顺序表
class MyList:
# 1. initList(&amp;L)：初始化表。构造一个空的线性表。放回值应该是一个线性表
def initList(self):
    # print(&quot;初始化&quot;)
    self.arr = [None]*20
    self.size = 0

# 2. destroyList(&amp;L)：销毁操作。销毁线性表，并释放线性表L所占的内存空间。放回值为void
def destroyList(self):
    # print(&quot;销毁操作&quot;)
    self.arr = None
    self.size = 0
    return True

# 3. locateElem(L,e)：按值查找操作。在表中L查找具有给定关键值的元素。放回一个int类型
def locateElem(self,value):
    if(self.arr is None):
        return False
    # print(&quot;按值查找&quot;)
    for i in range(0,self.size):
        if(value == self.arr[i]):
            return i + 1

# 4. getElem(L,i)：按位查找。获取表中第i个位置的元素的值。
def getElem(self,pos):
    # print(&quot;按位查找&quot;)
    if(self.arr is None):
        return False
    if(pos &lt; 1 and pos &gt; self.size):
        return False
    return self.arr[pos - 1]

# 5. listInsert(&amp;L,i,e)：插入操作。在表L中的第i个位置上插入指定的元素e。
def listInsert(self,pos,value):
    # print(&quot;插入操作&quot;)
    if(self.arr is None):
        return False
    if(pos &lt; 1 and pos &gt; self.size + 1):
        return False
    if(pos &gt;= len(self.arr)):
        newArr = [None]*(len(self.arr) * 2)
        for i in range(0,self.size):
            # print(i)
            newArr[i] = self.arr[i]
        self.arr = newArr

    for i in range(pos,self.size - 1,-1):
        self.arr[i] = self.arr[i - 1]
    self.arr[pos - 1] = value
    # print(self.arr[pos - 1])
    self.size += 1
    return True

# 6. listDelete(&amp;L,i,e)：删除操作。删除表L中第i个位置的元素。
def listDelete(self,pos):
    # print(&quot;删除操作&quot;)
    if(self.arr is None):
        return False
    if(pos &lt; 1 and pos &gt; self.size):
        return False
    for i in range(pos - 1,self.size - 1):
        self.arr[i] = self.arr[i + 1]
    self.size -= 1
    return True

# 7. PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。
def PrintList(self):
    if(self.arr is not None):
        # print(&quot;输出操作&quot;)
        s = &quot;&quot;
        for i in range(0,self.size):
            s += str(self.arr[i]) + &quot; &quot;
        print(s)

# 8. empty(L)：判空操作。若L为空表，则放回true，否则放回false。
def isEmpty(self):
    # print(&quot;判空操作&quot;)
    return self.arr is None

# 9. length(L)：求表长。放回线性表L的长度，即L中数据元素的个数。
def getLength(self):
    # print(&quot;获取长度&quot;)
    return self.size

8.2、编写顺序表的测试类

from MyList import *
1、测试初始化操作
list = MyList()

list.initList()
2、测试插入操作
s = ""

for i in range(1,100):

if(list.listInsert(i,i*100)):

s += str(i) + "号元素插入成功 "

print(s)
3、测试判空操作
if(list.isEmpty()):

print("空表")

else:

print("不是空表")
4、测试求表长操作
print(list.getLength())
5、测试按位删除操作
if(list.listDelete(56)):

print("删除成功")
6、测试按位查找的操作
print(list.getElem(56))
7、测试按值查找的操作
print(list.locateElem(1000))
8、测试输出操作
list.PrintList()
9、测试销毁操作
if(list.destroyList()):

print("销毁成功")

8.3、测试结果

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号元素插入成功不是空表 99 删除成功 5700 10 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 销毁成功

Process finished with exit code 0

查看全文

相关阅读:
2013第五周上机任务【项目1 三角形类（构造函数）】
Google搜索小技巧
 项目总结：文件上传（MVC uploadify）
Oracle 触发器 Update 不能操作本表的疑问
 【笔试题STL】求两个vector的交集
 Zookeeper（六）数据模型
 是的，我们真的在遭遇有史以来最大的DDoS攻击，并且还在加剧
 在MFC框架下使用osg报内存泄露的解决办法
 NetBeans 时事通讯（刊号 # 107 Jun 25, 2010）
VS 2008中的C/C++静态代码分析工具Prefast

原文地址：https://www.cnblogs.com/xgp123/p/12329883.html