主頁 >  其他 > 五種編程語言解釋資料結構與演算法——順序表（總）

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

2020-09-20 07:10:58 其他

五種編程語言解釋資料結構與演算法——順序表1（理論與C語言實作）

1、線性表的分類

2、線性表的定義及其基本操作

2.1、定義：線性表是具有相同型別的n(n>=0)個元素的有序序列，其中n為表長，當n=0時，該表為空表，

2.3、線性表的邏輯結構為：

2.4、線性表的特點：

  1. 表中的元素個數有限
  2. 表中的元素居具有邏輯上的順序性，在序列中各個元素排列順序有其先后次序
  3. 表中的元素都是資料元素，每個元素都是單個元素
  4. 表中的元素的資料型別都相同，每個元素都是單個元素
  5. 表中的元素具有抽象性，即討論元素之間一對一的邏輯關系，而不考慮元素究竟表示的內容
  6. 線性表是一種邏輯結構，表示元素之間一對一相鄰的關系

2.5、線性表的九種基本操作：

  1. initList(&L)：初始化表，構造一個空的線性表，
  2. destroyList(&L)：銷毀操作，銷毀線性表，并釋放線性表L所占的記憶體空間，
  3. locateElem(L,e)：按值查找操作，在表中L查找具有給定關鍵值的元素，
  4. getElem(L,i)：按位查找，獲取表中第i個位置的元素的值，
  5. listInsert(&L,i,e)：插入操作，在表L中的第i個位置上插入指定的元素e，
  6. listDelete(&L,i,e)：洗掉操作，洗掉表L中第i個位置的元素，并用e放回洗掉元素的值，
  7. PrintList(L)：輸出操作，按前后順序輸出線性表L的所有元素值，
  8. empty(L)：判空操作，若L為空表，則放回true，否則放回false，
  9. length(L)：求表長，放回線性表L的長度，即L中資料元素的個數，

3、順序表

3.1、線性表的順序存盤又稱為順序表，

3.2、順序表中邏輯順序與物理順序是相同的

一組相鄰連續存放的存盤單元依次的存放線性表的元素，從而使得邏輯上相鄰的兩個元素在物理位置上也相鄰，

3.3、陣列和順序表的區別

  1. 陣列下標從0開始，而順序表是從1開始的
  2. 陣列長度固定，而順序表的長度的可變的
  3. 資料可以是多維的，而順序表只能是一維的，

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=https://www.cnblogs.com/xgp123/p/"./MyList.js"></script>

<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 =https://www.cnblogs.com/xgp123/p/= self.arr[i]):
            return i + 1

# 4. getElem(L,i)：按位查找，獲取表中第i個位置的元素的值，
def getElem(self,pos):
    # print("按位查找")
    if(self.arr is None):
        return False
    if(pos < 1 and pos > self.size):
        return False
    return self.arr[pos - 1]

# 5. listInsert(&L,i,e)：插入操作，在表L中的第i個位置上插入指定的元素e，
def listInsert(self,pos,value):
    # print("插入操作")
    if(self.arr is None):
        return False
    if(pos < 1 and pos > self.size + 1):
        return False
    if(pos >= 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(&L,i,e)：洗掉操作，洗掉表L中第i個位置的元素，
def listDelete(self,pos):
    # print("洗掉操作")
    if(self.arr is None):
        return False
    if(pos < 1 and pos > 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("輸出操作")
        s = ""
        for i in range(0,self.size):
            s += str(self.arr[i]) + " "
        print(s)

# 8. empty(L)：判空操作，若L為空表，則放回true，否則放回false，
def isEmpty(self):
    # print("判空操作")
    return self.arr is None

# 9. length(L)：求表長，放回線性表L的長度，即L中資料元素的個數，
def getLength(self):
    # print("獲取長度")
    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

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/86943.html

標籤：其他

上一篇：二叉樹的鏡像

下一篇：五種編程語言解釋資料結構與演算法——順序表1（理論與C語言實作）

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 網閘典型架構簡述

    網閘架構一般分為兩種：三主機的三系統架構網閘和雙主機的2+1架構網閘。 三主機架構分別為內端機、外端機和仲裁機。三機無論從軟體和硬體上均各自獨立。首先從硬體上來看，三機都用各自獨立的主板、記憶體及存盤設備。從軟體上來看，三機有各自獨立的作業系統。這樣能達到完全的三機獨立。對于“2+1”系統，“2”分為 ......

    uj5u.com 2020-09-10 02:00:44 more
  • 如何從xshell上傳檔案到centos linux虛擬機里

    如何從xshell上傳檔案到centos linux虛擬機里及：虛擬機CentOs下執行 yum -y install lrzsz命令，出現錯誤：鏡像無法找到軟體包 前言 一、安裝lrzsz步驟 二、上傳檔案 三、遇到的問題及解決方案 總結 前言 提示：其實很簡單，往虛擬機上安裝一個上傳檔案的工具 ......

    uj5u.com 2020-09-10 02:00:47 more
  • 一、SQLMAP入門

    一、SQLMAP入門 1、判斷是否存在注入 sqlmap.py -u 網址/id=1 id=1不可缺少。當注入點后面的引數大于兩個時。需要加雙引號， sqlmap.py -u "網址/id=1&uid=1" 2、判斷文本中的請求是否存在注入 從文本中加載http請求，SQLMAP可以從一個文本檔案中 ......

    uj5u.com 2020-09-10 02:00:50 more
  • Metasploit 簡單使用教程

    metasploit 簡單使用教程 浩先生， 2020-08-28 16:18:25 分類專欄： kail 網路安全 linux 文章標簽： linux資訊安全 編輯 著作權 metasploit 使用教程 前言 一、Metasploit是什么？ 二、準備作業 三、具體步驟 前言 Msfconsole ......

    uj5u.com 2020-09-10 02:00:53 more
  • 游戲逆向之驅動層與用戶層通訊

    驅動層代碼： #pragma once #include <ntifs.h> #define add_code CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ANY_ACCESS) /* 更多游戲逆向視頻www.yxfzedu.com ......

    uj5u.com 2020-09-10 02:00:56 more
  • 北斗電力時鐘（北斗授時服務器）讓網路資料更精準

    北斗電力時鐘（北斗授時服務器）讓網路資料更精準 北斗電力時鐘（北斗授時服務器）讓網路資料更精準 京準電子科技官微——ahjzsz 近幾年，資訊技術的得了快速發展，互聯網在逐漸普及，其在人們生活和生產中都得到了廣泛應用，并且取得了不錯的應用效果。計算機網路資訊在電力系統中的應用，一方面使電力系統的運行 ......

    uj5u.com 2020-09-10 02:01:03 more
  • 【CTF】CTFHub 技能樹 彩蛋 writeup

    ?碎碎念 CTFHub：https://www.ctfhub.com/ 筆者入門CTF時時剛開始刷的是bugku的舊平臺，后來才有了CTFHub。 感覺不論是網頁UI設計，還是題目質量，賽事跟蹤，工具軟體都做得很不錯。 而且因為獨到的金幣制度的確讓人有一種想去刷題賺金幣的感覺。 個人還是非常喜歡這個 ......

    uj5u.com 2020-09-10 02:04:05 more
  • 02windows基礎操作

    我學到了一下幾點 Windows系統目錄結構與滲透的作用 常見Windows的服務詳解 Windows埠詳解 常用的Windows注冊表詳解 hacker DOS命令詳解（net user / type /md /rd/ dir /cd /net use copy、批處理 等） 利用dos命令制作 ......

    uj5u.com 2020-09-10 02:04:18 more
  • 03.Linux基礎操作

    我學到了以下幾點 01Linux系統介紹02系統安裝，密碼啊破解03Linux常用命令04LAMP 01LINUX windows： win03 8 12 16 19 配置不繁瑣 Linux：redhat,centos(紅帽社區版)，Ubuntu server,suse unix:金融機構，證券，銀 ......

    uj5u.com 2020-09-10 02:04:30 more
  • 05HTML

    01HTML介紹 02頭部標簽講解03基礎標簽講解04表單標簽講解 HTML前段語言 js1.了解代碼2.根據代碼 懂得挖掘漏洞 （POST注入/XSS漏洞上傳）3.黑帽seo 白帽seo 客戶網站被黑帽植入劫持代碼如何處理4.熟悉html表單 <html><head><title>TDK標題，描述 ......

    uj5u.com 2020-09-10 02:04:36 more
最新发布
  • 2023年最新微信小程式抓包教程

    01 開門見山 隔一個月發一篇文章，不過分。 首先回顧一下《微信系結手機號資料庫被脫庫事件》，我也是第一時間得知了這個訊息，然后跟蹤了整件事情的經過。下面是這起事件的相關截圖以及近日流出的一萬條資料樣本： 個人認為這件事也沒什么，還不如關注一下之前45億快遞資料查詢渠道疑似在近日復活的訊息。 訊息是 ......

    uj5u.com 2023-04-20 08:48:24 more
  • web3 產品介紹：metamask 錢包 使用最多的瀏覽器插件錢包

    Metamask錢包是一種基于區塊鏈技術的數字貨幣錢包，它允許用戶在安全、便捷的環境下管理自己的加密資產。Metamask錢包是以太坊生態系統中最流行的錢包之一，它具有易于使用、安全性高和功能強大等優點。 本文將詳細介紹Metamask錢包的功能和使用方法。 一、 Metamask錢包的功能 數字資 ......

    uj5u.com 2023-04-20 08:47:46 more
  • vulnhub_Earth

    前言 靶機地址->>>vulnhub_Earth 攻擊機ip：192.168.20.121 靶機ip：192.168.20.122 參考文章 https://www.cnblogs.com/Jing-X/archive/2022/04/03/16097695.html https://www.cnb ......

    uj5u.com 2023-04-20 07:46:20 more
  • 從4k到42k，軟體測驗工程師的漲薪史，給我看哭了

    清明節一過，盲猜大家已經無心上班，在數著日子準備過五一，但一想到銀行卡里的余額……瞬間心情就不美麗了。最近，2023年高校畢業生就業調查顯示，本科畢業月平均起薪為5825元。調查一出，便有很多同學表示自己又被平均了。看著這一資料，不免讓人想到前不久中國青年報的一項調查：近六成大學生認為畢業10年內會 ......

    uj5u.com 2023-04-20 07:44:00 more
  • 最新版本 Stable Diffusion 開源 AI 繪畫工具之中文自動提詞篇

    🎈 標簽生成器 由于輸入正向提示詞 prompt 和反向提示詞 negative prompt 都是使用英文，所以對學習母語的我們非常不友好 使用網址：https://tinygeeker.github.io/p/ai-prompt-generator 這個網址是為了讓大家在使用 AI 繪畫的時候 ......

    uj5u.com 2023-04-20 07:43:36 more
  • 漫談前端自動化測驗演進之路及測驗工具分析

    隨著前端技術的不斷發展和應用程式的日益復雜，前端自動化測驗也在不斷演進。隨著 Web 應用程式變得越來越復雜，自動化測驗的需求也越來越高。如今，自動化測驗已經成為 Web 應用程式開發程序中不可或缺的一部分，它們可以幫助開發人員更快地發現和修復錯誤，提高應用程式的性能和可靠性。 ......

    uj5u.com 2023-04-20 07:43:16 more
  • CANN開發實踐：4個DVPP記憶體問題的典型案例解讀

    摘要：由于DVPP媒體資料處理功能對存放輸入、輸出資料的記憶體有更高的要求（例如，記憶體首地址128位元組對齊），因此需呼叫專用的記憶體申請介面，那么本期就分享幾個關于DVPP記憶體問題的典型案例，并給出原因分析及解決方法。 本文分享自華為云社區《FAQ_DVPP記憶體問題案例》，作者：昇騰CANN。 DVPP ......

    uj5u.com 2023-04-20 07:43:03 more
  • msf學習

    msf學習 以kali自帶的msf為例 一、msf核心模塊與功能 msf模塊都放在/usr/share/metasploit-framework/modules目錄下 1、auxiliary 輔助模塊，輔助滲透（埠掃描、登錄密碼爆破、漏洞驗證等） 2、encoders 編碼器模塊，主要包含各種編碼 ......

    uj5u.com 2023-04-20 07:42:59 more
  • Halcon軟體安裝與界面簡介

    1. 下載Halcon17版本到到本地 2. 雙擊安裝包后 3. 步驟如下 1.2 Halcon軟體安裝 界面分為四大塊 1. Halcon的五個助手 1) 影像采集助手：與相機連接，設定相機引數，采集影像 2) 標定助手：九點標定或是其它的標定，生成標定檔案及內參外參，可以將像素單位轉換為長度單位 ......

    uj5u.com 2023-04-20 07:42:17 more
  • 在MacOS下使用Unity3D開發游戲

    第一次發博客，先發一下我的游戲開發環境吧。 去年2月份買了一臺MacBookPro2021 M1pro(以下簡稱mbp)，這一年來一直在用mbp開發游戲。我大致分享一下我的開發工具以及使用體驗。 1、Unity 官網鏈接： https://unity.cn/releases 我一般使用的Apple ......

    uj5u.com 2023-04-20 07:40:19 more

Copyright © 2010-2020 有解無憂