顺序表

顺序表的是计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。顺序表是将表中的元素（节点）一个接一个存入一组连续的存储单元中。

静态顺序表，大小已知，实现基本的增删改查。

由于顺序表是一个依次存储的线性结构，在插入或者删除节点时可以有头插头删，尾插尾删。

我们可以定义一个结构体，用来保存表的数据和数据的个数。

接下来折半查找顺序表可以实现以下功能：

1：尾插

2：尾删

3：头插

4：头删

5：在给定位置插入元素

6：删除给定位置的元素

7：删除给定的元素

8：删除几个相同的元素

9：实现顺序表的几种排序如：冒泡排序，选择排序，插入排序

10：折半查找

头文件

#define _CRT_SECURE_NO_WARNINGS 1

#ifndef __SEQLIST__
#define __SEQLIST__

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#define MAX_SIZE 10

typedef int  datatype;
typedef struct Seqlist
{
    datatype arr[MAX_SIZE];//存放表的数据；
    size_t size;//数据的个数；
}Seqlist;

void Init(Seqlist* seq);//初始化；
void PrintSeqlist(Seqlist *seq);//打印顺序表；
//实现增删改查；
void  Pushback(Seqlist *seq, datatype x);
void Popback(Seqlist *seq, datatype x);
void PushFront(Seqlist *seq, datatype x);
void PopFront(Seqlist *seq, datatype x);
void Insert(Seqlist *seq, datatype x,size_t pos);
int Find(Seqlist *seq, datatype x);
void Erase(Seqlist *seq, size_t pos);
void Remove(Seqlist *seq, datatype x);
void Removall(Seqlist *seq, datatype x);
void BubbleSort(Seqlist *seq);
void SelsectSort(Seqlist *seq);
void InsertSort(Seqlist *seq, datatype x);
int BinarySearch(Seqlist *seq, datatype x);
#endif

一.实现一个顺序表的初始化。

//初始化
void Init(Seqlist *seq)
{
	assert(seq);


	seq->size= 0;//顺序表的初始化；
	memset(seq, 0, sizeof(datatype)*MAX_SIZE);
}

二.然后是打印顺序表。

//打印
void PrintSeqlist(Seqlist *seq)
{
	assert(seq);

	int i = 0;
	for (; i < seq->size; i++)
	{
		printf(" %d ", seq->arr[i]);
	}
	printf("\n");
}

三.尾插，判断这个表是否满了，没满就继续插入数据。

//尾插
void  Pushback(Seqlist *seq, datatype x)
{
	assert(seq);

	if (seq->size == MAX_SIZE)
	{
		printf("list is full\n");
		exit(0);
	}
	seq->arr[seq->size] = x;
	seq->size++;
}

四.尾删要考虑是否为空表。

//尾删
void Popback(Seqlist *seq, datatype x)
{
	assert(seq);
	//空表
	//不为空
	if (seq->size == 0)
	{
		printf("list is empty\n");
		exit(0);
	}
	seq->size--;
}

五.头插

//头插

void PushFront(Seqlist*seq, datatype x)

{
	assert(seq);

	if (seq->size == MAX_SIZE)//表满；
	{
		printf("list is full\n");
		exit(0);
	}

	int i = 0;
	for (i = seq->size; i >= 0;i--)
	{
		seq->arr[i] = seq->arr[i-1];
	}
	seq->arr[0] = x;
	seq->size++;
}

六.头删，判断顺序表是否为空。

//头删
void PopFront(Seqlist *seq, datatype x)
{
	assert(seq);

	if (seq->size == 0)
	{
		printf("list is enpty\n");
		exit(0);
	}

	int i = 0;
	for (i = 0; i < seq->size;i++)
	{
		seq->arr[i] = seq->arr[i+1];
	}
	seq->size--;
}

七.在指定位置插入元素

//插入
void Insert(Seqlist *seq, datatype x, size_t pos)
{
	assert(seq);

	if (seq->size == MAX_SIZE || (pos<1 && pos > MAX_SIZE+1))
	{
		printf("list is full\n");
		exit(0);
	}

	int i = 0;
	for (i = seq->size-1; i >= pos; i--)
	{
		seq->arr[i+1] = seq->arr[i];
	}
	seq->arr[pos] = x;
	seq->size++;
}

八.删除指定位置的元素，原理就是找到所在的位置，然后后一个把前一个覆盖即可。

//删除指定位置的元素；
void Erase(Seqlist *seq, size_t pos)
{
	assert(seq);

	if (seq->size == 0)
	{
		printf("list is empty\n");
		exit(0);
	}

	int i = 0;
	for (i= pos; i < seq->size; i++)
	{
		seq->arr[i] = seq->arr[i + 1];
	}
	seq->size--;
}

九.删除给定的元素用两个循环，第一次找到元素，break,第二次循环左移把要删除的元素覆盖即可。

//删出给定元素
void Remove(Seqlist *seq, datatype x)
{
	assert(seq);

	if (seq->size == 0)
	{
		printf("list is empty\n");
		exit(0);
	}
	int i = 0;
	for (i = 0; i < seq->size;i++)
	{
		if (seq->arr[i] == x)
		{
			break;
		}
	}
	if (i == seq->size)
	{
		printf("删除的元素不存在\n");
		exit(0);
	}
	int j = 0;
	for (j = i + 1; j < seq->size; j++)
	{
		seq->arr[j - 1] = seq->arr[j];
	}
	seq->size--;
}

十.删除几个相同的元素，外循环控制移动的步数，内循环从开始删除的位置开始，后面把前面覆盖。

//删除出现相同的元素
void Removall(Seqlist *seq, datatype x)
{
	assert(seq);


	if (seq->size == 0)
	{
		printf("list is full");
		exit(0);
	}


	int i = 0;
	for (i = 0; i < seq->size; i++)
	{
		if (x == seq->arr[i])
		{
			int j = 0;
			for (j = i; j < seq->size - 1; j++)
			{
				seq->arr[j] = seq->arr[j + 1];
			}
			seq->size--;
			i--;
		}
	}
}

十一.冒泡排序，此处是升序排序。

//冒泡排序
void BubbleSort(Seqlist *seq)
{
	assert(seq);

	int i = 0;
	int flag = 1;
	for (; i < seq->size; i++)
	{
		int j = 0;
		flag = 0;
		for (j = 0; j < seq->size - i - 1; j++)
		{
			if (seq->arr[j]>seq->arr[j+1])
			{
				int tmp = seq->arr[j];
				seq->arr[j] = seq->arr[j + 1];
				seq->arr[j + 1] = tmp;
				flag = 1;
			}
		}
		if (flag != 1)
		{
			break;
		}
	}
}

十二.插入排序，原理将一个无序数插入到一个有序的序列中。

//插入排序
void InsertSort(Seqlist *seq)
{
		assert(seq);
		
			int i = 0;
			for (i = 1; i < seq->size; i++)
			{
			   int tmp = seq->arr[i];
			   int j = 0;
			   for (j = i - 1; j >= 0; j--)
			   {
				   if (seq->arr[j]>tmp)
				   {
		
					   seq->arr[j + 1] = seq->arr[j];
				   }
				   else
				   {
					   break;
				   }
			   }
			   seq->arr[j+1] = tmp;
			}
}

十三.选择排序找到最小值，然后依次与其他的比较。

//选择排序
void SelsectSort(Seqlist *seq)
{
	assert(seq);

	int i = 0;
	for (i = 0; i < seq->size-1; i++)
	{
		int min =i;
		int j = 0;
		for (j = i+1; j < seq->size; j++)
		{
			if ((seq->arr[min]) >(seq->arr[j]))
			{
				min = j;
			}
		}

		if (seq->arr[min] != seq->arr[i])
		{
			int tmp = seq->arr[i];
			seq->arr[i] = seq->arr[min];
			seq->arr[min] = tmp;
		}
	}
}

十四.折半查找，每一次使规模缩小一半，查找比较高效。

//二分查找
int BinarySearch(Seqlist *seq, datatype x)
{
	assert(seq);

	int left = 0;
	int right = seq->size - 1;
	if (seq->size == 0)
	{
		printf("list is empty\n");
	}
	if (left > right)
	{
		return;
	}
	while (left <= right)
	{
		int mid = left + ((left + right) >> 1);
		if (seq->arr[mid] == x)
		{
			printf("找到了%d\n",x);
			break;
		}
		  else if (seq->arr[mid] < x)
		  {
			left = mid + 1;
		  }
		  else 
		   {
			right = mid - 1;
		   }
	}
}

主函数的实现：

//尾插尾删测试
void test1()
{
	Seqlist seq;
	Init(&seq);
	Pushback(&seq, 1);
	Pushback(&seq, 2);
	Pushback(&seq, 3);
	Pushback(&seq, 4);
	Popback(&seq, 3);
	Popback(&seq, 4);
	PrintSeqlist(&seq);
}
//头插头删测试
void test2()
{
	Seqlist seq;
	Init(&seq);
	PushFront(&seq, 1);
	PushFront(&seq, 2);
	PushFront(&seq, 3);
	PushFront(&seq, 4);
	PushFront(&seq, 5);
	PushFront(&seq, 6);
	PopFront(&seq, 6);
	PopFront(&seq, 5);
	PrintSeqlist(&seq);
}
//插入删除测试
void test3()
{
	Seqlist seq;
	Init(&seq);
	Pushback(&seq, 1);
	Pushback(&seq, 3);
	Pushback(&seq, 4);
	Insert(&seq,2,2);
	PrintSeqlist(&seq);
	Erase(&seq, 4);
	PrintSeqlist(&seq);
}
//测试删除给定的某个元素，删除几个相同元素
void test4()
{
	Seqlist seq;
	Init(&seq);
	Pushback(&seq, 1);
	Pushback(&seq, 2);
	Pushback(&seq, 2);
	Pushback(&seq, 2);
	Pushback(&seq, 3);
	Pushback(&seq, 4);
	PrintSeqlist(&seq);
	Remove(&seq, 4);
	PrintSeqlist(&seq);
	Removall(&seq, 2);
	PrintSeqlist(&seq);
}
//测试几种排序
void test5()
{
	Seqlist seq;
	Init(&seq);
	Pushback(&seq, 5);
	Pushback(&seq, 2);
	Pushback(&seq, 4);
	Pushback(&seq, 3);
	Pushback(&seq, 1);
	PrintSeqlist(&seq);
	BubbleSort(&seq);
	PrintSeqlist(&seq);
	Pushback(&seq, 4);
	Pushback(&seq, 3);
	SelsectSort(&seq);
	PrintSeqlist(&seq);
	InsertSort(&seq);
	PrintSeqlist(&seq);
}
//测试折半查找
void test6()
{
	Seqlist seq;
	Init(&seq);
	Pushback(&seq, 1);
	Pushback(&seq, 2);
	Pushback(&seq, 3);
	Pushback(&seq, 4);;
	BinarySearch(&seq, 1);
	PrintSeqlist(&seq);
}
int main()
{
	test1();
	test2();
	test3();
	test4();
	test5();
	test6();
	system("pause");
	return 0;
}