C语言实现顺序表

头文件：seqlist.h

//静态
#ifndef _SEQLIST_H_
#define _SEQLIST_H_
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>


#define MAX_SIZE 100
typedef int DataType;


typedef struct SeqList
{
DataType array[MAX_SIZE];// 存储数据的数组 
size_t size; // 有效数据的个数 
}SeqList;


void InitSeqList(SeqList* seq);
void DestorySeqList(SeqList* seq);
void PrintSeqlist(SeqList* seq);


// 增删查改 
void PushBack(SeqList* seq, DataType x);
void PopBack(SeqList* seq);
void PushFront(SeqList* seq, DataType x);
void PopFront(SeqList* seq);
void Modify(SeqList* seq, size_t pos, DataType x);


// 在pos的前面进行插入 
void Insert(SeqList* seq, size_t pos, DataType x);
int Find(SeqList* seq, DataType x);
void Erase(SeqList* seq, size_t pos);
int Remove(SeqList* seq, DataType x);
int RemoveAll(SeqList* seq, DataType x);


void BubbleSort(SeqList* seq);
void SelectSort(SeqList* seq);
void InsertSort(SeqList* seq);
int BinarySearch(SeqList* seq, DataType x);


#endif

seqlist.c

#include"seqlist.h"


void InitSeqList(SeqList* seq)
{
memset(seq->array, 0, sizeof(DataType)* 100);
seq->size = 0;
}
// 增删查改 
void PushBack(SeqList* seq, DataType x)
{//防御式编程
assert(seq != NULL);
if (seq->size == MAX_SIZE)
{
printf("It has been full!\n");
return;
}
else
{
seq->array[seq->size] = x;
seq->size = (seq->size) + 1;
}
}
void PopBack(SeqList* seq)
{
assert(seq != NULL);
if (seq->size == 0)
{
printf("It has been empty!\n");
}
else
{
seq->array[seq->size - 1] = 0;
seq->size = (seq->size) - 1;
}
}
void PushFront(SeqList* seq, DataType x)
{
assert(seq != NULL);
if (seq->size == MAX_SIZE)
{
printf("It has been full!\n");
return;
}
else
{
int i = seq->size;
while (i != 0)
{
seq->array[i] = seq->array[i - 1];
i--;
}
seq->array[0] = x;
seq->size = (seq->size) + 1;
}
}
void PopFront(SeqList* seq)
{
assert(seq != NULL);
if (seq->size == 0)
{
printf("It has been empty!\n");
return;
}
else
{
int i = 0;
while (i != (seq->size)-1)
{
seq->array[i] = seq->array[i + 1];
i++;
}
seq->array[seq->size - 1] = 0;
seq->size = (seq->size) - 1;
}
}


// 在pos的前面进行插入 
void Insert(SeqList* seq, size_t pos, DataType x)
{
assert(seq != NULL);
assert(pos<seq->size);
if (seq->size == MAX_SIZE)
{
printf("It has been full!\n");
return;
}
else
{
if (pos == seq->size - 1)
{
PushBack(seq, x);
}
else if (pos == 0)
{
PushFront(seq, x);
}
else
{
int i = seq->size;
while (i != pos)
{
seq->array[i] = seq->array[i - 1];
i--;
}
seq->array[pos] = x;
seq->size++;
}
}
}
int Find(SeqList* seq, DataType x)
{
assert(seq);
if ( seq->size == 0 )
{
printf("It has been empty!\n");
return -2;
}
int i = 0;
while (i != seq->size)
{
if (seq->array[i] == x)
{
return i;
break;
}
i++;
}
return -1;
}
void Erase(SeqList* seq, size_t pos)
{
assert(seq);
assert(pos < seq->size);
if (seq->size == 0)
{
printf("It has been empty!\n");
return;
}
else
{
if (pos == 0)
{
PopFront(seq);
}
else if (pos == seq->size - 1)
{
PopBack(seq);
}
else
{
int i = pos;
while (i != seq->size - 1)
{
seq->array[i] = seq->array[i + 1];
i++;
}
seq->array[seq->size-1] = 0;
seq->size--;
}
}
}
void Modify(SeqList* seq, size_t pos, DataType x)
{
assert(seq);
assert(pos < seq->size);
seq->array[pos] = x;
}
int Remove(SeqList* seq, DataType x)
{
assert(seq);
int reback = Find(seq, x);
if (reback < 0)
{
return -1;
}
else
{
Erase(seq, reback);
return 0;
}
}
int RemoveAll(SeqList* seq, DataType x)
{
assert(seq);
size_t seek = 0;
size_t set = 0;
while (seek != seq->size)
{
if (seq->array[seek] != x)
{
seq->array[set] = seq->array[seek];
set++;
}
seek++;
}
seq->size = set;
return set == seek ? -1: 0;
}


//int RemoveAll(SeqList* seq, DataType x)
//{
// assert(seq);
// int ret;
// ret = Remove(seq, x);
// while (ret==0&&Remove(seq, x) == 0);
// return ret;
//}
void PrintSeqlist(SeqList* seq)
{
int i = 0;
for (0; i<(int)seq->size; i++)
{
printf("%d\t", seq->array[i]);
}
printf("\n");
}
void BubbleSort(SeqList* seq)
{
assert(seq);
int cnt = 0;
size_t tail = seq->size - 1;
while (tail != 0)
{
size_t  start = 0;
for (; start < tail; start++)
{
DataType tmp;
if (seq->array[start] < seq->array[start + 1])//降序
{
cnt++;
tmp = seq->array[start];
seq->array[start] = seq->array[start + 1];
seq->array[start+1] = tmp;
}
}
if (cnt == 0)
{
break;
}
tail--;
}
}
void swap(DataType *a, DataType * b)
{
DataType  tmp = *a;
*a = *b;
*b = tmp;
}
void SelectSort(SeqList* seq)
{
assert(seq);
size_t start = 0;
size_t end = seq->size - 1;
while (start < end)
{
int max = start;
int min = start;
size_t i = start;
while (i <= end)
{
if (seq->array[i]<seq->array[min])
{
min = i;
}
if (seq->array[i]>seq->array[max])
{
max = i;
}
i++;
}
swap(seq->array+start, seq->array+min);
//修正
if (seq->array[start] == seq->array[max])
{
max = min;
}
swap(seq->array+end, seq->array+max);
start++;
end--;
}
}




//void SelectSort(SeqList* seq)
//{
// assert(seq);
// size_t start1 = 0;
// size_t start2 ;
// while (start1!=seq->size-1)
// {
//
// for (start2=start1+1; start2 < seq->size; start2++)
// {
// if (seq->array[start1] < seq->array[start2])
// {
// int temp;
// temp = seq->array[start1];
// seq->array[start1] = seq->array[start2];
// seq->array[start2] = temp;
// }
// }
// start1++;
// }
//}
int BinarySearch(SeqList* seq, DataType x)
{
assert(seq);
size_t left = 0;
size_t right = seq->size - 1;
int mid = 0;
while (left <= right)
{
if (seq->array[left] == x)
{
return left;
}
else if (seq->array[right] == x)
{
return right;
}
else
{
mid = left + (right - left) / 2;
if (seq->array[mid] > x)
{
left = mid + 1;
}
else if (seq->array[mid] < x)
{
right = mid - 1;
}
else
{
return mid;
}
}
left--;
right++;
}
return -1;
}
void Testseqlist2()
{
SeqList s;
int ret;
InitSeqList(&s);
PushBack(&s, 8);
PushBack(&s, 2);
PushBack(&s, 7);
PushBack(&s, 4);
PushBack(&s, 3);
PushBack(&s, 6);
PrintSeqlist(&s);
//BubbleSort(&s);
SelectSort(&s);
PrintSeqlist(&s);
ret=BinarySearch(&s, 6);
if (ret > 0)
{
printf("%d\n", s.array[ret]);
}
}




void Testseqlist1()
{
SeqList s;
InitSeqList(&s);
PushBack(&s, 1);
PushBack(&s, 2);
PushBack(&s, 3);
PushBack(&s, 4);
PushBack(&s, 5);
PushBack(&s, 6);
PrintSeqlist(&s);
PushBack(&s, 7);
PushBack(&s, 8);
PrintSeqlist(&s);
PopBack(&s);
PopBack(&s);
PrintSeqlist(&s);
PushFront(&s, 0);
PushFront(&s, -1);
PrintSeqlist(&s);
PopFront(&s);
PrintSeqlist(&s);
Insert(&s,2,22);
PrintSeqlist(&s);
Erase(&s, 2);
Erase(&s, 0);
PrintSeqlist(&s);
Insert(&s, 3, 1);
Insert(&s, 4, 1);
PrintSeqlist(&s);
printf("%d\n",RemoveAll(&s, 1));
PrintSeqlist(&s);
}

主程序：顺序表.c

#include"seqlist.h"


int main()
{


//Testseqlist1();
Testseqlist2();
system("pause");
return 0;
}

动态顺序表：

seqlistd.h

//静态
#ifndef _SEQLISTD_H_
#define _SEQLISTD_H_
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>


#define MAX_SIZE 100
typedef int DataType;


typedef struct SeqListD
{
DataType* array;// 存储数据的数组首地址 
size_t size; // 有效数据的个数 
size_t capacity;
}SeqListD;


void InitSeqListD(SeqListD* seq)
{
assert(seq);
seq->array = (DataType *)malloc(3 * sizeof(DataType));
assert(seq->array);
seq->size = 0;
seq->capacity = 3;
}
void DestorySeqListD(SeqListD* seq)
{
assert(seq);
free(seq->array);
seq->size = 0;
seq->capacity = 0;
}
void PrintSeqlistD(SeqListD* seq)
{
assert(seq);
size_t i = 0;
for (; i < seq->size; i++)
{
printf("%d\t", seq->array[i]);
}
printf("\n");
}
void CheckCapacity(SeqListD* seq)
{
assert(seq);
if (seq->size == seq->capacity)
{
seq->array = (DataType *)realloc(seq->array, 2 * seq->capacity*sizeof(DataType));
assert(seq->array);
seq->capacity = 2 * seq->capacity;
}
}


// 增删查改 
void PushBackD(SeqListD* seq, DataType x)
{
assert(seq);
CheckCapacity(seq);
seq->array[seq->size] = x;
seq->size++;
}
void PopBackD(SeqListD* seq)
{
assert(seq);
if (seq->size == 0)
{
printf("It is empty!\n");
return;
}
seq->array[seq->size - 1] = 0;
seq->size--;
}
void PushFrontD(SeqListD* seq, DataType x)
{
assert(seq);
CheckCapacity(seq);
size_t i = seq->size;
for (; i > 0; i--)
{
seq->array[i] = seq->array[i - 1];
}
seq->array[0] = x;
seq->size++;
}
void PopFrontD(SeqListD* seq)
{
assert(seq);
if (seq->size == 0)
{
printf("It is empty!\n");
return;
}
size_t i = 0;
for (; i < seq->size - 1; i++)
{
seq->array[i] = seq->array[i + 1];
}
seq->array[seq->size - 1] = 0;
seq->size--;
}


#endif

test.c

#include "seqlistd.h"


int main()
{
SeqListD s;
int input = 1;
InitSeqListD(&s);
DataType x;
printf("/====================================================/\n");
while (input)
{
printf("********** 1 PushFront      3 PushBack ************\n");
printf("********** 2 PopFront       4 popBack  ************\n");
printf("********** 5 View           0 exit    ************\n");
printf("Please choose!\n");
scanf("%d", &input);
switch (input)
{
case 1:
printf("Please input the number that you will add in the seqlist!\n");
scanf("%d", &x);
PushFrontD(&s, x);
break;
case 2:
PopFrontD(&s);
break;
case 3:
printf("Please input the number that you will add in the seqlist!\n");
scanf("%d", &x);
PushBackD(&s, x);
break;
case 4:
PopBackD(&s);
break;
case 5:
PrintSeqlistD(&s);
break;
default:
break;
}
}
DestorySeqListD(&s);
printf("/====================================================/\n");
system("pause");
return 0;
}