静态顺序表的初始化，基本操作及冒泡，选择排序应用

最新推荐文章于 2019-04-24 20:37:56 发布

shy_black

最新推荐文章于 2019-04-24 20:37:56 发布

阅读量629

点赞数 1

分类专栏：程序数据结构

本文链接：https://blog.csdn.net/shy_black/article/details/82773260

版权

数据结构同时被 2 个专栏收录

22 篇文章 2 订阅

订阅专栏

程序

8 篇文章 1 订阅

订阅专栏

静态顺序表主要掌握顺序表的基本操作和初始化顺序表，是初学数据结构者遇见的第一种存储结构，后续如果有什么想法的话会持续更新…
//2018.9.19

head.h

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


#define DataType int 
#define MAX 50

typedef struct SeqList
{
	DataType arr[MAX];
	int sz;
}Seq, *pSeqList;


//初始化 
void InitSeqList(pSeqList pSeq);
//尾部插入 
void PushBack(pSeqList pSeq, DataType data);
//尾部删除 
void PopBack(pSeqList pSeq);
//头部插入 
void PushFront(pSeqList pSeq, DataType data);
//头部删除 
void PopFront(pSeqList pSeq);
//查找指定元素 
int Find(pSeqList pSeq, DataType data);
//指定位置插入 
void Insert(pSeqList pSeq, int pos, DataType data);
//删除指定位置元素 
void Erase(pSeqList pSeq, int pos);
//删除指定元素 
void Remove_1(pSeqList pSeq, DataType data);
void Remove_2(pSeqList pSeq, DataType data);
//删除所有的指定元素 
void Remove_All(pSeqList pSeq, DataType data);
//返回顺序表的大小 
int Size(pSeqList pSeq);
//判断顺序表是否为空 
int Empty(pSeqList pSeq);
//冒泡排序 
void BubbleSort(pSeqList pSeq);
//选择排序 
void SelectSort(pSeqList pSeq);
//选择排序的优化 
void SelectSortOP(pSeqList pSeq);
//二分查找 
int BinarySearch(pSeqList pSeq, DataType data);
//二分查找递归写法 
//int BinarySearch_R(pSeqList pSeq, int left, int right, DataType d);

//打印 
void Show(pSeqList pSeq);
//反转
void Reverse(pSeqList Seq);
void test_push_pop();//头尾插入删除测试
void test_Find_Insert_Erase();//指定位置插入删除测试
void Test_Remove_RemoveAll();//删除指定元素及删除全部指定元素测试
void test_BubbleSort();//冒泡排序测试
void test_SelectSort();//选择排序及其优化测试

func.c

#include "head.h"

void InitSeqList(pSeqList Seq)
{
	assert(Seq);
	memset(Seq->arr, 0, sizeof(DataType)*MAX);
	Seq->sz = 0;
}
void PushBack(pSeqList Seq, DataType data)
{
	assert(Seq);
	if (Seq->sz == MAX)
	{
		printf("表满\n");
		return;
	}
	Seq->arr[Seq->sz] = data;
	Seq->sz++;
}
void PopBack(pSeqList Seq)
{
	assert(Seq);
	if (Seq->sz == 0)
	{
		printf("表空\n");
		return;
	}
	Seq->sz--;
}
void PushFront(pSeqList Seq, DataType data)
{
	assert(Seq);
	int i = Seq->sz;
	if (Seq->sz == MAX)
	{
		printf("表满\n");
		return;
	}
	for (i = Seq->sz-1; i >= 0; i--)
	{
		Seq->arr[i + 1] = Seq->arr[i];
	}
	Seq->arr[0] = data;
	Seq->sz++;
}

void PopFront(pSeqList Seq)
{
	assert(Seq);
	int i = 0;
	if (Seq->sz == 0)
	{
		printf("表空\n");
		return;
	}
	for (i = 0; i < Seq->sz-1; i++)
	{
		Seq->arr[i] = Seq->arr[i + 1];
	}
	Seq->sz--;
}
void Show(pSeqList Seq)
{
	assert(Seq);
	int i = 0;
	for (i = 0; i < Seq->sz; i++)
	{
		printf("%d ", Seq->arr[i]);
	}
	printf("\n");
	return;
}
//Find
int Find(pSeqList Seq, DataType data)
{
	assert(Seq);
	int i = 0;
	for (i = 0; i <= Seq->sz - 1; i++)
	{
		if (data == Seq->arr[i])
			return i;
	}
	return-1;
}
//Insert
void Insert(pSeqList Seq, int pos,DataType data)
{
	assert(Seq);
	int i = 0;
	if (pos > Seq->sz || pos < 0)
	{
		printf("非法插入\n");
		return;
	}
	for (int i = Seq->arr[Seq->sz-1]; i >= pos; i--)
	{
		Seq->arr[i + 1] = Seq->arr[i];
	}
	Seq->arr[pos] = data;
	Seq->sz++;
}
//Erase
void Erase(pSeqList Seq, int pos)
{
	assert(Seq);
	if (pos > Seq->sz || pos < 0)
	{
		printf("非法删除\n");
		return;
	}
	int i = 0;
	for (i = pos; i < Seq->sz - 1; i++)
	{
		Seq->arr[i] = Seq->arr[i+1];
	}
	Seq->sz--;
}
//Remove 删除指定元素
//void Remove_1(pSeqList Seq, DataType data)
//{
//	assert(Seq);
//
//	int i = 0, j = 0;
//	for (i = 0; i <= Seq->sz - 1; i++)
//	{
//		if (Seq->arr[i] == data)
//		{
//
//			for (j = i; j < Seq->sz-1; j++)
//			{
//				Seq->arr[j] = Seq->arr[j + 1];
//			}
//			Seq->sz--;
//			return;
//		}
//		
//	}
//}
void Remove_2(pSeqList Seq, DataType data)
{
	assert(Seq);
	int i = Find(Seq, data);//&Seq和直接Seq有啥区别
	Erase(Seq, i);
	return;
}
//Remove_All
void Remove_All(pSeqList Seq, DataType data)
{
	assert(Seq);
	
	while (1)
	{
		int i = Find(Seq, data);
		if (i == -1)
		{
			break;
		}
		Erase(Seq, i);
	}
}
//返回顺序表的大小 
int Size(pSeqList Seq)
{
	assert(Seq);
	int i = 0;
	while (Seq->arr[i] == '\0')
	{
		i++;
	}
	return i;

}
//判断顺序表是否为空 
int Empty(pSeqList Seq)
{
	assert(Seq);
	int i = 0;
	if (Seq->arr[0] == '\0')
		return 1;
	return 0;
}
//冒泡排序//小到大 
void BubbleSort(pSeqList Seq)
{
	int i = 0, j = 0;
	assert(Seq != NULL);
	for (i = 1; i < Seq->sz; i++)
	{
		for (j = 0; j < Seq->sz - i; 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;
			}
		}
	}
	return;
}
//选择排序 
void SelectSort(pSeqList Seq)
{
	assert(Seq);
	int i, j, min, tmp;
	for (i = 0; i < Seq->sz - 1; i++)
	{
		min = i;                         //min为记住的最小值的下标
		for (j = i + 1; j < Seq->sz; j++)
		if (Seq->arr[min] > Seq->arr[j])
			min = j;
		if (min != i)
		{
			tmp = Seq->arr[min];
			Seq->arr[min] = Seq->arr[i];
			Seq->arr[i] = tmp;
		}
	}
}

//选择排序的优化 
void SelectSortOP(pSeqList Seq)
{
	assert(Seq);
	int left = 0;
	int right = Seq->sz - 1;
	int tmp;
	while (left < right)
	{
		int min = left;
		int max = right;
		for (int i = left; i <= right; i++)
		{
			if (Seq->arr[i] < Seq->arr[min])
				min = i;
			if (Seq->arr[i] > Seq->arr[max])
				max = i;
		}

		tmp = Seq->arr[max];
		Seq->arr[max] = Seq->arr[right];
		Seq->arr[right] = tmp;

		if (min == right)
			min = max;

		tmp = Seq->arr[min];
		Seq->arr[min] = Seq->arr[left];
		Seq->arr[left] = tmp;
		left++;
		right--;
	}
}

//二分查找 --> 返回下标 
int BinarySearch(pSeqList Seq, DataType data)
{
	int left = 0, right = Seq->sz - 1, mid = (Seq->sz - 1) / 2;

	while (left <= right)
	{
		if (data < Seq->arr[mid])
		{
			right = mid - 1;
			mid = (left + right) / 2;
		}
		else if (data > Seq->arr[mid])
		{
			left = mid + 1;
			mid = (left + right) / 2;
		}
		else
			return mid;
	}
	return -1;
}
//二分查找递归写法 
int BinarySearch_R(pSeqList Seq, int left, int right, DataType d)
{
	int mid = (left + right) / 2;
	if (left <= right)
	{
		if (d < Seq->arr[mid])
			right = mid - 1;
		else if (d > Seq->arr[mid])
			left = mid + 1;
		else
			return mid;
		return BinarySearch_R(Seq, left, right, d);
	}
	return -1;

}
//反转顺序表
void Reverse(pSeqList Seq)
{
	assert(Seq);
	int i = 0;
	int	j = Seq->sz-1;
	while (i < Seq->sz/2)
	{
		DataType temp = Seq->arr[i];
		Seq->arr[i] = Seq->arr[j];
		Seq->arr[j] = temp;
		
		i++;
		j--;
	}
}

test.c

#include"head.h"

int main(void)
{

	//test_push_pop();//头尾插入删除测试
	//test_Find_Insert_Erase();//指定位置插入删除测试
	//Test_Remove_RemoveAll();//删除指定元素及删除全部指定元素测试
	//test_BubbleSort();//冒泡排序测试
	test_SelectSort();//选择排序及其优化测试

	system("pause");
}
void test_push_pop()
{
	//assert(Seq);
	Seq Seq;
	InitSeqList(&Seq);
	PushBack(&Seq, 1);
	PushBack(&Seq, 2);
	PushBack(&Seq, 3);
	PushBack(&Seq, 4);
	PopBack(&Seq);
	Show(&Seq);
	PushFront(&Seq, 5);
	PushFront(&Seq, 4);
	PushFront(&Seq, 3);
	PushFront(&Seq, 2);
	PushFront(&Seq, 1);
	PopFront(&Seq);

	Show(&Seq);
}
void test_Find_Insert_Erase()
{
	Seq Seq;
	InitSeqList(&Seq);
	PushBack(&Seq, 1);
	PushBack(&Seq, 2);
	PushBack(&Seq, 3);
	PushBack(&Seq, 4);
	PushBack(&Seq, 5);
	Show(&Seq);
	printf("Find->%d\n",Find(&Seq, 2));

	Insert(&Seq, 1, 10);
	printf("Show->");
	Show(&Seq);
	Erase(&Seq, 1);

	Erase(&Seq,-1);
	printf("Erase->");
	Show(&Seq);

	system("pause");
}
void Test_Remove_RemoveAll()
{
	Seq Seq;
	InitSeqList(&Seq);
	PushBack(&Seq, 1);
	PushBack(&Seq, 2);
	PushBack(&Seq, 2);
	PushBack(&Seq, 2);
	PushBack(&Seq, 2);
	PushBack(&Seq, 3);
	PushBack(&Seq, 4);
	Remove_2(&Seq, 3);
	printf("Remove->");
	Show(&Seq);
	Remove_All(&Seq, 2);
	printf("Remove_All->");
	Show(&Seq);

}
void test_BubbleSort()
{
	Seq Seq;
	InitSeqList(&Seq);
	PushBack(&Seq, 5);
	PushBack(&Seq, 3);
	PushBack(&Seq, 1);
	PushBack(&Seq, 2);
	PushBack(&Seq, 4);
	Show(&Seq);
	BubbleSort(&Seq);
	Show(&Seq);

}
void test_SelectSort()
{
	Seq Seq;
	InitSeqList(&Seq);
	PushBack(&Seq, 5);
	PushBack(&Seq, 3);
	PushBack(&Seq, 1);
	PushBack(&Seq, 2);
	PushBack(&Seq, 4);
	PushBack(&Seq, 6);
	Show(&Seq);

	SelectSort(&Seq);
	Show(&Seq);

	Reverse(&Seq);
	Show(&Seq);

	SelectSortOP(&Seq);
	Show(&Seq);
}

shy_black

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
静态顺序表的初始化，基本操作及冒泡，选择排序应用

静态顺序表主要掌握顺序表的基本操作和初始化顺序表，是初学数据结构者遇见的第一种存储结构，后续如果有什么想法的话会持续更新…//2018.9.19head.h#include&amp;lt;stdio.h&amp;gt;#include&amp;lt;stdlib.h&amp;gt;#include&amp;lt;assert.h&amp;gt;#include&amp;lt;string.h&amp;gt;#
复制链接

扫一扫

专栏目录