C语言——静态顺序表常见操作

不用多说，直接贴代码    list.h 文件

#ifndef __LIST_H__
#define __LIST_H__

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

#define Max_t 100
typedef int Typename;

typedef struct Palist
{
Typename arr[Max_t];
int size;

}plist;
//打印
void Printplist(plist* list);

// 初始化
void Initlist(plist * list);

// 尾插
void PushBack(plist * list, Typename data);

// 尾删
void PopBack(plist * list);

// 头插
void PushFront(plist * list, Typename data);

// 头删
void PopFront(plist * list);

// 任意位置上插入
void Insert(plist * list, int pos, Typename data);
// 任意位置删除
void Erase(plist * list, int pos);

// 查找值为data的元素，找到返回该元素的位置，否则返回-1
int Find(plist * list, Typename data);

// 删除第一个值为data的元素
void Remove(plist * list, Typename data);

// 删除所有值为data的元素
void RemoveAll(plist * list, Typename data);

// 使用冒泡排序元素
void BubbleSort(plist * list);

// 使用选择排序元素
void SelectSort(plist * list);

// 使用二分查找查找值为data
int BinarySearch(plist * list, Typename data);

#endif

list.c  文件

#include "list.h"

//打印顺序表
void Printplist(plist* list)
{
assert(list);
int i = 0;
for (i = 0; i < list->size; i++)
{
printf("%2d\t", list->arr[i]);
}
printf("\n");
}

//初始化顺序表

void Initlist(plist * list)
{
assert(list);
int i = 0;
for (i = 0; i < Max_t; i++)
{
list->arr[i] = 0;
}
list->size = 0;
}

//尾部插入元素
void PushBack(plist * list, Typename data)
{
if (list->size > Max_t )
{
return ;   //顺序表已满
}
int i = list->size;
list->arr[i] = data;
list->size++;
}

//尾删
void PopBack(plist * list)
{
if (list->size < 0)
{
return;
}
list->size--;
}

//头删
void PopFront(plist * list)
{
assert(list);
if (list->size == 0)
{
return;
}
for (int i = 0; i < list->size; i++)
{
list->arr[i] = list->arr[i + 1];
}
list->size--;

}

//头插
void PushFront(plist * list, Typename data)
{
assert(list);
int i = 0;
if (list->size > Max_t)
return;

for ( i = list->size; i > 0; i--)
{
list->arr[i] = list->arr[i - 1];
}
list->arr[i] = data;
list->size++;
}

//任意位置插入
void Insert(plist * list, int  pos, Typename data)
{
int i = 0;
assert(list);
if (list->size >= Max_t)
return;
if (pos > list->size)
{
printf("插入位置不合法，插入到尾部\n");
PushBack(list, data);
return;
}
for (i = list->size; i >= pos; i--)
{
list->arr[i] = list->arr[i - 1];
}
list->arr[i] = data;
list->size++;
}

//在任意位置删除
void Erase(plist * list, int pos)
{
assert(list);
if (pos > list->size)
return;
for (int i = pos; i <= list->size; i++)
{
list->arr[i - 1] = list->arr[i];
}
list->size--;
}
//查找值为data第一次出现位置
int Find(plist * list, Typename data)
{
int i = 0;
assert(list);
for (i = 0; i < list->size; i++)
{
if (data == list->arr[i])
{
return i + 1;
}
}
return -1;
}

// 删除顺序表中第一个值为data的元素
void Remove(plist * list, Typename data)
{
assert(list);
int i = 0;
i = Find(list, data);
/*while (data != list->arr[i])
{
i++;
}*/
for (; i < list->size; i++)
{
list->arr[i-1] = list->arr[i];
}
list->size--;
}

// 删除顺序表中所有值为data的元素
void RemoveAll(plist * list, Typename data)
{
int i = 0;
int count = 0;
for (i = 0; i < list->size; i++)
{
if (list->arr[i] == data)
count++;
else
list->arr[i - count] = list->arr[i];
}
list->size -= count;
}

// 使用冒泡排序给顺序表中的元素排序
void BubbleSort(plist * list)
{
for (int i = 0; i < list->size; i++)//比较次数，不参与数据比较
{
for (int k = 0; k < list->size - i-1;k++) //第一个位置的数据依次与其他位置比较
if (list->arr[k]>list->arr[k+1])
{
int tmp = list->arr[k];
list->arr[k] = list->arr[k+1];
list->arr[k+1] = tmp;
}
}
}

// 使用选择排序给顺序表中的元素排序
void SelectSort(plist * list)
{
int i = 0; int j = 0;
for (i = 0; i < list->size; i++)  //比较次数，并参与运算，
{
for (j = i + 1; j < list->size;j++)  //第一个位置依次与其他位置比较
if (list->arr[i] < list->arr[j])
{
int tmp = list->arr[i];
list->arr[i] = list->arr[j];
list->arr[j] = tmp;
}
}
}

// 使用二分查找在顺序表中查找值为data
int   BinarySearch(plist * list, Typename data)
{
int  left = 0;  //左下标
int right = list->size - 1;//右下标
int mid = left + ((right - left) >> 1);
while (left <= right)
{
if (list->arr[mid] == data)
{
printf("已找到:\t %d\n", data);
return 1;
}
else if (list->arr[mid] > data)
{
right = mid - 1;
mid = left + ((right - left) >> 1);
}
else
{
left  = mid + 1;
mid = left + ((right - left) >> 1);
}
}
printf("没有找到\n");
return -1;
}

int main()
{
plist  list;
plist* Splist;
Splist = &list;
Initlist(Splist);
PushBack(Splist, 1);
PushBack(Splist, 2);
PushBack(Splist, 3);
PushBack(Splist, 4);
Printplist(Splist);
/*PopBack(Splist);
Printplist(Splist);
PopBack(Splist);
Printplist(Splist);
PushBack(Splist, 6);
Printplist(Splist);
PopFront(Splist);
PushBack(Splist, 0);
PushFront(Splist, 8);
Printplist(Splist);*/
/*Insert(Splist, 2, 5);
Insert(Splist, 1, 6);
Printplist(Splist);
Erase(Splist, 2);
Printplist(Splist);*/
PushBack(Splist, 3);
PushBack(Splist, 3);
PushBack(Splist, 3);
Remove(Splist, 3);
Printplist(Splist);
RemoveAll(Splist, 3);
Printplist(Splist);
BubbleSort(Splist);
Printplist(Splist);
SelectSort(Splist);
Printplist(Splist);
BinarySearch(Splist, 2);

}