静态顺序表基本操作实现

   静态顺序表实际上是运用了数组的知识，通过数组分配空间来存储表的信息，可以实现以下几个基本操作

1.初始化

2.扩大表的容量

3.查找指定元素

4.尾插元素

6.尾删元素

7.头插元素

8.头删元素

9.删除指定下标元素

10.添加指定下标元素

11.删除指定元素

12.删除值为X的所有元素（时间复杂度为O(n),空间复杂度为O(1)  ）

13.冒泡排序

14.选择排序

头文件：

#define MAX 1000
#pragma once  //防止头文件包含
typedef int ListType;
typedef struct
{
	ListType data[MAX];
	size_t size;//size_t就是unsigned int
}list;

void InitList(list *p);//初始化

操作函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include"test1.h"
#include<assert.h>
#include<Windows.h>
list Seq;
void InitList(list *seq)//初始化
{
	assert(seq);
	seq->size = 0;
}

//这里的下标不是数组下标，而是第一个元素

//找到指定元素并返回下标
int Find(list *seq,int value)
{
	assert(seq);
	size_t i = 0;
	for (i = 0; i < seq->size; i++)
	{
		if (seq->data[i] == value)
		{
			return i;//返回数组下标
		}
	}
	return -1;
}

//尾插元素
void PushEnd(list *seq,int value)
{
	assert(seq);
	if (seq->size == MAX)//判断表满
	{
		printf("The list is full！\n");
		return;
	}
	else
	{
		seq->data[seq->size] = value;
		seq->size++;
	}
}


//尾删元素
void PopEnd(list *seq)
{
	assert(seq);
	if (seq->size == 0)//判断表空
	{
		printf("The list is empty!\n");
		return;
	}
	seq->size--;
}

//头插元素
void PushHead(list *seq, int value)
{
	assert(seq);
	if (seq->size == MAX)//判断表满
	{
		printf("The list is full！\n");
		return;
	}
	seq->size++;
	size_t i = 0;
	for (i = seq->size; i >0; i--)
	{
		seq->data[i] = seq->data[i-1];
	}
	seq->data[0] = value;
}


//头删元素
void Pophead(list *seq)
{
	assert(seq);
	if (seq->size == 0)//判断表空
	{
		printf("The list is empty!\n");
		return;
	}
	size_t i = 0;
	for (i = 0; i<seq->size-1; i++)
	{
		seq->data[i] = seq->data[i + 1];
	}
	seq->size--;
}

//删除指定下标元素
void Pop(list *seq, int ret)
{
	assert(seq);
	if (seq->size == 0)
	{
		printf("The list is empty!\n");
		return;
	}
	size_t i = 0;
	for (i = ret; i < seq->size; i++)
	{
		seq->data[ret - 1] = seq->data[ret];
	}
	seq->size--;
}

//添加指定下标元素
void Push(list *seq, size_t ret,int value)
{
	assert(seq);
	if (seq->size > MAX)
	{
		printf("The list is full!\n");
		return;
	}
	
	size_t i = 0;
	for (i = seq->size; i > ret-1; i--)
	{
		seq->data[i] = seq->data[i-1];
	}
	seq->data[ret -1] = value;
	seq->size++;
}

//删除指定元素
void PopValue(list *seq, int value)
{
	assert(seq);
	int ret = Find(seq, value);
	if (ret<0)
	{
		printf("没找到！\n");
	}
	else
	{
		Pop(seq, ret + 1);
	}
}

//删除值为X的所有元素
void PopAll(list *seq, int value)
{
	size_t i = 0;
	size_t index = 0;
	for (i = 0; i<seq->size; i++)
	{
		if (seq->data[i] != value)
		{
		
			seq->data[index] = seq->data[i];
			index++;
		}
	}
	seq->size = index;
}

//冒泡排序
void BobSort(list *seq)
{
	assert(seq);
	size_t i = 0;
	size_t j = 0;
	for (i = 0; i < seq->size - 1; i++)
	{
		for (j = 0; j < seq->size - 1 - i; j++)
		{
			if (seq->data[j] > seq->data[j + 1])
			{
				seq->data[j] ^= seq->data[j + 1];
				seq->data[j + 1] ^= seq->data[j];
				seq->data[j] ^= seq->data[j + 1];
			}
		}
	}
}
   
//选择排序
void SeleSort(list *seq)
{
	assert(seq);
	size_t i = 0;
	size_t j = 0;
	for (i = 0; i < seq->size; i++)
	{
		size_t min = i;
		for (j = i + 1; j < seq->size; j++)//找到每次最小值  
		{
			if (seq->data[min] > seq->data[j])
			{
				min = j;
			}
		}

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

		}
	}
}

//打印元素
void Print(list *seq)
{
	assert(seq);
	size_t i = 0;
	for (i = 0; i < seq->size; i++)
	{
		printf("%d->", seq->data[i]);
	}
}


void delall(list *l, int x)
{
	size_t i = 0, j;
	while (i<l->size && l->data[i] != x)
		i++;
	for (j = i + 1; j<l->size; j++)
	if (l->data[j] != x)
	{
		l->data[i++] = l->data[j];
	}
	l->size = i;
}
int main()
{
	InitList(&Seq);
	PushEnd(&Seq, 1);
	PushEnd(&Seq, 9);
	PushEnd(&Seq, 7);
	PushEnd(&Seq, 3);
	PushEnd(&Seq, 5);
	

	//PushEnd(&Seq, );
	//PopEnd(&Seq);
	//Push(&Seq, 2,10);
	//PopValue(&Seq, 3);
	//PopAll(&Seq,3 );
	//BobSort(&Seq);
	SeleSort(&Seq);
	//delall(&Seq, 3);
	//PushHead(&Seq, 60);
	printf("\n");
	//printf("%d\n", Find(&Seq, 3));
	Print(&Seq);
	system("pause");
	return 0;
}