动态顺序表基本操作实现

动态顺序表实际是在静态顺序表改变过来的，基本思想和静态顺序表差不多，唯一的区别就是动态分配了空间，空间不够可以增加，弥补了静态顺序表的缺陷。

基本操作

1.初始化

2.扩大表的容量

3.查找指定元素

4.尾插元素

6.尾删元素

7.头插元素

8.头删元素

9.删除指定下标元素

10.添加指定下标元素

11.删除指定元素

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

13.冒泡排序

14.选择排序

头文件：

#define MAX 10
#pragma once  //防止头文件包含
typedef int DataType;
typedef struct
{
	DataType* elem;
	size_t size;//size_t就是unsigned int，有效长度
	int capacity;//容量
}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)//初始化
{
	Seq->elem = (DataType*)malloc(MAX*sizeof(DataType));
	Seq->capacity = MAX;
	Seq->size = 0;
}


//扩大容量
void EXP(list *seq)
{
	assert(seq);
	if (seq->size >= seq->capacity)
	{
		seq->capacity = seq->capacity * 2;
		DataType* newelem = (DataType*)malloc(seq->capacity*sizeof(DataType));
		memcpy(newelem, seq->elem, seq->size*sizeof(DataType));//两块内存合并
		free(seq->elem);
		seq->elem = newelem;
	}
}

//找到指定元素并返回下标
int Find(list *seq, int value)
{
	assert(seq);
	size_t i = 0;
	for (i = 0; i < seq->size; i++)
	{
		if (seq->elem[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->elem[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->elem[i] = seq->elem[i - 1];
	}
	seq->elem[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->elem[i] = seq->elem[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->elem[ret - 1] = seq->elem[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->elem[i] = seq->elem[i - 1];
	}
	seq->elem[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->elem[i] != value)
		{

			seq->elem[index] = seq->elem[i];
			index++;
		}
	}
	seq->size = index;
}

//冒泡排序
void BobSort(list *seq)
{
	assert(seq);
	size_t i = 0;
	size_t j = 0;
	int flag = 0;
	for (i = 0; i < seq->size - 1; i++)
	{
		for (j = 0; j < seq->size - 1 - i; j++)
		{
			if (seq->elem[j] > seq->elem[j + 1])
			{
				seq->elem[j] ^= seq->elem[j + 1];//交换两数 
				seq->elem[j + 1] ^= seq->elem[j];
				seq->elem[j] ^= seq->elem[j + 1];
				flag = 1;
			}
		}

		if (flag == 0)      //如果第一轮比较没有交换过，说明是序列本来是升序的
		{
			return ;
		}
	}
}

//选择排序
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->elem[min] > seq->elem[j])
			{
				min = j;
			}
		}
		
		if (i != min)
		{
			/*DataType t = seq->elem[min];
			seq->elem[min] = seq->elem[i];
			seq->elem[i] = t;*/
			seq->elem[min] ^= seq->elem[i];
			seq->elem[i] ^= seq->elem[min];
			seq->elem[min] ^= seq->elem[i];

		}
	}
}

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


void delall(list *l, int x)
{
	size_t i = 0, j;
	while (i<l->size && l->elem[i] != x)
		i++;
	for (j = i + 1; j<l->size; j++)
	if (l->elem[j] != x)
	{
		l->elem[i++] = l->elem[j];
	}
	l->size = i;
}

int main()
{
	InitList(&Seq);

       if (Seq.elem == NULL)//是否开辟成功的判断；  
		printf("out of memory\n");

        PushEnd(&Seq, 1);

	PushEnd(&Seq, 9);

	PushEnd(&Seq, 7);
	PushEnd(&Seq, 3);
	PushEnd(&Seq, 5);
	printf("\n");
	//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("%d\n", Find(&Seq, 3));
	Print(&Seq);
	system("pause");
	return 0;
}

动态顺序表基本操作实现

猜你喜欢