线性表的实现

实现线性表的各类操作：

void InitSeqList(SeqList *list); //初始化线性表

int begain(SeqList *list); //线性表的初始位置（返回第一个下标即0）

int end(SeqList *list); //末位置（返回最后一个元素的下标）

bool Isfull(SeqList *list); //判断是否已满

bool Isempty(SeqList *list); //判断是否为空

bool Insert_pos(SeqList *list,int n,ElemType x); //按下标插入元素

bool Push_back(SeqList *list,ElemType item); //尾插法

bool Push_front(SeqList *list,ElemType item); //头插法

bool show(SeqList *list); //输出线性表的所有元素

bool Pop_back(SeqList *list); //尾删法

bool Pop_front(SeqList *list); //头删法

int find(SeqList *list,ElemType val); //查找某个元素是否存在

bool Delete_pos(SeqList *list,int pos); //按下标删除

bool Delete_val(SeqList *list,ElemType val); //按值删除

bool Modify(SeqList *list,ElemType val); //修改

int Getval(SeqList *list,int pos); //求某个下标所对应的值

void next(SeqList *list,ElemType val); //求后继

void prio(SeqList *list,ElemType val); //求前驱

void reverse(SeqList *list); //反转数组元素

void clear(SeqList *list); //清除线性表

void destory(SeqList *list); //销毁线性表

void ascend_sort(SeqList *list); //升序排列

void descend_sort(SeqList *list); //降序排列

SeqList.h：

#ifndef __SEQLIST_H__
#define __SEQLIST_H__
#include<stdlib.h>
#include<stdio.h>
#include<malloc.h>
#include<iostream.h>
#define FAULT_STRING_SIZE 100
typedef int ElemType;

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

void InitSeqList(SeqList *list);                //初始化线性表
int begain(SeqList *list);                      //线性表的初始位置（返回第一个下标即0）
int end(SeqList *list);                         //末位置（返回最后一个元素的下标）
bool Isfull(SeqList *list);                     //判断是否已满
bool Isempty(SeqList *list);                    //判断是否为空
bool Insert_pos(SeqList *list,int n,ElemType x);//按下标插入元素
bool Push_back(SeqList *list,ElemType item);    //尾插法
bool Push_front(SeqList *list,ElemType item);   //头插法
bool show(SeqList *list);                       //输出线性表的所有元素
bool Pop_back(SeqList *list);                   //尾删法
bool Pop_front(SeqList *list);                  //头删法
int  find(SeqList *list,ElemType val);          //查找某个元素是否存在
bool Delete_pos(SeqList *list,int pos);         //按下标删除
bool Delete_val(SeqList *list,ElemType val);    //按值删除
bool Modify(SeqList *list,ElemType val);        //修改
int  Getval(SeqList *list,int pos);             //求某个下标所对应的值
void next(SeqList *list,ElemType val);          //求后继
void prio(SeqList *list,ElemType val);          //求前驱
void reverse(SeqList *list);                    //反转数组元素
void clear(SeqList *list);                      //清除线性表
void destory(SeqList *list);                    //销毁线性表
void ascend_sort(SeqList *list);                //升序排列
void descend_sort(SeqList *list);               //降序排列
#endif

SeqList.cpp

#include"SeqList.h"
//初始化线性表
void InitSeqList(SeqList *list)
{
	list->capacity= FAULT_STRING_SIZE;
	list->base = (ElemType *)malloc(sizeof(ElemType)*list->capacity);
	list->size = 0;
}
//判断是否已满
bool Isfull(SeqList *list)
{
	return (list->capacity == list->size);
}
//判断是否为空
bool Isempty(SeqList *list)
{
	return (list->size == 0);
}
//尾插法
bool Push_back(SeqList *list,ElemType item)
{
	Insert_pos(list,end(list),item);
	return true;
}
/*bool Push_back(SeqList *list,ElemType item)
{

	if(Isfull(list))
	{
		return false;
	}
	list->base[list->size] = item;
	list->size++;
	return true;
}*/
//头插法
bool Push_front(SeqList *list,ElemType item)
{
	Insert_pos(list,begain(list),item);
	return true;

}
/*bool Push_front(SeqList *list,ElemType item)
{
	if(Isfull(list))
	{
		return false;
	}

	for(int i=list->size-1;i>=0;--i)
	{
		list->base[i+1] = list->base[i];
	}
	list->base[0] = item;
	list->size++;
	return true;
}*/
//输出线性表的所有元素
bool show(SeqList *list)
{
	if(Isempty(list))
	{
		return false;
	}
	for(int i=0;i<list->size;i++)
	{
		printf("%d\n",list->base[i]);
	}
	return true;
}
//按下标插入元素
bool Insert_pos(SeqList *list,int pos,ElemType item)
{
	if(Isfull(list))
	{
		return false;
	}
	if(pos < 0 || pos > list->size)
	{
		return false;
	}
	for(int i=list->size-1;i>=pos;--i)
	{
		list->base[i+1] = list->base[i];
	}
	list->base[pos] = item;
	list->size++;
	return true;
}
//线性表的初始位置（返回第一个下标即0）
int begain(SeqList *list)
{
	return 0;
}
//末位置（返回最后一个元素的下标）
int end(SeqList *list)
{
	return list->size;
}
//尾删法
/*bool Pop_back(SeqList *list)
{
	if(Isempty(list))
	{
		return false;
	}
	list->size--;
	return true;
}*/
bool Pop_back(SeqList *list)
{
	Delete_pos(list,end(list));
	return true;
}
//头删法
/*bool Pop_front(SeqList *list)
{
	if(Isempty(list))
	{
		return false;
	}
	for(int i=1;i<list->size;i++)
	{
		list->base[i-1] = list->base[i];
	}
	list->size--;
	return true;
}*/
bool Pop_front(SeqList *list)
{
	Delete_pos(list,begain(list)-1);
	return true;
}
//按下标删除
bool Delete_pos(SeqList *list,int pos)
{
	if(Isempty(list))
	{
		return false;
	}
	if(pos<0 || pos>=list->size)
	{
		return false;
	}
	for(int i=pos+1;i<list->size;++i)
	{
		list->base[i-1] = list->base[i];
	}
	list->size--;
	printf("it is deleted!\n");
	return true;
}
//查找某个元素是否存在
int find(SeqList *list,ElemType val)
{
	for(int i=0;i<list->size;++i)
	{
		if(val == list->base[i])
		{
			return i;
		}
	}
	return -1;
}
 //按值删除
bool Delete_val(SeqList *list,ElemType val)
{
	if(Isempty(list))
	{
		return false;
	}
	int pos = find(list,val);
	if(-1 != pos)
	{
		Delete_pos(list,pos);
	}
	else
		printf("it's not exist!\n");
	return true;
}
//求某个下标所对应的值
ElemType Getval(SeqList *list,int pos)
{
	if(pos >= list->size)
	{
		printf("input error!\n");
		return -1;
	}
	return list->base[pos];
}
//修改
bool Modify(SeqList *list,ElemType val)//bool Modify(SeqList *list,ElemType val);
{
	int n = find(list,val);
	int value;
	if(-1 != n)
	{
		printf("please input a new val:\n");
		scanf("%d",&value);
		list->base[n] = value;
		printf("it's modified!\n");
		return true;
	}
	printf("it's not exist!\n");
	return false;
}
 //求后继
void next(SeqList *list,ElemType val)
{
	int n = find(list,val);
	if(-1 != n)
	{
		if(n == (list->size - 1))
		{
			printf("it don't have next!\n");
		}
		else
			printf("it's next is %d\n",list->base[n+1]);
	}
	else
		printf("the value you put is not exist!\n");
}
//求前驱
void prio(SeqList *list,ElemType val)
{
	int n = find(list,val);
	if(-1 != n)
	{
		if(n == 0)
		{
			printf("it don't have prio!\n");
		}
		else
			printf("it's prio is %d\n",list->base[n-1]);
	}
	else
		printf("the value you put is not exist!\n");

}
//反转数组元素
void reverse(SeqList *list)
{
	int left = 0;
	int right = list->size - 1;
	ElemType temp;
	while(left<=right)
	{
		temp = list->base[left];
		list->base[left] = list->base[right];
		list->base[right] = temp;
		left++;
		right--;
	}
	printf("it is reversed!\n");
}
//清除线性表
void clear(SeqList *list)
{
	list->size = 0;
	printf("the list is clear!\n");
}
//销毁线性表
void destory(SeqList *list)
{
	free(list->base);
	printf("the list is destoryed!\n");
}
 //升序排列
void ascend_sort(SeqList *list)
{
	int i;
	int j;
	int k;
	ElemType temp;
	for(i=0;i<list->size -1;++i) //选择排序(升序排列)
	{
		k = i;
		for(j=i;j<list->size;++j)
		{
			if(list->base[j] < list->base[k])
			{
				k = j;
			}
		}
		if(k != i)
		{
			temp = list->base[i];
			list->base[i] = list->base[k];
			list->base[k] = temp;
		}
	}
	printf("they are resorted!\n");
}
 //降序排列
void descend_sort(SeqList *list)//冒泡排序（降序）
{
	int i;
	int j;
	ElemType temp;
	for(i=0;i<list->size-1;++i)
	{
		for(j=0;j<list->size -1-i;++j)
		{
			if(list->base[j] > list->base[j+1])
			{
				temp = list->base[j];
				list->base[j] = list->base[j+1];
				list->base[j+1] = temp;
			}
		}
	}
	printf("they are resorted!\n");
}

main.cpp

#include"SeqList.h"
int main()
{
	SeqList mylist;
	ElemType item;
	int choice;
	int i = 1;
	int pos;
	int value;
	syatem("mode con cols=100 lines=100");
	while(i)
	{
		printf("*****************SeqList********************\n");
		printf("                                ---zyh_helen\n");
		printf("*[1]InitSeqList           [2]Push_back   *\n");
		printf("*[3]Push_front            [4]Pop_back    *\n");
		printf("*[5]Pop_front             [6]Delete_pos  *\n");
		printf("*[7]show                  [8]insert_pos  *\n");
		printf("*[9]Delete_val            [10]find       *\n");
		printf("*[11]Getval               [12]Modify     *\n");
		printf("*[13]next                 [14]prio       *\n");
		printf("*[15]reverse              [16]clear      *\n");
		printf("*[17]destory              [18]ascend_sort*\n");
		printf("*[19]descend_sort         [0]quit_system *\n");

		printf("please input the num of the fuction :\n");
		scanf("%d",&choice);
		switch(choice)
		{
			case 1:
				InitSeqList(&mylist);
				break;
			case 2:
				printf("please input the num you want to push_front: (-1 as a break)\n");
				while(cin>>item,item != -1)
				{
					Push_back(&mylist,item);
				}
				break;
			case 3:
				printf("please input the num you want to push_front: (-1 as a break)\n");
				while(cin>>item,item != -1)
				{
					Push_front(&mylist,item);
				}
				break;
			case 4:
				Pop_back(&mylist);
				break;
			case 5:
				Pop_front(&mylist);
				break;
			case 6:
				printf("please input the pos:\n");
				scanf("%d",&pos);
				Delete_pos(&mylist,pos);
				break;
			case 7:
				show(&mylist);
				break;
			case 8:
				printf("please input the pos:\n");
				scanf("%d",&pos);
				int num;
				printf("please input the num:\n");
				scanf("%d",&num);
				Insert_pos(&mylist,pos,num);
				break;
			case 9:
			//	int val;
				printf("please input the val you want to delete:\n");
				scanf("%d",&value);
				Delete_val(&mylist,value);
				break;
			case 10:
				printf("please input the value you want to find:\n");
		//		int value;
				scanf("%d",&value);
				int m;
				m = find(&mylist,value);//!!!!!!!!!!!int m= find(&mylist,value)
				if( m != -1)
				{
					printf("the value is found ,it's pos is %d\n",m);
				}
				else
				{
					printf("it is not exist!\n");
				}
				break;
			case 11:
				printf("please input the pos:\n");
				scanf("%d",&pos);
				if(Getval(&mylist,pos) != -1)
				{
					printf("the val is %d\n",Getval(&mylist,pos));
				}
				break;
			case 12:
				printf("please input the value you want to modify:\n");
		//		int value2;
				scanf("%d",&value);
				Modify(&mylist,value);
				break;
			case 13:
				printf("Please input a value:\n");
				scanf("%d",&value);
				next(&mylist,value);
				break;
			case 14:
				printf("Please input a value:\n");
				scanf("%d",&value);
				prio(&mylist,value);
				break;
			case 15:
				reverse(&mylist);
				break;
			case 16:
				clear(&mylist);
				break;
			case 17:
				destory(&mylist);
				break;
			case 18:
				ascend_sort(&mylist);
				break;
			case 19:
				descend_sort(&mylist);
				break;
			default:
				i = 0;
				break;
		}
	}

	return 0;
}

以下显示部分测试：没有测试的，望读者自行验证：

Pop_back & show:

push_front & show:

Pop_back& show:

Pop_front & show:

Delete_pos:下标为1的5被删了

insert_pos

Delete val:

ascend_sort(升序)：

时间： 2024-07-29 15:30:32

线性表的实现的相关文章

线性表---顺序表

线性结构的特点是:在非空的有限集合中,只有唯一的第一个元素和唯一的最后一个元素.第一个元素没有直接前驱元素,最后一个没有直接的后继元素.其它元素都有唯一的前驱元素和唯一的后继元素. 线性表是一种最简单的线性结构.线性表可以用顺序存储结构和链式存储结构存储,可以在线性表的任意位置进行插入和输出操作. 要想将线性表在计算机上实现,必须把其逻辑结构转化为计算机可识别的存储结构.线性表的存储结构主要有两种:顺序存储结构和链式存储结构. 线性表的顺序表示与实现线性表的顺序存储结构线性表的顺序存储结构指

数据结构笔记2 线性表

线性表是最简单,最常用的一种数据结构,它是由n个数据元素(结点)组成的有限序列. 线性表的基本运算 1.置空表 InitList(L) ,构造一个空的线性表L 2.求表长 ListLength(L) ,返回线性表L中元素个数,即表长. 3.取表中第i个元素GetNode(L,i) ,若1 <= i <= ListLength(L) ,则返回第i个元素a[i] 4.按值查找LocateNode(L,x),在表L中查找第一个值为x的元素,并返回该元素在表L中的位置,若表中没有元素的值为x,则返回0

数据结构与算法之线性表

前言上一篇<数据结构和算法之时间复杂度和空间复杂度>中介绍了时间复杂度的概念和常见的时间复杂度,并分别举例子进行了一一说明.这一篇主要介绍线性表. 线性表属于数据结构中逻辑结构中的线性结构.回忆一下,数据结构分为物理结构和逻辑结构,逻辑结构分为线性结构.几何结构.树形结构和图形结构四大结构.其中,线性表就属于线性结构.剩余的三大逻辑结构今后会一一介绍. 线性表基本概念线性表(List):由零个或多个数据元素组成的有限序列. 注意: 1.线性表是一个序列. 2.0个元素构成的线性表是空表.

数据导论——线性表

线性表是一种线性结构,由n个数据元素组成的又穷序列,数据元素又称为节点,线性表中的每个数据元素的含义,在不同的应用中各不相同,但在同一个线性表中的数据元素具有相同的特性. 下面的图总结了第二章的主要内容,用于总结和回想,巩固学习: 线性表的基本运算包括:初始化.求表长.读表元素.定位.插入.删除等基本运算,不同的存储结构实现细节可能不同. 在线性表的存储方式有顺序存储和链式存储. 顺序存储的存储方式是最简单的,逻辑顺序对应于存储顺序,数组就是顺序表的表现之一.顺序存储的运算包括插入.删除和定位,

数据结构——线性表顺序存储结构

关于线性表线性表是零个或者多个数据元素的集合.它主要有以下三个特征: 1:线性表的数据元素之间是有顺序的. 2:线性表中数据元素个数是有限的. 3:线性表中数据元素数据类型是相同的. 关于线性表的操作,主要有创建线性表.销毁线性表.清空线性表.将元素插入线性表.将元素从线性表中删除.获取线性表中某个位置的元素.获取线性表的长度. 线性表主要有两种存储结构: 1:线性表的顺序存储结构,c语言中的数组及采用这种方式. 2:线性表的链式存储结构. 关于顺序存储结构定义: 是指用一段地址连续的内

数据结构中线性表的基本操作-合并两个线性表-依照元素升序排列

#include<iostream> #include<stdlib.h> #define LIST_INIT_SIZE 10/*线性表初始长度*/ #define LIST_CREATENT 2/*每次的增量*/ typedef int ElemType; using namespace std; typedef struct SqList/*线性表的数据结构定义*/ { ElemType *elem;/*线性表基址*/ int length;/*当前线性表所含的元素个数*/ i

数据结构和算法学习总结04 线性表---栈

栈栈(Stack)是特殊的线性表,是只允许在一端进行插入和删除的线性表. 允许插入和删除的叫栈顶,反之则是栈底. 栈的插入称为进栈,删除称为出栈. 特性是:后进先出,所以栈也叫后进先出表,简称LIFO表(Last In First Out). 因为栈是线性表,所以也有顺序表和链表两种形式,一般我们常用顺序表. 从代码中可以看出:与顺序表相比实际上就是插入和删除操作发生了改变. #include <iostream> using namespace std; const int Stack_S

大话数据结构---顺序存储结构的线性表

线性表的定义:零个或多个数据元素的有限序列. 定义的解读: 首先是由一组数据元素组成,可以基本数据类型,也可以使自定义的类型, 有限的个数,当然可以是0个,也就是空表呗, 还有一个特点就是有序这么一看线性表抽象出来就和生活中的排队一样,一群小朋友站成一队,每个人都知道自己站在第几个,自己的前面是谁,后面谁,除了排头排位的两个数据,每个数据都有唯一的前驱和后继. 线性表的分类今天先学习一下顺序存储结构,顺序存储结构指的就是用一段地址连续的存储单元依次存储线性表的数据元素: 这么一看线性表挺像数

【线性表2】线性表的顺序实现：顺序表

顺序表简介特点:使用一组地址连续的存储单元依次存储表中的数据元素,常见的就是使用数组去实现. 表中逻辑相邻的数据元素,在物理内存上也相邻. 顺序表中的任意数据元素都可随机访问,是一种支持随机访问,长度自动动态调整的线性表结构. 优点:访问表中的元素很快,时间复杂度为O(1) 缺点:插入,删除元素需要移动大量的元素,时间复杂度为O(n) . 因此如果我们在编程中需要这样一种线性表数据结构:构造后对元素的访问操作很频繁,而很少进行增,删等元素位置的调整操作,那么就可以考虑使用顺序表. 代码实现 #

数据结构之线性表

线性表是最简单最常用的一种数据结构,在生活中各个方面都有应用. 线性表的定义:线性表大多数情况下是除了第一个位置的数据元素只存在后继元素,最后一个位置的数据元素只存在前驱元素外,所有数据元素都存在前驱和后继的一个有限序列.举个简单的例子就是:字母表中除了 a 只存在后继 b,z 只存在前驱 y之外,剩余的所有字母全部都有前驱和后继.为什么是大多数情况下,是因为线性表的链式存储结构中除了单向链表,还有循环链表和双向链表. 线性表的存储结构:顺序存储(数组实现,需要预先分配连续的内存空间)和链式存储