# Lucky to be appreciated by the rich, how can the sequence table not be

# Sequence table

## Linear table

A linear list is a finite sequence of n data elements with the same characteristics. Linear table is a data structure widely used in practice. Common linear tables: sequential table, linked list, stack, queue, string

A linear table is logically a linear structure, that is, a continuous straight line. However, the physical structure is not necessarily continuous. When the linear table is stored physically, it is usually stored in the form of array and chain structure.

But today's blog only talks about the sequence table

## Sequential table (essentially array)

### Concept and structure

Sequential table is a linear structure in which data elements are stored in sequence with a storage unit with continuous physical addresses. Generally, array storage is used. Complete the addition, deletion, query and modification of data on the array.

### The sequence table can generally be divided into:

#### 1. Static sequence table: use fixed length array to store elements.

#pragma once //It is convenient to change the size of the array #define N 100 typedef int SLDataType; //This will be easy to modify //Static sequence table typedef struct SeqList { SLDataType a[N]; SLDataType size;//Indicates how many data are stored in the array }SL; void SeqListPushBack(SL* ps, SLDataType x);

The static feature is not to allow insertion when it is full. The disadvantage is that we don't know how much space is appropriate, waste when it is large and "crime" when it is small, so there is a dynamic sequence table

#### 2. Dynamic sequence table: use dynamic array storage.

Since they are all dynamic, there is no need for the space size N. We can use the pointer

//It is convenient to change the size of the array //#define N 100 typedef int SLDataType; //This will be easy to modify //Dynamic sequence table typedef struct SeqList { SLDataType* a; int size;//Indicates how many data are stored in the array int capacity;//How much space can the array actually hold data }SL; void SeqListPushBack(SL* ps, SLDataType x);

#### Interface function (here I teach you to close the pit, otherwise sometimes you don't know how to die (the difference between value transfer and address transfer))

##### Sequence table initialization SeqListInit

###### pass by value

A caveat here is that vs13 is different from vs19. vs13 can run without initialization, while vs19sl can't run without initialization. I'll put the figure below

###### Address transfer

Since the of the argument cannot be passed to the formal parameter, we will pass the address

//Sequence table initialization void SeqListInit(SL* ps) { ps->a = NULL; ps->size = ps->capacity = 0; }

#### Tail interpolation function SeqListPushBack

//Tail insertion void SeqListPushBack(SL* ps, SLDataType x) { if (ps->size == ps->capacity) { //There's no room at all //Capacity expansion when the space is full int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2; SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType)); if (tmp == NULL) { printf("Development failure\n");//Failed to open up successfully exit(-1);//Abnormal end } //After successful capacity expansion ps->a = tmp;//Give him the new address ps->capacity = newcapacity;//Give him the capacity } //Enough space ps->a[ps->size] = x; ps->size++; }

But sometimes it's a waste of time to debug to see how our interface is written, so we have to write a print function

#### Sequence table printing function SeqListPrint

//Sequence table printing void seqListPrint(SL* ps) { int i = 0; for (i = 0; i < ps->size; i++) { printf("%d ", ps->a[i]); } printf("\n"); }

We can basically see this step as a successful start of the sequence table. Now we need to destroy the sequence table. In fact, we know that the last is the destruction of the sequence table, but we can realize it here (you can understand it as the smallest system of single chip microcomputer or the version of micro star)

#### Sequence table destruction function seqlistdestroy

//Sequence table destruction void seqListDestory(SL* ps)//Is to free memory and prevent memory overflow { free(ps->a); ps->a = NULL; ps->capacity = ps->size = 0; }

When the minimum system board is ready, we will add modules one by one

#### Tail deletion function SeqListPopBack

tender

//Tail deletion void SeqListPopBack(SL* ps) { //Gentle approach if (ps->size > 0) { ps->size--; } }

Rough (I, a big man, prefer to be rough and straightforward)

//Tail deletion void SeqListPopBack(SL* ps) { Gentle approach //if (ps->size > 0) //{ // ps->size--; //} //Rough assert(ps->size > 0);//It doesn't matter if you assert that it's not true and report an error directly ps->size--; }

Before writing the header insert, let's think about it. If you want to insert, you must consider whether you need to expand the capacity. Then it is heavier than the expansion in the previous tail insert, so you can extract it and write a function separately

#### Sequence table check capacity function SeqListCheckCapacity

//Sequence table check capacity void SeqListCheckCapacity(SL* ps) { if (ps->size == ps->capacity) { //There's no room at all //Capacity expansion when the space is full int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2; SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType)); if (tmp == NULL) { printf("Development failure\n");//Failed to open up successfully exit(-1);//Abnormal end } //After successful capacity expansion ps->a = tmp;//Give him the new address ps->capacity = newcapacity;//Give him the capacity } }

Then you can easily expand the capacity by checking the capacity with that

#### Header insertion function SeqListPushFront

//Head insert void SeqListPushFront(SL* ps, SLDataType x) { //Check capacity increase SeqListCheckCapacity(ps); //Mobile data int end = ps->size - 1; while (end>=0) { ps->a[end + 1] = ps->a[end]; end--; } ps->a[0] = x; ps->size++; }

#### Header delete SeqListPopFront

//Header deletion void SeqListPopFront(SL* ps) { assert(ps->size>0); int begin = 1; while (begin<ps->size) { ps->a[begin-1] = ps->a[begin]; begin++; } ps->size--; }

#### Sequence table lookup function SeqListFind

//Sequential table lookup function int SeqListFind(SL* ps, SLDataType x) { int i = 0; for (i = 0; i < ps->size; i++) { if (ps->a[i] == x) return i; } return -1; }

#### Sequential table insert function SeqListInsert

//Sequential table insert function void SeqListInsert(SL* ps, int pos, SLDataType x) { //Assertion does not end directly in scope assert(pos>=0 && pos<=ps->size); //Check expansion SeqListCheckCapacity(ps); //Mobile data int end = ps->size - 1; while (pos<=end) { ps->a[end + 1] = ps->a[end]; end--; } //Then give the data to the current location ps->a[pos] = x; ps->size++; }

Therefore, there is no need to write the head insert and tail insert. You can call the insert function directly

#### Sequence table delete function SeqListErase

//Sequential table deletion function void SeqListErase(SL* ps, int pos) { //Assertion does not end directly in scope assert(pos >= 0 && pos < ps->size); //When deleting, you do not need to consider capacity expansion, but directly move the data int begin = pos; while (begin+1<ps->size) { ps->a[begin] = ps->a[begin + 1]; begin++; } ps->size--; }

Therefore, header deletion and tail deletion can be reused

## Exercises

### Example 1 Removing Elements

Let's analyze the problem first. He has requirements for space complexity and no requirements for time complexity

int removeElement(int* nums, int numsSize, int val){ int i = 0; int* cur = nums; for(i = 0;i<numsSize;i++) { if(val ^ nums[i]) { *cur++ = nums[i]; } } return cur-nums; }

### Example 2 Remove duplicates from an ordered array

We can't look at it empty. We have to draw a picture to solve it. The problem directly determines the space. It won't give you an additional array, so we can only solve it with multiple pointers

Brain simulation, a positioning pointer, two cursor pointers, should be able to solve

int removeDuplicates(int* nums, int numsSize){ if(numsSize == 0)//Empty array jump out return 0; int* cur = nums;//Positioning pointer int* head = nums;//Swim header pointer int* tail = nums+1;//Cursor tail pointer while(tail<nums+numsSize) { if(*head == *tail) { tail++; } else { *cur = *head; cur++; head = tail; tail++; } } *cur = *head;//The last one is forced to be assigned regardless of equality cur++; return (cur-nums); }

### Example 3 Merge two ordered arrays

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){ int* p1 = nums1+m-1; int* p2 = nums2+n-1; int* cur = nums1+m+n-1; while(p1>=nums1 && p2>=nums2) { *cur-- = *p1>*p2 ? *p1-- : *p2--;//ternary operator } while(p2>=nums2) { *cur-- = *p2--; } }