静态顺序表的基本操作

#pragma once
#define MAX_SIZE 10
typedef unsigned int size_t;
typedef int DataType;
#include<stdio.h>
#include<assert.h>
#include<memory.h>
#include <stdlib.h>
#define MAX 100

typedef struct SeqList
{
DataType arr[MAX];
int sz; // 顺序表中有效元素的个数
}SeqList, *pSeqList;

//typedef struct SeqList SeqList;

///
// .h
// 初始化顺序表
void InitSeq(pSeqList pSeq)//初始化顺序表
{
assert(pSeq);
memset(pSeq->arr, 0, sizeof(DataType)*MAX);
pSeq->sz = 0;
}
// 尾插
void PushBack(pSeqList pSeq, DataType x)//尾插
{
assert(pSeq);
if (pSeq->sz == MAX)
{
printf("顺序表已满\n");
exit(EXIT_FAILURE);
}
pSeq->arr[pSeq->sz] = x;
++pSeq->sz;
}

// 尾删
void PopBack(pSeqList pSeq)//尾删
{
assert(pSeq);
if (pSeq->sz == 0)
{
printf("顺序表没有元素；不可删除\n");
exit(EXIT_FAILURE);
}
--pSeq->sz;
}

// 头插
void PushFront(pSeqList pSeq, DataType x)//头插
{
int i = 0;
assert(pSeq);
if (pSeq->sz == MAX)
{
printf("顺序表已满\n");
exit(EXIT_FAILURE);

}

for (i = pSeq->sz; i>0; --i)
{
pSeq->arr[i] = pSeq->arr[i - 1];
}
pSeq->arr[0] = x;
++pSeq->sz;
}

// 头删
void PopFront(pSeqList pSeq)//头删
{
int i = 0;
assert(pSeq);
if (pSeq->sz == 0)
{
printf("顺序表没有元素；不可删除\n");
exit(EXIT_FAILURE);

}
for (i = 0; i<pSeq->sz - 1; ++i)
{
pSeq->arr[i] = pSeq->arr[i + 1];
}
--pSeq->sz;
}

// 任意位置中插入值为data的元素
void Insert(pSeqList pSeq, int pos, DataType x)//在顺序表某位置插入某个特定元素
{
int i = 0;
assert(pSeq);
if (pSeq->sz == MAX)
{
printf("顺序表已满\n");
exit(EXIT_FAILURE);
}
if (pos >= MAX)
{
printf("插入位置不合适\n");
exit(EXIT_FAILURE);
}

for (i = pSeq->sz; i>pos; --i)
{
pSeq->arr[i] = pSeq->arr[i - 1];
}
pSeq->arr[pos] = x;
++pSeq->sz;
}

// 删除任意位置中的元素
void SeqListErase(pSeqList pSeq, int pos)
{
int i = 0;
assert(pSeq);
if (Empty(pSeq))
{
printf("顺序表为空\n");
return;
}
if (pos < 0 || pos >= pSeq->sz)
{
printf("%d 位置非法\n");
return;
}
for (i = pos; i < pSeq->sz - 1; i++)
{
pSeq->arr[i] = pSeq->arr[i + 1];
}
pSeq->sz--;
}

// 在顺序表中查找值为data的元素，返回该元素在顺序表中的下标
//int SeqListFind(pSeqList ps, DataType data);
int SeqListFind(pSeqList pSeq, int value)
{
assert(pSeq);
size_t i = 0;
for (i = 0; i < pSeq->sz; i++)
{
if (pSeq->arr[i] == value)
{
return i;//返回数组下标
}
}
return -1;
}

// 删除顺序表中值为data的元素
void Remove(pSeqList pSeq, DataType data)
{
int i = 0;
int j = 0;
assert(pSeq);
if (pSeq->sz == 0)
{
printf("顺序表为空；不可删除\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < (pSeq->sz); ++i)
{
if (pSeq->arr[i] == data)
{
for (j = i; j<pSeq->sz - 1; ++j)
{
pSeq->arr[j] = pSeq->arr[j + 1];
}
--pSeq->sz;
break;
}
}
return;
}

// 删除顺序表中所有值为data的元素
void RemoveAll(pSeqList pSeq, DataType x)
{
int i = 0;
int j = 0;
assert(pSeq);
if (pSeq->sz == 0)
{
printf("顺序表没有元素；不可删除\n");
exit(EXIT_FAILURE);
}
for (i = 0; i<pSeq->sz; ++i)
{
if (pSeq->arr[i] == x)
{
for (j = i; j<pSeq->sz - 1; ++j)
{
pSeq->arr[j] = pSeq->arr[j + 1];
}
--pSeq->sz;//记得--元素个数；要不然上增循环会越界；
/*删除元素以后（后面覆盖前面），记得将下标回到前一位置；
再次进入循环,i会走到刚才的位置；现在是新的元素；这样可以
避免漏检查元素，可以有效删除出相连相同的元素；*/
i = i - 1;
}
}
return;
}

// 判断顺序表是否为空
int SeqListEmpty(SeqList* seqlist)//返回该顺序表是否为空，为空返回1，否则返回0
{
if (seqlist == NULL) {
return;
}
if (seqlist->sz == 0) {
return 1;
}
else
return 0;

}

// 获取顺序表中元素的个数
size_t SeqListSize(SeqList* seqlist)//返回该顺序表的个数
{

if (seqlist == NULL) {
return;
}
return seqlist->sz;

}

/
// 辅助操作
// 打印顺序表中的元素
void Print(SeqList *seq)
{
assert(seq);
size_t i = 0;
for (i = 0; i < seq->sz; i++)
{
printf("%d->", seq->arr[i]);
}
}

// 用冒泡排序对顺序表中的元素进行排序
void SeqListBubbleSort(SeqList* seqlist)//冒泡排序
{

if (seqlist == NULL) {
return;
}
if (seqlist->sz == 1) {
return;
}
int i = 0;
for (i = 0; i<seqlist->sz - 1; i++) {
int j = 0;
for (j = 0; j<seqlist->sz - 1 - i; j++) {
if (seqlist->arr[j]>seqlist->arr[j + 1]) {
DataType tmp = seqlist->arr[j];
seqlist->arr[j] = seqlist->arr[j + 1];
seqlist->arr[j + 1] = tmp;
}
}
}
}

// 用选择排序对顺序表中的元素进行排序
void SelectSort(int* arr, int sz);
void SelectSort(SeqList *seq)
{
assert(seq);
size_t i = 0;
size_t j = 0;
for (i = 0; i < seq->sz; i++)
{
size_t min = i;
for (j = i + 1; j < seq->sz; j++)//找到每次最小值
{
if (seq->arr[min] > seq->arr[j])
{
min = j;
}
}

if (i != min)
{
/*DataType t = seq->data[min];
seq->data[min] = seq->data[i];
seq->data[i] = t;*/
seq->arr[min] ^= seq->arr[i];
seq->arr[i] ^= seq->arr[min];
seq->arr[min] ^= seq->arr[i];

}
}
}

// 选择排序优化---一次找出最大最小元素所在的位置
void SelectSort_OP(int* arr, int sz);