五種編程語言解釋數據結構與算法——順序表（總）

本文轉載自查看原文 2020-02-19 09:46 639 多語言/ 理論學習/ 數據·結構·/ 順序表/ 技術學習

五種編程語言解釋數據結構與算法——順序表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("\n");
 }
//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\n&quot;,getLength(list));

//5、測試按位刪除操作
int flag = listDelete(list, 56);
printf(&quot;被刪除的元素為%d\n&quot;,flag);

//6、測試按位查找的操作
int res = getElem(list, 56);
printf(&quot;56號元素為:%d\n&quot;,res);

//7、測試按值查找的操作
int count = locateElem(list, 1000);
printf(&quot;1000所在的位置為：%d\n&quot;,count);

//8、測試輸出操作
PrintList(list);

//9、測試銷毀操作
int flag2 = destroyList(list);
if(flag2 == 1) printf(&quot;銷毀成功\n&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

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 五種編程語言解釋數據結構與算法—順序棧業余辦一個【編程語言+數據結構+算法】培訓班怎么樣？ C語言數據結構之順序表順序表的創建—數據結構算法數據結構與算法——順序表的實現及原理數據結構中的順序表和鏈表(Python語言) 數據結構學習1——順序表(C語言描述) 數據結構-順序表數據結構之順序表數據結構4:順序表(線性表的順序存儲結構)及C語言實現