数据结构线性表顺序表实现

望着太阳说那啥

已于 2023-04-01 13:58:22 修改

阅读量67

点赞数

文章标签：数据结构 c++ 算法

于 2023-04-01 13:30:39 首次发布

本文链接：https://blog.csdn.net/qq_44000144/article/details/129807114

版权

一、线性结构

线性结构的特点是：在数据元素的非空有限集中，存在唯一的一个被称作第一个的数据元素，存在唯一的一个被称做最后一个的数据元素，除第一个之外，集合中的每个数据元素均只有一个前驱，除最后一个外，集合中每个数据元素均只有一个后继。

二、线性表的顺序表示和实现

1.定义

线性表的顺序表示指的是用一组地址连续的存储单元一次存储线性表的数据元素

2、实现

SeqLIst.h

#ifndef __SEQLIST_H__
#define __SEQLIST_H__
#include<stdio.h>
#include<malloc.h>
#include<assert.h>

#define SEQLIST_INIT_SIZE 8
#define INC_SIZE		  3

typedef int ElemType;

typedef struct SeqList
{
	ElemType* base;
	int capacity;
	int size;
}SeqList;

bool Inc(SeqList* list);
void InitSeqList(SeqList *list);
void push_back(SeqList *list, ElemType x);
void push_front(SeqList *list, ElemType x);
void show_list(SeqList *list);
void pop_back(SeqList *mylist);
void pop_front(SeqList *mylist);
void insert_pos(SeqList *list, int pos, ElemType x);
int find(SeqList *list, ElemType x);
int length(SeqList *mylist);
void delete_pos(SeqList *mylist, int pos);
void delete_val(SeqList *mylist, int Item);
void sort(SeqList* mylist);
void reserve(SeqList *list);
void clear(SeqList *mylist);
void destroy(SeqList *mylist);

#endif //__SEQLSIT_H__

SeqList.cpp


void main()
{
	SeqList myList;
	InitSeqList(&myList);
	ElemType Item;
	int select = 1;
	int pos = 0;
	while (select)
	{
		printf("*********************************************\n");
		pirntf("* [1]  push_back			[2]  push_front *\n");
		pirntf("* [3]  show_list			[4]  pop_back   *\n");
		pirntf("* [5]  pop_front			[6]  insert_pos *\n");
		pirntf("* [7]  find			        [8]  length     *\n");
		pirntf("* [9]  delete_pos			[10] delete_val *\n");
		pirntf("* [11] sort		            [12] resver     *\n");
		pirntf("* [13] clear		        [14] destroy    *\n");
		pirntf("* [0]  quit_system						    *\n");
		printf("*********************************************\n");
		printf("请选择：>");
		scanf("%d", &select);
		if (select == 0)
			break;
		switch (select)
		{
		case 1:
			printf("请输入要插入的数据(-1结束)：>");
			while (scanf("%d", &Item), Item != -1)
			{
				push_back(&mylist, Item);
			}
			break;
		case 2:
			printf("请输入要插入的数据(-1结束)：>");
			while (scanf("%d", &Item), Item != -1)
			{
				push_back(&mylist, Item);
			}
			break;
		case 3:
			show_list(&mylist);
			break;
		case 4:
			pop_back(&mylist);
			break;
		case 5:
			pop_front(&mylist);
			break;
		case 6:
			printf("请输入要插入的数据：>");
			scanf("%d", &Item);
			printf("请输入要插入的数据的位置：>");
			scanf("%d", &pos);
			insert_pos(&mylist, pos, Item);
			break;
		case 7:
			printf("请输入要查找的数据：>");
			scanf("%d", &Item);
			pos = find(&mylist, Item);
			if (pos == -1)
				printf("查找的数据 %d 在顺序表中不存在。\n", Item);
			else
			{
				printf("查找的数据 %d 在顺序表中存在,地址为 %d。\n", Item, pos);
			}

			break;
		case 8:
			printf("顺序表的长度为：%d\n", length(&myliist));
			break;
		case 9:
			printf("请输入要删除数据的位置：>");
			scanf("%d", &pos);
			delete_pos(&mylist, pos);
			break;
		case 10:
			printf("请输入要删除的数据：>");
			scanf("%d", &Item);
			delete_val(&mylist, Item);
			break;
		case 11:
			sort(&mylist);
			break;
		case 12:
			rseerve(&mylist);
			break;
		case 13:
			clear(&mylist);
			break;
		case 14:
			destroy(&mylist);
			break;
		default:
			printf("输入的选择错误，请重新输入.\n");
			destroy(&mylist);
			break;
		}

	}
}

void InitSeqList(SeqList* list)
{
	list->base = (ElemType*)malloc(sizeof(ElemType) * SEQLIST_INIT_SIZE);
	assert((list->base) != NULL);
	list->capacity = SEQLIST_INIT_SIZE;
	list->size = 0;
}

void push_back(SeqList* list, ElemType x)
{
	if (list->size >= list->capacity && !Inc(list))
	{
		printf("顺序表空间已满，不能尾部插入数据.\n");
		return;
	}
	list->base[list->size] = x;
	list->size++;

}

void push_front(SeqList* list, ElemType x)
{
	if (list->size >= list->capacity && !Inc(list))
	{
		printf("顺序表空间已满，不能头部插入数据.\n");
		return;
	}

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

void show_list(SeqList* list)
{
	for (int i = 0; i < list->size; ++i)
	{
		printf("%d", list->base[i]);
	}
	printf("\n");
}

void pop_back(SeqList* mylist)
{
	if (list->size == 0)
	{
		printf("顺序表已空，不能尾部删除数据");
		return;
	}
	list->size--;

}

void pop_front(SeqList* mylist)
{
	if (list->size == 0)
	{
		printf("顺序表已空，不能头部删除数据");
		return;
	}
	for (int i = 1; i < list->size; i++)
	{
		mylist->base[i - 1] = mylist->base[i];
	}
	mylist->size--;
}

void insert_pos(SeqList* list, int pos, ElemType x)
{
	if (list->size >= list->capacity && !Inc(list))
	{
		printf("顺序表空间已满，不能头部插入数据.\n");
		return;
	}

	if (pos >= 0 && pos <= list->size)
	{
		/*if (pos == 0)
		{
			push_front(list, x);
		}
		else if (pos == list->size)
		{
			push_back(list, x);
		}
		else
		{
			for (int i = list->size; i > pos; i--)
			{
				list->base[i] = list->base[i - 1];
			}
			list->base[pos] = x;
			list->size++;
		}*/
		for (int i = list->size; i > pos; i--)
		{
			list->base[i] = list->base[i - 1];
		}
		list->base[pos] = x;
		list->size++;
	}
	else
	{
		printf("插入数据的位置非法，不能插入数据");
		return;
	}
}

int find(SeqList* list, ElemType x)
{
	for (int i = 0; i < list->size; i++)
	{
		if (list->base[i] == x)
		{
			return i;
		}
		return -1;
	}
}

int length(SeqList* mylist)
{
	return mylist->size;
}

void delete_pos(SeqList* mylist, pos)
{
	if (pos < 0 || pos >= mylist->size)
	{
		pirntf("删除数据的位置非法，不能删除数据");
		return;
	}
	for (int i = pos; i < mylist->size; i++)
	{
		mylist->base[i] = mylist->base[i + 1];
	}
}

void delete_val(SeqList* mylist, int Item)
{
	int pos = find(mylist, Item);
	if (pos == -1)
	{
		printf("要删除的数据不存在");
		return;
	}

	delete_pos(mylist, pos);
}

void sort(SeqList* list)
{
	for (int i = 0; i < list->size - 1; i++)
	{
		for (int j = 0; j < list->size - 1 - i; j++)
		{
			if (list->base[j] > list->base[j + 1])
			{
				ElemType tmp = list->base[j];
				list->base[j] = list->[j + 1];
				list->[j + 1] = list->tmp;
			}
		}
	}
}

void reserve(SeqList* mylist)
{
	if (list->size == 0 || list->size == 1)
		return 0;
	int low = 0;
	int high = list->size - 1;
	ElemType tmp;
	while (low < high)
	{
		tmp = list->base[low];
		list->base[low] = list->base[high];
		list->base[high] = tmp;
		low++;
		high--;
	}
}

void clear(SeqList* list)
{
	list->size = 0;
}

void destroy(SeqList* list)
{
	free(list->base);
	list->base = NULL;
	list->size = 0;
}

bool Inc(SeqList* list)
{

	ElemType* newbase = (ElemType*)realloc(list->base, sizeof(ElemType) * (list->capacity + INC_SIZE));
	if (newbase == NULL)
	{
		printf("增加空间失败，内存不足\n");
		return false;
	}
	list->base = newbase;
	list->capacity += INC_SIZE;
	return true;
}