線性表之順序表
線性表
線性表（linear list）是n個具有相同特性的資料元素的有限序列。 線性表是一種在實際中廣泛使用的資料結構，常見的線性表：順序表、連結串列、棧、佇列、字串...
線性表在邏輯上是線性結構，也就說是連續的一條直線。但是在物理結構上（也就是在記憶體上的排列）並不一定是連續的，線性表在記憶體中的結構通常以陣列和鏈式結構的形式儲存。
順序表
順序表是一段在記憶體上實體地址連續的線性表，也就是說，它是邏輯、物理上都連續的，通常情況下，以陣列形式儲存，然後後續操作就在陣列上進行增刪改查；順序表根據它的建立方式分為：
①靜態順序表：使用定長的陣列儲存；
// 順序表的靜態儲存//使用巨集來表示定長陣列的大小 #define N 100 //使用typedef來重新命名資料型別，如果後續順序表中儲存的資料型別需要改變，那麼只需修改這裡的資料型別即可，很方便 typedef int SLDataType; typedef struct SeqList { SLDataType array[N]; // 定長陣列 size_t size; // 有效資料的個數 }SeqList;
靜態順序表只適用於確定資料多少的情況下，否則不好確定定長陣列的大小，建立大了浪費空間，建立小了不夠用，所以一般實際開發中不經常用，我們更多的是使用動態順序表，下面就重點來實現一下動態順序表。
②動態順序表：使用動態開闢的陣列儲存；
// 順序表的動態儲存 //使用typedef來重新命名資料型別，如果後續順序表中儲存的資料型別需要改變，那麼只需修改這裡的資料型別即可，很方便 typedef int SLDataType; typedef struct SeqList { SLDataType* array; // 指向動態開闢的陣列 size_t size ; // 有效資料個數 size_t capicity ; // 容量空間的大小 }SeqList;
動態順序表可以在資料進行輸入的過程中，如果發現空間滿了，那麼我們可以進行動態的申請空間，而不是放棄原來的表，重新建立新的順序表，這是非常人性化的一件事；
實現介面
當我們將順序表創建出來後，拿給使用者使用時，我們是不需要讓使用者明白到底是如何向裡面輸入資料、如何拿出資料等等的原理的，我們只需要提供一個介面，而使用者只需將一個數據放到介面中，那麼就完成了一個操作，這會給使用者帶來極大的方便；
那麼下面我就來實現一下各種介面，需要注意的是，介面的函式名一般是有預設形式，也就是說這個藉口實現什麼樣的功能，那它的名字最好寫的規範些，方便別人的使用；
//這是 .h 部分的檔案 #pragma once //使用這種方式來重新命名資料型別，這樣可以很方便的修改後續資料的資料型別，相當於#define的作用 typedef int SeqListType; //動態建立順序表 typedef struct SeqList { //使用指標指向一塊動態開闢的記憶體 SeqListType* _date; //表示順序表中的有效資料 size_t _size; //表示順序表的最大容量 size_t _capacity; }SeqList; //包含所有函式的宣告 //順序表初始化 void SeqListInit(SeqList* s1); //順序表銷燬 void SeqListDestroy(SeqList* s1); //檢查順序表是否已滿 void CheckCapacity(SeqList* s1); //順序表尾插 void SeqListPushBack(SeqList* s1, SeqListType val); //順序表尾刪 void SeqListPopBack(SeqList* s1); //順序表頭插 void SeqListPushFront(SeqList* s1, SeqListType val); //順序表頭刪 void SeqListPopFront(SeqList* s1); //順序表任意插 void SeqListInsert(SeqList* s1, int pos, SeqListType val); //順序表任意刪 void SeqListErase(SeqList* s1, int pos); //列印順序表 void SeqListPrint(SeqList* s1); //順序表判空 int SeqListEmpty(SeqList* s1); //順序表大小 int SeqListSize(SeqList* s1); //順序表查詢下標 int SeqListFindIdx(SeqList* s1, SeqListType val); //順序表下標對應元素 SeqListType SeqListGetIdx(SeqList* s1, int pos);
//這是 .c 部分的程式碼 #include<stdio.h> #include<stdlib.h> #include<string.h> #include"SQList.h" //順序表初始化 void SeqListInit(SeqList* s1) { s1->_date = NULL; s1->_size = s1->_capacity = 0; } //順序表銷燬 void SeqListDestroy(SeqList* s1) { //引數合法性檢驗,是空就不用釋放了 if (s1 == NULL||s1->_date == NULL) { return; } free(s1->_date); s1->_date = NULL; } //檢查順序表是否已滿 void CheckCapacity(SeqList* s1) { //引數合法性檢驗 if (s1 == NULL) { return; } if (s1->_capacity == s1->_size) { //由於一開始容量為0，不好進行相乘運算，所以先增加1 s1->_capacity = s1->_capacity == 0 ? 1 : s1->_capacity; //每次以二倍的容量增加 SeqListType* temp = (SeqListType*)malloc(sizeof(SeqListType) * 2 * s1->_capacity); //使用memcpy函式來進行將舊空間的資料拷貝到新空間 memcpy(temp, s1->_date, sizeof(SeqListType) * s1->_size); //釋放掉舊空間 free(s1->_date); //更新變數 s1->_capacity = 2 * s1->_capacity; s1->_date = temp; temp = NULL; } } //順序表尾插 void SeqListPushBack(SeqList* s1, SeqListType num) { //引數合法性檢驗 if (s1 == NULL) { return; } //在插入資料之前應該檢查是否滿了 CheckCapacity(s1); s1->_date[s1->_size] = num; ++s1->_size; } //順序表尾刪 void SeqListPopBack(SeqList* s1) { //引數合法性檢驗 if (s1 == NULL||s1->_size == 0) { return; } --s1->_size; } //順序表頭插 void SeqListPushFront(SeqList* s1, SeqListType val) { //引數合法性檢驗 if (s1 == NULL) { return; } CheckCapacity(s1); int end = s1->_size; while (end > 0) { s1->_date[end] = s1->_date[end - 1]; --end; } s1->_date[0] = val; ++s1->_size; } //順序表頭刪 void SeqListPopFront(SeqList* s1) { //引數合法性檢驗 if (s1 == NULL||s1->_size == 0) { return; } int start = 1; while (start < s1->_size) { s1->_date[start - 1] = s1->_date[start]; ++start; } --s1->_size; } //順序表任意插 void SeqListInsert(SeqList* s1, int pos, SeqListType val) { //引數合法性檢驗 if (s1 == NULL) { return; } CheckCapacity(s1); int end = s1->_size; while (end > pos) { s1->_date[end] = s1->_date[end - 1]; --end; } s1->_date[pos] = val; ++s1->_size; } //順序表任意刪 void SeqListErase(SeqList* s1, int pos) { //引數合法性檢驗 if (s1 == NULL || s1->_size == 0) { return; } ++pos; while (pos < s1->_size) { s1->_date[pos - 1] = s1->_date[pos]; ++pos; } --s1->_size; } //列印順序表 void SeqListPrint(SeqList* s1) { //引數合法性檢驗 if (s1 == NULL || s1->_size == 0) { return; } for (int i = 0; i < s1->_size; ++i) { printf("%d ", s1->_date[i]); }printf("\n"); } //順序表判空 int SeqListEmpty(SeqList* s1) { if (s1 == NULL || s1->_size == 0) { return 0; } return 1; } //順序表大小 int SeqListSize(SeqList* s1) { if (s1 == NULL) { return 0; } return s1->_size; } //順序表查詢下標,這個模組程式碼不完善 //因為一個順序表中重複的數字很多,所以我們應該返回一個數組，裡面包含的val出現的所有位置 //但是實現起來較麻煩，所以不在此展示 int SeqListFindIdx(SeqList* s1, SeqListType val) { if (s1 == NULL||s1->_size == 0) { return -1; } for (int i = 0; i < s1->_size; ++i) { if (s1->_date[i] == val) { return i; } } return -1; } //順序表下標對應元素 SeqListType SeqListGetIdx(SeqList* s1, int pos) { //此模組無法進行判空，因為如果為空，那麼該返回什麼值呢？ //返回的值都有可能是順序表中的某一個值，所以此模組預設已經進行判空 return s1->_date[pos]; } int main() { SeqList s1; SeqListInit(&s1); return 0; }
以上就是對順序表各種操作的介面實現，在上面的程式碼中，對每一個功能都進行了函式封裝，這有利於後期對程式碼的維護；而且在上面的程式碼中，對資料的頭插頭刪，尾插尾刪，其實是可以通過對在任意位置插入刪除函式呼叫，這樣使得程式碼複用性高，也是便於後期維護。
順序表優缺點
優點：①空間連續，支援隨機訪問；
②尾插、尾刪效率高，時間複雜度O(1)；
③空間利用率高，不容易產生記憶體碎片，因為每次開闢空間都是開闢較大的空間，當你不用時，別人仍可以用；
④實現簡單，邏輯思路不復雜；
缺點：①在除過尾部的其他地方，插入、刪除元素時間複雜度都為O(N)，效率低；
②增容時，很有可能需要另開闢一片空間，然後將資料搬運過去，然後釋放掉原有空間，開銷大；
注：在我寫的程式碼中，每一次增容時都需要另開闢空間、搬運資料、釋放原有空間，是因為我實現的方式比較繁瑣，但是是為了更清楚的邏輯思路；除過我寫的這種方式，其實還可以用realloc函式，將開闢新空間、搬運資料、釋放原有空間合為一體，十分方便，當記憶體空間足夠時，是直接在原有空間後面在開闢連續的空間，省去資料搬運、釋放空間的步驟。
陣列相關面試題：（對於順序表的各種操作，其實無非就是對陣列的操作）
①原地移除陣列nums中所有等於val的元素，並返回陣列的新長度，元素順序可變，不需考慮陣列中超出新長度後面的元素。要求空間複雜度為O(1)。例如：nums=[3,2,2,3],val=3;返回長度為2，且nums中的前兩個元素均為2。(leetcode,27)
int removeElement(int* nums, int numsSize, int val) { int size = 0; for (int i = 0; i < numsSize; i++) { if (nums[i] != val) { nums[size] = nums[i]; size++; } } return size; }
②原地刪除排序陣列的重複項，返回移除後的陣列長度。要求空間複雜度O(1)。例如：給定nums=[1,1,2]，返回長度為2，並且nums中前兩個元素修改為1,2。(leetcode,26)
int removeDuplicates(int* nums, int numsSize) { int idx = 1; int flag = nums[0]; int count = 1; for (int i = 1; i < numsSize; i++) { if (flag != nums[i]) { nums[idx++] = nums[i]; flag = nums[i]; count++; } } return count; }
③兩個有序陣列nums1、nums2，陣列元素個數為m、n，將nums2合併到nums1中，使nums1成為有序陣列,假設nums1有足夠的空間。例如：nums1=[1,2,3]、m=3，nums2=[2,5,6]、n=3，輸出nums1=[1,2,2,3,5,6]。(leetcode,88)
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) { int count = m + n-1; m--,n--; while (m >= 0 || n >= 0) { if (nums1[m] < nums2[n]) { nums1[count] = nums2[n]; count--; n--; } else { nums1[count] = nums1[m]; count--; m--; } } }
④給定一個數組，右旋k位，k為非負數。例如：nums=[1,2,3,4,5,6,7]、k=3，輸出nums=[5,6,7,1,2,3,4]。(leetcode,189)
void swap(int* nums,int start,int end) { for (; start < end; start++, end--) { int temp = 0; temp = nums[start]; nums[start] = nums[end]; nums[end] = temp; } } void removeDuplicates(int* nums, int numsSize,int k) { swap(nums, 0, numsSize - k - 1); swap(nums, numsSize - k, numsSize - 1); swap(nums, 0, numsSize-1); }
⑤對於非負整數X，有陣列A是按照X從左到右每一位的順序組成的陣列，給定陣列A，再給一個整數K，返回X+K的陣列形式。例如：X=1231,A=[1,2,3,1],K=34,返回1265的陣列形式nums=[1,2,5,6]。(leetcode,989)
int* addToArrayForm(int* A, int ASize, int K, int* returnSize) { if (K == 0) { *returnSize = ASize; return A; } int count = (log10(K) + 1) > ASize ? (log10(K) + 2) : ASize + 1; *returnSize = count; int* ret = (int*)calloc(count, sizeof(int)); if (ret == NULL) return NULL; while ( K > 0) { if (--ASize >= 0) K = A[ASize] + K; ret[--count] = K % 10; K /= 10; } if (ret[0] == 0) { ret[--count] = K; (*returnSize)--; return ++ret; } else return ret; }