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);

}