---

前言

順序表是一種常見的線性數(shù)據(jù)結(jié)構(gòu)，它使用一段連續(xù)的存儲單元依次存儲數(shù)據(jù)元素。這種數(shù)據(jù)結(jié)構(gòu)的特點(diǎn)是邏輯上相鄰的元素在物理存儲位置上也相鄰，因此可以快速地訪問表中的任意元素。

順序表的實(shí)現(xiàn)通常依賴于數(shù)組，數(shù)組是一種靜態(tài)的數(shù)據(jù)結(jié)構(gòu)，一旦創(chuàng)建，其大小就是固定的。這意味著在順序表中插入或刪除元素可能會導(dǎo)致空間的浪費(fèi)或不足。例如，如果在一個已經(jīng)滿了的順序表中插入一個新元素，就需要重新分配更大的數(shù)組空間，并將原有元素復(fù)制到新數(shù)組中，這是一個相對耗時的操作。

然而，順序表在訪問元素時具有很高的效率。由于元素在內(nèi)存中是連續(xù)存儲的，計(jì)算機(jī)可以直接通過計(jì)算偏移量來訪問任意位置的元素，這種訪問方式的時間復(fù)雜度為O(1)。相比之下，鏈表等動態(tài)數(shù)據(jù)結(jié)構(gòu)在訪問元素時可能需要遍歷多個節(jié)點(diǎn)，效率較低。

順序表還支持快速的元素查找。通過索引，我們可以在常數(shù)時間內(nèi)找到表中的任意元素。這種特性使得順序表在處理需要頻繁查找操作的場景時表現(xiàn)出色。

總的來說，順序表是一種高效、簡單的數(shù)據(jù)結(jié)構(gòu)，適用于需要快速訪問和查找元素的場景。然而，它的固定大小特性也限制了其在需要頻繁插入和刪除操作的場景中的應(yīng)用。在實(shí)際應(yīng)用中，我們需要根據(jù)具體的需求和場景來選擇合適的數(shù)據(jù)結(jié)構(gòu)。

---

一、線性表

線性表（linear list）是n個具有相同特性的數(shù)據(jù)元素的有限序列。 線性表是一種在實(shí)際中廣泛使用的數(shù)據(jù)結(jié)構(gòu)，常見的線性表：順序表、鏈表、棧、隊(duì)列、字符串…

線性表在邏輯上是線性結(jié)構(gòu)，也就說是連續(xù)的一條直線。但是在物理結(jié)構(gòu)上并不一定是連續(xù)的，線性表在物理上存儲時，通常以數(shù)組和鏈?zhǔn)浇Y(jié)構(gòu)的形式存儲。

二、順序表

2.1概念及結(jié)構(gòu)

順序表是用一段物理地址連續(xù)的存儲單元依次存儲數(shù)據(jù)元素的線性結(jié)構(gòu)，一般情況下采用數(shù)組存儲。在數(shù)組上完成數(shù)據(jù)的增刪查改。

順序表一般可以分為：

1. 靜態(tài)順序表：使用定長數(shù)組存儲元素。
   
2. 動態(tài)順序表：使用動態(tài)開辟的數(shù)組存儲。
   

2.2 接口實(shí)現(xiàn)

靜態(tài)順序表只適用于確定知道需要存多少數(shù)據(jù)的場景。靜態(tài)順序表的定長數(shù)組導(dǎo)致N定大了，空間開多了浪費(fèi)，開少了不夠用。所以現(xiàn)實(shí)中基本都是使用動態(tài)順序表，根據(jù)需要動態(tài)的分配空間大小，所以下面我們實(shí)現(xiàn)動態(tài)順序表。

typedef int SLDataType;
// 順序表的動態(tài)存儲
typedef struct SeqList
{SLDataType* array;  // 指向動態(tài)開辟的數(shù)組size_t size ;       // 有效數(shù)據(jù)個數(shù)size_t capicity ;   // 容量空間的大小
}SeqList;
// 基本增刪查改接口
// 順序表初始化
void SeqListInit(SeqList* psl);
// 檢查空間，如果滿了，進(jìn)行增容
void CheckCapacity(SeqList* psl);
// 順序表尾插
void SeqListPushBack(SeqList* psl, SLDataType x);
// 順序表尾刪
void SeqListPopBack(SeqList* psl);
// 順序表頭插
void SeqListPushFront(SeqList* psl, SLDataType x);
// 順序表頭刪
void SeqListPopFront(SeqList* psl);
// 順序表查找
int SeqListFind(SeqList* psl, SLDataType x); 
// 順序表在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
// 順序表刪除pos位置的值
void SeqListErase(SeqList* psl, size_t pos);
// 順序表銷毀
void SeqListDestory(SeqList* psl);
// 順序表打印
void SeqListPrint(SeqList* psl);

2.3 數(shù)組相關(guān)面試題

1. 原地移除數(shù)組中所有的元素val，要求時間復(fù)雜度為O(N)，空間復(fù)雜度為O(1)
2. 刪除排序數(shù)組中的重復(fù)項(xiàng)
3. 合并兩個有序數(shù)組

2.4 順序表的問題及思考

問題：

1. 中間/頭部的插入刪除，時間復(fù)雜度為O(N)
2. 增容需要申請新空間，拷貝數(shù)據(jù)，釋放舊空間。會有不小的消耗。
3. 增容一般是呈2倍的增長，勢必會有一定的空間浪費(fèi)。例如當(dāng)前容量為100，滿了以后增容到
   200，我們再繼續(xù)插入了5個數(shù)據(jù)，后面沒有數(shù)據(jù)插入了，那么就浪費(fèi)了95個數(shù)據(jù)空間。

思考：如何解決以上問題呢？

三、順序表具體實(shí)現(xiàn)代碼

順序表的初始化

void SLInit(SL* p);//順序表的初始化

void SLInit(SL* p)
{p->arr = NULL;//動態(tài)開辟數(shù)組的地址置為空指針p->capacity = 0;//數(shù)組容量置為0p->size = 0;//數(shù)組下標(biāo)置為0或-1，具體看你需要哪一種下標(biāo)
}

順序表的初始化是數(shù)據(jù)結(jié)構(gòu)學(xué)習(xí)中不可或缺的一步，它指的是為一個預(yù)先分配了固定大小內(nèi)存空間的線性表分配存儲空間，并設(shè)置其初始狀態(tài)。在順序表中，數(shù)據(jù)元素在內(nèi)存中是連續(xù)存放的，這種存儲方式使得我們可以通過下標(biāo)直接訪問任何位置的元素，從而實(shí)現(xiàn)了快速的元素訪問。

順序表的初始化通常包括分配內(nèi)存空間、設(shè)定初始容量、以及可能的初始化所有元素為某一默認(rèn)值。初始化操作的正確與否直接關(guān)系到后續(xù)數(shù)據(jù)操作的效率與正確性。

以C語言為例，順序表可以用數(shù)組來實(shí)現(xiàn)。在初始化時，我們通常會定義一個結(jié)構(gòu)體來表示順序表，這個結(jié)構(gòu)體包含數(shù)組本身、數(shù)組的大小（即當(dāng)前已存儲的元素?cái)?shù)量）以及數(shù)組的最大容量（即預(yù)先分配的內(nèi)存空間大小）。

順序表的銷毀

void SLDestroy(SL* p);//順序表的銷毀

void SLDestroy(SL* p)
{assert(p);int i = 0; free(p->arr);SLInit(p);
}

在數(shù)據(jù)結(jié)構(gòu)和算法的世界里，順序表作為一種基本的線性表結(jié)構(gòu)，承載著數(shù)據(jù)的存儲和訪問功能。然而，正如任何資源的生命周期一樣，順序表的使用也需要在結(jié)束時進(jìn)行適當(dāng)?shù)匿N毀和清理，以確保內(nèi)存的有效利用和系統(tǒng)的穩(wěn)定運(yùn)行。

順序表的銷毀，主要涉及到內(nèi)存的釋放。當(dāng)一個順序表不再需要使用時，我們必須將其所占用的內(nèi)存空間歸還給操作系統(tǒng)，避免內(nèi)存泄漏。內(nèi)存泄漏是程序運(yùn)行過程中未能正確釋放不再使用的內(nèi)存空間，長時間累積下來會導(dǎo)致可用內(nèi)存空間減少，最終可能導(dǎo)致程序運(yùn)行緩慢甚至崩潰。

銷毀順序表的過程通常包括以下步驟：

1. 遍歷順序表，釋放其中存儲的每一個數(shù)據(jù)元素。如果數(shù)據(jù)元素是指針類型，需要確保這些指針指向的內(nèi)存也被正確釋放。

2. 釋放順序表本身所占用的內(nèi)存空間。這通常通過調(diào)用相應(yīng)的內(nèi)存釋放函數(shù)（如C語言中的free()函數(shù)）來實(shí)現(xiàn)。

3. 將順序表的頭指針或引用設(shè)置為null或nullptr，表示該順序表已經(jīng)不再有效，防止后續(xù)代碼錯誤地訪問或操作已銷毀的順序表。

4. 在某些情況下，可能還需要進(jìn)行額外的清理工作，如關(guān)閉與順序表相關(guān)的文件、釋放其他相關(guān)資源等。

通過以上步驟，我們可以確保順序表在不再使用時能夠被正確地銷毀，從而保持程序的內(nèi)存安全和穩(wěn)定運(yùn)行。在實(shí)際編程中，我們應(yīng)該始終遵循資源管理的最佳實(shí)踐，確保在適當(dāng)?shù)臅r候釋放不再需要的資源，避免內(nèi)存泄漏和其他潛在問題。

順序表的打印

void SLprint(SL p);//順序表的打印

void SLprint(SL p)
{for (int i = 0; i < p.size; i++){printf("%5d", p.arr[i]);}printf("\n");
}

順序表的打印通常指的是將順序表中的所有元素按照一定的格式輸出到控制臺或其他輸出設(shè)備上。這個過程通常涉及到遍歷順序表中的所有元素，并將它們轉(zhuǎn)換為人類可讀的格式。在打印順序表時，我們通常會選擇一種易于閱讀和理解的方式，如按照元素在表中的順序依次打印，或者使用特定的分隔符將不同的元素分隔開。

順序表的增容

void SLCheckCapacity(SL* ps);//順序表的增容

void SLCheckCapacity(SL* p)
{SL* a;assert(p);int Datacapaity = 0;if (p->size == p->capacity){Datacapaity = 0 ? 4 : 2 * p->capacity;//三目運(yùn)算符a = (DataType*)realloc(p->arr, Datacapaity * sizeof(DataType));//使得擴(kuò)容按照2倍增長assert(a);p->arr = a;}p->capacity = Datacapaity;
}

順序表是一種線性數(shù)據(jù)結(jié)構(gòu)，它使用一段連續(xù)的存儲空間來存儲元素。當(dāng)順序表中的元素?cái)?shù)量達(dá)到其當(dāng)前容量上限時，就需要進(jìn)行增容操作，以確?？梢岳^續(xù)添加新的元素。

增容操作的核心思想是為順序表分配更多的連續(xù)存儲空間，并將原有的元素復(fù)制到新的存儲空間中。這通常涉及到兩個主要步驟：分配新的存儲空間和元素遷移。

分配新的存儲空間是增容操作的第一步。順序表會根據(jù)其當(dāng)前容量和擴(kuò)容因子來計(jì)算出新的容量。擴(kuò)容因子是一個大于1的常數(shù)，用于確定每次增容時應(yīng)該增加多少存儲空間。例如，如果擴(kuò)容因子為2，那么每次增容時新的容量將是原容量的兩倍。

在分配了新的存儲空間之后，接下來就是元素遷移的步驟。這一步將順序表中原有的元素從舊的存儲空間復(fù)制到新的存儲空間中。為了保證數(shù)據(jù)的完整性和正確性，復(fù)制過程必須小心謹(jǐn)慎地進(jìn)行。通常，復(fù)制過程會從順序表的第一個元素開始，逐個復(fù)制到新的存儲空間的相應(yīng)位置，直到所有元素都被復(fù)制完畢。

完成元素遷移后，順序表就可以繼續(xù)使用新的存儲空間來存儲新的元素了。同時，順序表的容量上限也得到了提升，可以容納更多的元素。

需要注意的是，增容操作雖然可以擴(kuò)展順序表的容量，但也會帶來一定的性能開銷。因?yàn)槊看卧鋈荻夹枰峙湫碌拇鎯臻g并進(jìn)行元素遷移，這些操作都需要消耗一定的時間和資源。因此，在設(shè)計(jì)和實(shí)現(xiàn)順序表時，需要權(quán)衡擴(kuò)容的時機(jī)和頻率，以避免頻繁的增容操作對性能產(chǎn)生負(fù)面影響。

為了優(yōu)化性能，可以在順序表的使用過程中采取一些策略來減少增容的次數(shù)。例如，可以在添加元素之前先檢查順序表的容量是否足夠，如果不足夠則提前進(jìn)行增容操作，以避免在添加元素時觸發(fā)頻繁的增容。此外，還可以根據(jù)實(shí)際應(yīng)用場景和數(shù)據(jù)特點(diǎn)來選擇合適的擴(kuò)容因子，以平衡存儲空間的利用率和增容操作的開銷。

順序表的頭部/尾部插入

//順序表的頭部/尾部插入
void SLPushBack(SL* p, DataType x);
void SLPushFront(SL* p, DataType x);

void SLPushBack(SL* p, DataType x)//順序表的尾插
{assert(p);SLCheckCapacity(p);//增容p->arr[p->size++] = x;
}void SLPushFront(SL* p, DataType x)//順序表的頭插
{assert(p);SLCheckCapacity(p);//增容for (int i = p->size; i > 0; i--){p->arr[i] = p->arr[i - 1];}p->arr[0] = x;p->size++;
}

順序表的頭部/尾部插入是順序表操作中的基本功能，它們直接影響了順序表的數(shù)據(jù)存儲和訪問效率。順序表，又稱數(shù)組列表，是一種線性表的數(shù)據(jù)結(jié)構(gòu)，其特點(diǎn)是元素在內(nèi)存中是連續(xù)存儲的。這種存儲方式使得順序表在訪問元素時具有很高的效率，因?yàn)榭梢酝ㄟ^下標(biāo)直接定位到元素的位置。然而，在插入或刪除元素時，順序表的表現(xiàn)就不如鏈表等其他數(shù)據(jù)結(jié)構(gòu)了。

在順序表的頭部插入元素時，需要將所有已存在的元素向后移動一位，以騰出空間給新插入的元素。這種操作的時間復(fù)雜度是O(n)，其中n是順序表的長度。因此，對于頻繁在頭部插入元素的場景，順序表并不是最優(yōu)的數(shù)據(jù)結(jié)構(gòu)選擇。

相比之下，在順序表的尾部插入元素則相對高效。因?yàn)槲膊渴琼樞虮淼囊粋€“開放”端，新元素可以直接添加到這個位置，而不需要移動其他元素。這種操作的時間復(fù)雜度是O(1)，即常數(shù)時間復(fù)雜度，意味著無論順序表有多大，尾部插入的效率都是相同的。

在實(shí)際應(yīng)用中，順序表的頭部/尾部插入操作常常用于實(shí)現(xiàn)各種算法和數(shù)據(jù)結(jié)構(gòu)。例如，在某些需要動態(tài)維護(hù)數(shù)據(jù)集合的場景中，我們可以使用順序表來存儲數(shù)據(jù)，并根據(jù)需要在頭部或尾部進(jìn)行插入操作。此外，順序表還可以用于實(shí)現(xiàn)棧（Stack）和隊(duì)列（Queue）等數(shù)據(jù)結(jié)構(gòu)，其中棧通常使用順序表的頭部進(jìn)行插入和刪除操作，而隊(duì)列則使用頭部進(jìn)行刪除操作，使用尾部進(jìn)行插入操作。

需要注意的是，雖然順序表在訪問元素時具有很高的效率，但在插入和刪除元素時可能會遇到性能瓶頸。因此，在選擇數(shù)據(jù)結(jié)構(gòu)時，我們需要根據(jù)具體的應(yīng)用場景和需求來權(quán)衡各種因素，以選擇最適合的數(shù)據(jù)結(jié)構(gòu)。

順序表的頭部/尾部刪除

//順序表的頭部/尾部刪除
void SLPopBack(SL* p);
void SLPopFront(SL* p);

void SLPopBack(SL* p)
{assert(p);assert(p->size);p->size--;
}
void SLPopFront(SL* p)
{assert(p);assert(p->size);for (int i = 0; i < p->size - 1; i++){p->arr[i] = p->arr[i + 1];}p->size--;
}

順序表的頭部/尾部刪除是數(shù)據(jù)結(jié)構(gòu)中常見的操作，它們分別涉及到對順序表的首個元素和最后一個元素的移除。這兩種操作在多種應(yīng)用場景中都具有重要的意義，比如緩存管理、消息隊(duì)列、數(shù)據(jù)庫索引等。

在順序表（數(shù)組）中實(shí)現(xiàn)頭部刪除操作，通常需要將數(shù)組中的所有元素向前移動一位，以填補(bǔ)被刪除元素的位置。這種操作的時間復(fù)雜度為O(n)，其中n為數(shù)組的長度。如果順序表是動態(tài)分配的，并且有足夠的空間，也可以采用標(biāo)記刪除的方式，即簡單地將頭部元素標(biāo)記為已刪除，而不實(shí)際移動其他元素。但這種方法需要額外的邏輯來跟蹤哪些元素是已刪除的，因此可能會增加空間和時間上的開銷。

相比之下，尾部刪除操作通常更為簡單和高效。在順序表中，尾部元素總是位于數(shù)組的最后一個位置，因此刪除它不需要移動其他元素。只需將數(shù)組的最后一個元素的位置標(biāo)記為未使用，或者如果使用的是動態(tài)數(shù)組，可以減少其容量以釋放未使用的空間。這種操作的時間復(fù)雜度通常為O(1)。

然而，需要注意的是，雖然尾部刪除在單個操作上可能更快，但在頻繁進(jìn)行頭部刪除的情況下，順序表可能不是最優(yōu)的數(shù)據(jù)結(jié)構(gòu)選擇。在這種情況下，使用鏈表可能更為合適，因?yàn)殒湵碓陬^部和尾部刪除操作上的時間復(fù)雜度都是O(1)。

指定位置之前插入數(shù)據(jù)和刪除指定位置數(shù)據(jù)

//指定位置之前插入數(shù)據(jù)
//刪除指定位置數(shù)據(jù)
void SLInsert(SL* p, int pos, DataType x);
void SLErase(SL* p, int pos);

void SLInsert(SL* p, int pos, DataType x)
{assert(p);assert(pos>=0 && pos <= p->size);SLCheckCapacity(p);for (int i = p->size; i >= pos; i--){p->arr[i] = p->arr[i - 1];}p->arr[pos] = x;p->size++;
}
void SLErase(SL* p, int pos)
{assert(p);assert(pos >= 0 && pos <= p->size);for (int i = pos - 1; i < p->size; i++){p->arr[i] = p->arr[i + 1];}p->size--;
}

指定位置之前插入數(shù)據(jù)和刪除指定位置數(shù)據(jù)是編程中常見的操作，尤其在處理列表、數(shù)組、字符串等數(shù)據(jù)結(jié)構(gòu)時。這些操作不僅對于數(shù)據(jù)的管理和維護(hù)至關(guān)重要，而且在很多算法和程序設(shè)計(jì)中也扮演著重要角色。

在插入數(shù)據(jù)時，我們通常需要考慮以下幾個因素：插入的位置、要插入的數(shù)據(jù)以及插入后數(shù)據(jù)結(jié)構(gòu)的完整性。

在刪除指定位置的數(shù)據(jù)時，我們需要確保刪除操作不會破壞數(shù)據(jù)結(jié)構(gòu)的其余部分。
需要注意的是，在進(jìn)行插入和刪除操作時，我們需要確保索引的有效性。如果索引超出數(shù)據(jù)結(jié)構(gòu)的范圍，那么程序會拋出異常。因此，在實(shí)際編程中，我們通常需要在進(jìn)行這些操作之前先檢查索引的有效性。

此外，插入和刪除操作的時間復(fù)雜度也是我們需要考慮的因素。在大多數(shù)數(shù)據(jù)結(jié)構(gòu)中，插入和刪除操作的時間復(fù)雜度都是O(n)，其中n是數(shù)據(jù)結(jié)構(gòu)的長度。這意味著，隨著數(shù)據(jù)結(jié)構(gòu)的增長，這些操作所需的時間也會增加。因此，在選擇數(shù)據(jù)結(jié)構(gòu)時，我們需要根據(jù)實(shí)際需求來權(quán)衡各種因素，包括插入和刪除操作的頻率、數(shù)據(jù)結(jié)構(gòu)的長度以及所需的空間等。

總的來說，指定位置之前插入數(shù)據(jù)和刪除指定位置數(shù)據(jù)是編程中常見的操作，我們需要熟練掌握這些操作的方法和技巧，以便在實(shí)際編程中能夠靈活應(yīng)用。同時，我們還需要注意操作的有效性和時間復(fù)雜度等問題，以確保程序的正確性和效率。

順序表元素的查找

//順序表元素的查找
int SLFind(SL p, DataType x);

int SLFind(SL* p, DataType x)
{assert(p);for (int i = 0; i < p->size; i++){if (p->arr[i] == x)return i + 1;}return -1;
}

順序表元素的查找是計(jì)算機(jī)科學(xué)中的一個基本問題，它涉及到在一個有序或無序的列表中查找特定的元素。在各種實(shí)際應(yīng)用中，如數(shù)據(jù)庫管理、搜索引擎、編程語言中的數(shù)據(jù)結(jié)構(gòu)等，順序表元素的查找都扮演著重要的角色。

對于順序表元素的查找，最基礎(chǔ)的算法是線性查找。線性查找的思想是從表的第一個元素開始，逐個比較每個元素，直到找到目標(biāo)元素或遍歷完整個表。這種查找方法的時間復(fù)雜度為O(n)，其中n為表的長度。雖然線性查找簡單易懂，但在處理大數(shù)據(jù)量時，其效率往往不能滿足要求。

為了提高查找效率，人們設(shè)計(jì)了更為高效的查找算法，如二分查找。二分查找只適用于有序的順序表，其基本思想是將表分為兩半，通過比較目標(biāo)元素與中間元素的大小，決定在哪一半繼續(xù)查找，如此反復(fù)，直到找到目標(biāo)元素或確定目標(biāo)元素不存在于表中。二分查找的時間復(fù)雜度為O(log n)，在數(shù)據(jù)量較大時，其效率遠(yuǎn)高于線性查找。

除了二分查找，還有一些其他的查找算法，如插值查找和斐波那契查找等。插值查找是對二分查找的一種改進(jìn)，它根據(jù)目標(biāo)元素在表中的大致位置，選擇一個更接近于目標(biāo)元素的中間元素進(jìn)行比較，從而減少比較次數(shù)。斐波那契查找則是利用斐波那契數(shù)列的性質(zhì)，通過計(jì)算斐波那契數(shù)來確定查找范圍，進(jìn)一步提高查找效率。

在實(shí)際應(yīng)用中，選擇哪種查找算法取決于具體的需求和場景。對于有序的順序表，二分查找、插值查找和斐波那契查找等高效算法是更好的選擇；而對于無序的順序表，線性查找可能是唯一可行的選擇。此外，還可以根據(jù)表的大小、元素的分布等因素來選擇合適的查找算法。

四、順序表完整代碼

text.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int DataType;靜態(tài)順序表
//typedef struct Seqlist
//{
//	DataType data[10];
//	int size;
//}Seqlist;//動態(tài)順序表
typedef struct Seqlist
{DataType* arr;int size;int capacity;
}SL;void SLCheckCapacity(SL* ps);//順序表的增容void SLInit(SL* p);//順序表的初始化
void SLDestroy(SL* p);//順序表的銷毀
void SLprint(SL p);//順序表的打印//順序表的頭部/尾部插入
void SLPushBack(SL* p, DataType x);
void SLPushFront(SL* p, DataType x);//順序表的頭部/尾部刪除
void SLPopBack(SL* p);
void SLPopFront(SL* p);//指定位置之前插入數(shù)據(jù)
//刪除指定位置數(shù)據(jù)
void SLInsert(SL* p, int pos, DataType x);
void SLErase(SL* p, int pos);
int SLFind(SL p, DataType x);

text.c

#include"text.h"
void SLCheckCapacity(SL* p)
{SL* a;assert(p);int Datacapaity = 0;if (p->size == p->capacity){Datacapaity = 0 ? 4 : 2 * p->capacity;a = (DataType*)realloc(p->arr, Datacapaity * sizeof(DataType));assert(a);p->arr = a;}p->capacity = Datacapaity;
}void SLInit(SL* p)
{p->arr = NULL;p->capacity = 0;p->size = 0;
}
void SLDestroy(SL* p)
{int i = 0; for (i = 0; i < p->size; i++){free(p->arr[i]);}SLInit(p);
}
void SLprint(SL p)
{for (int i = 0; i < p.size; i++){printf("%5d", p.arr[i]);}printf("\n");
}void SLPushBack(SL* p, DataType x)
{assert(p);SLCheckCapacity(p);p->arr[p->size++] = x;
}void SLPushFront(SL* p, DataType x)
{assert(p);SLCheckCapacity(p);for (int i = p->size; i > 0; i--){p->arr[i] = p->arr[i - 1];}p->arr[0] = x;p->size++;
}void SLPopBack(SL* p)
{assert(p);assert(p->size);p->size--;
}
void SLPopFront(SL* p)
{assert(p);assert(p->size);for (int i = 0; i < p->size - 1; i++){p->arr[i] = p->arr[i + 1];}p->size--;
}void SLInsert(SL* p, int pos, DataType x)
{assert(p);assert(pos>=0 && pos <= p->size);SLCheckCapacity(p);for (int i = p->size; i >= pos; i--){p->arr[i] = p->arr[i - 1];}p->arr[pos] = x;p->size++;
}
void SLErase(SL* p, int pos)
{assert(p);assert(pos >= 0 && pos <= p->size);for (int i = pos - 1; i < p->size; i++){p->arr[i] = p->arr[i + 1];}p->size--;
}int SLFind(SL* p, DataType x)
{assert(p);for (int i = 0; i < p->size; i++){if (p->arr[i] == x)return i + 1;}return -1;
}

main.c

#include"text.h"void slTest01() {SL sl;SLInit(&sl);SLPushBack(&sl, 1);SLPushBack(&sl, 2);SLPushBack(&sl, 3);SLPushBack(&sl, 4);SLprint(sl);      //1 2 3 4SLPushBack(&sl, 5);SLprint(sl);SLPushFront(&sl, 5);SLPushFront(&sl, 6);SLPushFront(&sl, 7);SLprint(sl);       //7 6 5 1 2 3 4SLPopBack(&sl);SLPopBack(&sl);SLPopBack(&sl);SLPopBack(&sl);SLprint(sl);   //1 2SLPopFront(&sl);SLPopFront(&sl);SLPopFront(&sl);//SLPopFront(&sl);SLprint(sl);   //3 4//SLInsert(&sl, 0, 100);//SLprint(sl); //100 1 2 3 4//SLInsert(&sl, sl.size, 200);//SLprint(sl); //100 1 2 3 4 200//SLInsert(&sl, 100, 300);//SLprint(sl);//SLErase(&sl, 0);//SLprint(sl);  //2 3 4//SLErase(&sl, sl.size - 1);//SLErase(&sl, 1);//SLprint(sl);//1 3 4
}int main()
{slTest01();return 0;
}

---