C语言实现 静态顺序表

顺序表的概念：

                                 用一段地址连续的存储单元依次存储数据元素的线性结构。

为什么要实现顺序表？ 比较数组

1.头文件的实现：list.h

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

#define N 100
typedef int DataType; 

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

void InitSeqList(SeqList* s); 
void DestorySeqList(SeqList* s); 
void PrintSeqList(SeqList* s);
// 增删查改 
void PushBack(SeqList* s, DataType x); 
void PopBack(SeqList* s); 
void PushFront(SeqList* s, DataType x); 
void PopFront(SeqList* s); 

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

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

2.函数的实现：list.c

#include "list.h"

void InitSeqList(SeqList* s)
{
	memset(s->array,0,sizeof(DataType)*N);
	s->size = 0;
}

void PrintSeqList(SeqList* s)
{
	size_t i = 0;
	for(i=0 ; i<s->size ; i++)
	{
		printf("%d ",s->array[i]);
	}
	printf("\n");
}

void PushBack(SeqList* s, DataType x)//尾插
{
	assert(s);
	if(s->size == N)
	{
		printf("SeqList is Full!\n");
		return;
	}
	s->array[s->size++] = x;
}

void PopBack(SeqList* s)//尾删
{
	assert(s);
	if(s->size == 0)
	{
		printf("SeqList is Empty!\n");
		return;
	}
	s->size--;
}

void PushFront(SeqList* s, DataType x)//头插 1 2 3
{
	size_t end = s->size;
	assert(s);
	if(s->size == N)
	{
		printf("SeqList is Full!\n");
		return;
	}
	for(end = s->size; end>0 ;end--)
	{
		s->array[end] = s->array[end-1];
	}
	s->array[0] = x;
	s->size++;
}

void PopFront(SeqList* s)//头删 1 2 3 4
{
	size_t end = 0;
	assert(s);
	if(s->size == 0)
	{
		printf("SeqList is Empty!\n");
		return;
	}
	for(; end<s->size-1 ; end++)
	{
		s->array[end] = s->array[end+1];
	}
	s->size--;
}

void Insert(SeqList* s, size_t pos, DataType x)//在指定位置前面添加一个元素0 1  3 4
{
	size_t end = s->size;
	assert(s);
	assert(pos < s->size );
	if(s->size == N)
	{
		printf("SeqList is Full!\n");
		return;
	}
	for(; end > pos; end--)
	{
		s->array[end] = s->array[end-1];
	}
	s->array[pos] = x;
	s->size++;
}

int Find(SeqList* s, DataType x)//在表中找元素x的位置
{
	size_t i = 0;
	assert(s);
	for(; i<s->size ;i++)
	{
		if(s->array[i] == x)
		{
			return i;
		}
	}
	return -1;
}

void Erase(SeqList* s, size_t pos)//删除pos位置的元素 0 1 2 3 4 (2)
{
	size_t end = pos;
	assert(s);
	assert(pos < s->size);
	for(; end<s->size-1 ;end++)
	{
		s->array[end] = s->array[end+1];
	}
	s->size--;
}

void Remove(SeqList* s, DataType x)//删除表中的元素x
{
	int pos;
	assert(s);
	pos = Find(s,x);
   
	if(pos != -1)
	{
		Erase(s,pos);
	}
	else
	{
		return ;
	}
}

int RemoveAll(SeqList* s, DataType x)//删除表中所有的元素x 0 1 2 2 4 2 3
{
	int i = 0;
	int j = 0;
	assert(s);
	while( i < s->size )
	{
		if(s->array[i] != x)//如果i找到的不是元素x，就把元素一一拿给j
		{
			s->array[j] = s->array[i];
			++j;
		}
		++i;
	}
	s->size = j;
	return i==j ? -1:0;
}

void Swap(DataType* left,DataType* right)
{
	DataType tmp = *left;
	*left = *right;
	*right = tmp;
}
void BubbleSort(SeqList* s)//冒泡排序 0 1 3 4 5 2 6
{
	size_t start = 0;
	size_t end = s->size ;
	assert(s);
	for(end = s->size ; end>0 ; end--)
	{
		int exchange = 0;
		start = 0;//每趟排序完将start置0，再进行下一趟排序
		while(start+1 < end)
		{
			if(s->array[start+1] < s->array[start])
			{
				/*DataType tmp = s->array[start+1];
				s->array[start+1] = s->array[start];
				s->array[start] = tmp;*/
				Swap(s->array+start,s->array+start+1);
				exchange = 1;
			}
			start++;
		}
		if(exchange == 0)
		{
			break;
		}
	}
}


void SelectSort(SeqList* s)//选择排序 
{
	size_t start = 0;
	size_t finish = s->size - 1;
	assert(s);
	while(start < finish)
	{
		size_t i = start;
		size_t min = start;
		size_t max = start;
		while(i<=finish)
		{
			if(s->array[i] < s->array[min])
			{
				min = i;
			}
			if(s->array[i] > s->array[max])
			{
				max = i;
			}
			i++;
		}
		Swap(s->array+start,s->array+min);
		if(start == max)
		{
			max = min;
		}
		Swap(s->array+finish,s->array+max);
		start++;
		finish--;
	}
}

//int BinarySearch(SeqList* s, DataType x)//二分查找
//{
//	size_t left = 0;
//	size_t right = s->size-1;
//	while(left <= right)
//	{
//		int mid = left+(right-left)/2;
//		if(s->array[mid] > x)
//		{
//			right = mid-1;
//		}
//		else if(s->array[mid] < x)
//		{
//			left = mid+1;
//		}
//		else
//			return mid;
//	}
//	return -1;
//}

//递归实现二分查找

int BinarySearch(SeqList* s,DataType x,int left,int right)
{
	if(left <= right)
	{
		int mid = left+(right-left)/2;
		if(s->array[mid] > x)
		{
			BinarySearch(s,x,left,mid-1);
		}
		else if(s->array[mid] < x)
		{
			BinarySearch(s,x,mid+1,right);
		}
		else
			return mid;
	}
	return -1;
}

3.测试函数：test.c

#include "list.h"

void  test1()
{
	
	SeqList s;
	InitSeqList(&s);
//尾插0 1 2 3 4
	PushBack(&s,0);
	PushBack(&s,1);
	PushBack(&s,2);
	PushBack(&s,3);
	PushBack(&s,4);
    
	PrintSeqList(&s); 
//尾删0 1 
	PopBack(&s);
	PopBack(&s);
	PopBack(&s);

	PrintSeqList(&s); 

}

void test2()
{
	SeqList s;
	InitSeqList(&s);
//头插0 1 2 3 4
	PushFront(&s,4);
	PushFront(&s,3);
	PushFront(&s,2);
	PushFront(&s,1);
	PushFront(&s,0);

	PrintSeqList(&s);
//头删3 4
	PopFront(&s);
	PopFront(&s);
	PopFront(&s);

	PrintSeqList(&s);
}

void test3()
{
	SeqList s;
	InitSeqList(&s);


	PushBack(&s,0);
	PushBack(&s,1);
	
	PushBack(&s,3);
	PushBack(&s,4);
	PrintSeqList(&s);

//在指定位置下表为pos前面添加一个元素
	Insert(&s,2,2);

	PrintSeqList(&s);
}

void test4()
{
	SeqList s;
	InitSeqList(&s);

	PushBack(&s,0);
	PushBack(&s,1);
	PushBack(&s,2);
	PushBack(&s,3);
	PushBack(&s,4);
	PushBack(&s,2);
	PushBack(&s,2);
    PrintSeqList(&s);//0 1 2 3 4 2 2

//删除指定位置下标为4的元素
	Erase(&s,4);

	PrintSeqList(&s);//0 1 2 3 2 2

//删除为2的元素（第一个）
	Remove(&s,2);
	PrintSeqList(&s);//0 1 3 2 2

//删除所有为2的元素
	RemoveAll(&s,2);
	PrintSeqList(&s);//0 1 3
}

void test5()
{
	SeqList s;
	InitSeqList(&s);

	PushBack(&s,0);
	PushBack(&s,1);
	PushBack(&s,2);
	PushBack(&s,7);
	PushBack(&s,5);
	PushBack(&s,3);
	PushBack(&s,6);
	PushBack(&s,4);

	PrintSeqList(&s);
//测试冒泡排序
	/*BubbleSort(&s);
	PrintSeqList(&s);*/
//测试选择排序
	SelectSort(&s);
	PrintSeqList(&s);
}

void test6()
{
	SeqList s;
	int ret;
	InitSeqList(&s);

	PushBack(&s,0);
	PushBack(&s,1);
	PushBack(&s,2);
	PushBack(&s,3);
	PushBack(&s,4);
	PushBack(&s,5);
	PushBack(&s,6);
	PushBack(&s,7);

	PrintSeqList(&s);
//测试二分查找
	/*ret = BinarySearch(&s,5);
	printf("search:%d\n",ret);

	ret = BinarySearch(&s,8);
	printf("search:%d\n",ret);

	ret = BinarySearch(&s,6);
	printf("search:%d\n",ret);

	ret = BinarySearch(&s,7);
	printf("search:%d\n",ret);*/
//测试递归实现的二分查找
	ret = BinarySearch(&s,5,2,8);
	printf("search:%d\n",ret);

	ret = BinarySearch(&s,7,1,6);
	printf("search:%d\n",ret);
}
int main()
{
	test6();
	return 0;
}