Using C language to implement sequential table

Using C language to implement static sequential table

----------header file # include "SeqList.h"--------------------

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 100

------------------define the data type----------------------------
typedef int DATATYPE;

Static allocation sequential storage structure of------------linear table----------------
typedef struct SEQLIST
{
DataType Arr[max];
int size;
}seqlist,*pseqlist;

----------------------Basic Operation----------------------------
void Initseqlist (Pseqlist pslist); Initialization
void Printseqlist (Seqlist slist); Print Order table
void pushback (Pseqlist pslist, DataType x); Tail plug
void Popback (Pseqlist pslist); Tail Delete
void Pushfront (Pseqlist pslist, DataType x); Head plug
void Popfront (Pseqlist pslist); Head Delete
void Insert (pseqlist pslist, int pos, DataType x); Insert
void Remove (pseqlist pslist,datatype x); Delete
void RemoveAll (Pseqlist pslist, DataType x); Delete all the same nodes
int Find (pseqlist pslist,datatype x); Find
void Reverselist (Pseqlist pslist); Reverse
void Sortlist (Pseqlist pslist); Sort
int BinarySearch (pseqlist pslist,datatype x); Binary find

-------------the implementation of basic operations---------------------------
#include "SeqList.h"

void Initseqlist (Pseqlist pslist)//initialization
{
memset (Pslist->arr, 0, sizeof (Pslist->arr));
pslist->size = 0;
}

void Printseqlist (Seqlist slist)//Print order table
{
int i = 0;
for (i=0; i<slist.size; i++)
{
printf ("%d", slist.arr[i]);
}
printf ("over\n");
}

void pushback (Pseqlist pslist, DataType x)//tail plug
{
if (pslist->size >= MAX)
{
printf ("The Order table is full!");
}
Pslist->arr[pslist->size] = x;
pslist->size++;
}

void Popback (Pseqlist pslist)//Tail Delete
{
if (pslist->size = = 0)
{
printf ("Order table is empty!");
}
pslist->size--;
}

void Pushfront (Pseqlist pslist, DataType x)//head plug
{
int i=0;
if (pslist->size >=max)
{
printf ("The Order table is full!");
}
for (i = pslist->size; i > 0; i--)
{
Pslist->arr[i] = pslist->arr[i-1];
}
Pslist->arr[0] = x;
pslist->size++;
}

void Popfront (Pseqlist pslist)//First Delete
{
int i=0;
if (pslist->size = = 0)
{
printf ("Order table is empty");
}
for (i=0;i<pslist->size-1;i++)
{
Pslist->arr[i] = pslist->arr[i+1];
}
pslist->size--;
}

void Insert (pseqlist pslist, int pos, DataType x)//Insert
{
int i=0;
if (pslist->size >= MAX)
{
printf ("The Order table is full!");
}
for (i=pslist->size;i>pos;i--)
{
Pslist->arr[i] = pslist->arr[i-1];
}
Pslist->arr[pos] = x;
pslist->size++;
}

void Remove (pseqlist pslist,datatype x)//delete
{
int pos = Find (pslist,x);
int i = 0;
for (i = Pos;i < pslist->size-1;i++)
{
Pslist->arr[i] = pslist->arr[i+1];
}
pslist->size--;
}

void RemoveAll (Pseqlist pslist, DataType x)//delete all the same nodes
{
int i = 0;
int pos = Find (pslist, x);
while (pos! =-1)
{
for (i = pos;i<pslist->size-1;i++)
{
Pslist->arr[i] = pslist->arr[i+1];
}
pslist->size--;
pos = Find (pslist,x);
}
}

int find (pseqlist pslist,datatype x)//Find
{
int i = 0;
for (i = 0;i < pslist->size;i++)
{
if (pslist->arr[i] = = x)
{
return i;
}
}
return-1;
}

void Reverselist (Pseqlist pslist)//reverse order
{
int start = 0;
int end = pslist->size-1;
while (Start < end)
{
DataType tmp =pslist->arr[start];
Pslist->arr[start] = pslist->arr[end];
Pslist->arr[end] = tmp;
start++;
end--;
}
}

void Sortlist (Pseqlist pslist)//Sort
{
int i = 0,j = 0;
for (i = 0;i<pslist->size-1;i++)
{
for (j = 0;j<=pslist->size-2-i;j++)
{
if (Pslist->arr[j] > Pslist->arr[j+1])
{
DataType tmp = pslist->arr[j];
PSLIST->ARR[J] = pslist->arr[j+1];
PSLIST->ARR[J+1] = tmp;
}
}
}
}

int BinarySearch (pseqlist pslist,datatype x)//binary find
{
int start = 0;
int end = pslist->size-1;
while (Start < end)
{
int mid = (start + end)/2;
if (x = = Pslist->arr[mid])
return mid;
else if (x < Pslist->arr[mid])
{
end = Mid-1;
}
Else
{
Start = mid + 1;
}
return mid;
}
return 0;
}

-----------------Test function---------------------------------

#include "SeqList.h"

void Test1 ()
{
Seqlist Seqlist1;
Initseqlist (&SEQLIST1);
Pushback (&seqlist1,1);
Pushback (&seqlist1,2);
Pushback (&seqlist1,3);
Pushback (&seqlist1,4);
Printseqlist (SEQLIST1);
Popback (&SEQLIST1);
Printseqlist (SEQLIST1);
Pushfront (&seqlist1,8);
Printseqlist (SEQLIST1);
Popfront (&SEQLIST1);
Printseqlist (SEQLIST1);
}

void Test2 ()
{
int ret = 0;
Seqlist Seqlist1;
Initseqlist (&SEQLIST1);
Pushback (&seqlist1,1);
Pushback (&seqlist1,2);
Pushback (&seqlist1,3);
Pushback (&seqlist1,4);
Printseqlist (SEQLIST1);
Insert (&seqlist1, 4, 6);
Printseqlist (SEQLIST1);
ret = Find (&seqlist1, 4);
printf ("%d \ n", ret);
}

void Test3 ()
{
int ret = 0;
Seqlist Seqlist1;
Initseqlist (&AMP;SEQLIST1);
Pushback (&seqlist1,2);
Pushback (&seqlist1,1);
Pushback (&seqlist1,2);
Pushback (&seqlist1,3);
Pushback (&seqlist1,2);
Pushback (&seqlist1,4);
Pushback (&seqlist1,2);
Printseqlist (SEQLIST1);
Remove (&seqlist1,3);
Printseqlist (SEQLIST1);
RemoveAll (&seqlist1, 2);
Printseqlist (SEQLIST1);
}
void Test4 ()
{
int ret = 0;
Seqlist Seqlist1;
Initseqlist (&AMP;SEQLIST1);
Pushback (&seqlist1,1);
Pushback (&seqlist1,2);
Pushback (&seqlist1,3);
Pushback (&seqlist1,4);
Printseqlist (SEQLIST1);
Reverselist (&AMP;SEQLIST1);
Printseqlist (SEQLIST1);
}
void Test5 ()
{
int ret = 0;
Seqlist Seqlist1;
Initseqlist (&AMP;SEQLIST1);
Pushback (&seqlist1,3);
Pushback (&seqlist1,1);
Pushback (&seqlist1,4);
Pushback (&seqlist1,2);
Printseqlist (SEQLIST1);
Sortlist (&AMP;SEQLIST1);
Printseqlist (SEQLIST1);
ret = BinarySearch (&seqlist1, 2);
printf ("%d\n", ret);
}
int main ()
{
Test5 ();
System ("pause");
return 0;
}

This article from the "Edge to become Magic" blog, declined reproduced!

Using C language to implement sequential table