# Abstract data description of linear table:

### Type name: linear table (List)

### Data object: a linear table is an ordered sequence of n (> = 0) elements (a1, a2, a3,... An)

### Operation set: linear table L ∈ List, integer i represents position, and element X ∈ ElementType. The basic operations of linear table mainly include:

- 1 List MakeEmpty(): initializes an empty linear table L;
- 2 ElementType findkth (int K, list L): returns corresponding elements according to bit order K;
- 3 int Find(ElementType X, List L): find the first occurrence position of X in the linear table L;
- 4 void Insert(ElementType X, int i, List L): insert a new element X before bit order I;
- 5 void Delete(int i, LIst L): delete the elements of the location order I;
- 6 int Length(List L): returns the length n of linear table L;

# Sequential storage implementation of linear table:

#### Use the continuous storage space of the array to store the elements of the linear table in sequence

typedef struct LNode *List; struct LNode { ElementType Data[MAXSIZE]; int Last; }; struct LNode L; List PtrL;

## Implementation of main operations:

### 1. Initialization (create an empty sequence table)

#### The code is as follows:

List MakeEmpty() { List PtrL; PtrL = (List)malloc(sizeof(struct LNode)); PtrL->Last = -1; return PtrL; }

### 2. Find

#### The code is as follows:

int Find(ElementType X, List PtrL) { int i = 0; while (i <= PtrL->Last && PtrL->Data[i] != X) { i++; } if (i > PtrL->Last) return -1; else return i; }

## Insert (insert a new element with value X at position I (1 < = I < = n + 1))-Pay attention to the following move first!!!

### 3. Insert operation implementation

#### The code is as follows:

void Insert(ElementType X, int i, List PtrL) { // Note that the i passed in is a position, not an array subscript int j; if (PtrL->Last == MAXSIZE-1) //The tablespace is full and cannot be inserted { printf("Table full"); return; } if (i < 1 || i > PtrL->Last+2) //Check the legitimacy of the insertion position { printf("Illegal location"); } for (j = PtrL->Last;j >= i-1; j++) { //[] denotes subscript PtrL->Data[j + 1] = PtrL->Data[j]; //Move a[i+1]~a[n] backward in reverse order } PtrL->Data[i - 1] = X; //New element insertion PtrL->Last++; //Last still points to the last element return; }

## Delete (delete the element at position I (1 < = I < = n + 1)) of the table)

### 4. Delete operation implementation

#### The code is as follows:

void Delete(int i,List PtrL) { int j; if(i < 1 || PtrL->Last+1) //Check the validity of empty tables and deleted locations { printf("Does not exist%d Elements",i); return; } for(j=i;j <= PtrL->Last;j++) { //[] denotes subscript PtrL->Data[j-1] = PtrL->Data[j]; /*Move a[i+1]~a[n] forward in sequence*/ } PtrL->Last-- //Last still points to the last element }

# Chain storage implementation of linear list:

#### Two logically adjacent elements are not required to be physically adjacent, and the logical relationship between data elements is established through "chain".

typedef struct LNode*List; struct LNode{ ElementType Data; List Next; }; struct LNode L; List PtrL;

## Implementation of main operations:

### 1. Calculate meter length

#### The code is as follows:

int Length(List PtrL) { List p = PtrL; //p points to the first node of the table int j = 0; while(p) { p=p->next; j++; //The current p points to the j-th node } return j; }

### 2. Find

#### (1) Search by serial number: FindKth;

#### The code is as follows:

List FindKth(int K, List PtrL) { List p = PtrL; int i = 1; while(p!=NULL && i < K) { p=p->next; i++; } if(i == K)return p; //Find the K-th and return the pointer else return NULL; //Otherwise, it returns null }

#### (2) Find by value: find;

#### The code is as follows:

List Find(ElementType X, List PtrL) { List p = PtrL; while(p!=NULL && p->Data!=X) { p=p->next; } return p; }

### 3. Insert (insert a new node with a value of X after the I-1 (1 < = I < = n + 1)) node)

#### Basic ideas

(1) First, construct a new node and point it with s;

(2) Then find the i-1 node of the linked list and point to it with p;

(3) Then modify the pointer and insert the node (the new node inserted after p is s)

tips: major sequencing issues

#### The code is as follows:

List Insert(ElementType X, int i,List PtrL) { List p,s; if(i == 1) //Insert new node in header { s = (List)malloc(sizeof(struct LNode)); //Application and filling node s->Data = X; s->next = PtrL; return s; //Return new header pointer } p = FindKth(i-1,PtrL) //Find node i-1 if(p == NULL) //The i-1 does not exist and cannot be inserted { printf("parameter i wrong")； return NULL; }else{ s = (List)malloc(sizeof(struct LNode)) //Application and filling node s->Data = X; s->Next = p->Next; //The new node is inserted after the i-1 node p->Next = s; return PtrL; } }

### 4. Delete (delete the node at position I (1 < = I < = n + 1)) in the linked list)

#### Basic ideas

(1) First find the i-1 node of the linked list and point to it with p;

(2) Then the pointer s points to the node to be deleted (the next node of p);

(3) Then modify the pointer and delete the node referred to by s

#### The code is as follows:

List Delete(int i, List PtrL) { List p,s; if(i == 1) //To delete is the first node of the table { s = PtrL; //s points to the first node if(PtrL!=NULL)PtrL = PtrL->Next; //Delete from linked list else return NULL; free(s); //Release deleted node return PtrL; } p = FindKth(i-1,PtrL); //Find node i-1 if(p == NULL) { printf("The first%d Nodes do not exist",i-1); return NULL; } else if(p->Next == NULL) { printf("The first%d Nodes do not exist",i); return NULL; } else { s = p->Next; //s points to the ith node p->Next = s->Next; //Delete from linked list free(s); //Release deleted node return PtrL; } }