数据结构——线性表以及各功能的实现

最新推荐文章于 2024-07-12 10:45:29 发布
最新推荐文章于 2024-07-12 10:45:29 发布
阅读量559 收藏
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fujinlong520/article/details/45233571
版权 
#include<iostream>
#include"SeqList.h"
using namespace std;

void main()
{
  SeqList mylist;
  InitSeqList(&mylist);

  int select = 1;
  ElemType item;
  int pos;
  while(select)
  {
		cout<<"**********************************"<<endl;
		cout<<"* [0] quit_system [1] push_back  *"<<endl;
		cout<<"* [2] push_front  [3]show_seqlist*"<<endl;
		cout<<"* [4] pop_back    [5] pop_front  *"<<endl;
		cout<<"* [6] insert_pos  [7] insert_val *"<<endl;
		cout<<"* [8] delete_pos  [9] delete_val *"<<endl;
		cout<<"* [10] find       [11]getvalue   *"<<endl;
		cout<<"* [12] modify     [13]clear      *"<<endl;
		cout<<"* [14] destroy    [15]sort       *"<<endl;
		cout<<"* [16] resver     [17]length     *"<<endl;
		cout<<"* [18] next       [19]prio       *"<<endl;
		cout<<"**********************************"<<endl;
		cout<<"请选择:>";
		cin>>select;
		switch(select)
		{
		case 1:
			cout<<"请输入要插入的数据(-1结束):>";
			while(cin>>item,item!=-1)
			{
				push_back(&mylist,item);
			}
			break;
		case 2:
			cout<<"请输入要插入的数据(-1结束):>";
			while(cin>>item,item!=-1)
			{
				push_front(&mylist,item);
			}
			break;
		case 3:
			show(&mylist);
			break;
		case 4:
            cout<<"删除最后一个元素:>"<<endl;
			pop_back(&mylist);
			break;
		case 5:
            cout<<"删除第一个元素:>"<<endl;
			pop_front(&mylist);
			break;
		case 6:
			cout<<"请输入要插入的位置:>";
			cin>>pos;
			cout<<"请输入要插入的值:>";
			cin>>item;
			insert_pos(&mylist,pos,item);
			break;
		case 7:
			cout<<"请输入要插入节点的下标:>";
			cin>>pos;
			insert_val(&mylist,pos,item);
			break;
		case 8:
            cout<<"请输入要删除的下标:>";
            cin>>item;
			 delete_pos(&mylist,item);
			break;
		case 9:
			cout<<"请输入要删除的值:>";
			cin>>item;
			delete_val(&mylist,pos,item);
			break;
		case 10:
			cout<<"请输入要查找的数据："<<endl;
			cin>>item;
			cout<<"此数据的下标是：>" ;
			find(&mylist,item,pos);
				break;
		case 11:
			cout<<"请输入要查找的下标："<<endl;
			cin>>item;
	        cout<<" 此下标的值是：>" ; 
			getvalue(&mylist,pos,item);
				break;
		case 12:
	        cout<<"请输入要修改的下标：>" ;
			cin>>pos;
			cout<<"请输入要修改后的数字：>" ;
			cin>>item;
			modify(&mylist,pos,item);
				break;
		case 13:
			cout<<"清处链表："<<endl;
			clear(&mylist);
				break;
        case 14:
			cout<<"摧毁链表："<<endl;
			destroy(&mylist);
				break;
		case 15:
			cout<<"按从小到大输出:"<<endl ;
            sort(&mylist,pos,item);
				break;
		case 16:
			cout<<"倒序输出:"<<endl ;
           resver(&mylist,pos,item); 
			   
				break;
		case 17:
			cout<<"统计链表长度："<<endl;
			length(&mylist,item);
				break;
		case 18:
			 cout<<"请输入要查找后继数的值：>" ;
			cin>>item;
			next(&mylist,pos,item);
				break;	 
		case 19:
            cout<<"请输入要查找前驱数的值：>" ;
			cin>>item;
		     prio(&mylist,pos,item);
				break;
		default:
			break;
		}
	}
}

#include"SeqList.h"

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

}
int begin()
{
	return 0;
}
int end(SeqList *list)
{
	return list->size;
}

bool isempty(SeqList *list)
{
	return list->size == 0;
}
bool isfull(SeqList *list)
{
	return list->size >= list->capacity;
}

bool push_back(SeqList *list,ElemType x)//1
{
	return insert_pos(list,end(list),x);
}
bool push_front(SeqList *list,ElemType x)//2
{
	return insert_pos(list,begin(),x);
}
void show(SeqList *list)//3
{
	for(int i=0; i<list->size; ++i)
	{
		cout<<list->base[i]<<" ";
	}
	cout<<endl;
}

bool pop_back(SeqList *list)//4
{
	if(isempty(list))
		return false;
	list->size--;
	return true;
}

bool pop_front(SeqList *list)//5
{
	if(isempty(list))
		return false;
	for(int i=0; i<list->size-1; ++i)
	{
		list->base[i] = list->base[i+1];
	}
	list->size--;
	return true;
}

bool insert_pos(SeqList *list, int p, ElemType x)//6
{
	if(isfull(list))
		return false;
	if(p<0 || p>list->size)
		return false;

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


bool insert_val(SeqList *list, ElemType p, ElemType x)//7
{ 
	if(isempty(list))
		return false;
	if(p<0 || p>list->size+1)
		return false;
	list->size++;
    for(int i = list->size; i>p; --i)
    {   
		list->base[i] = list->base[i-1];
    }
     list->base[p] = -1;
	
	return true;
}
bool delete_pos(SeqList *list, ElemType key)//8
 {
   	if(isempty(list)) 
		return false;
    if(key<0 || key>list->size)
		return false;
	{
		for(int i=key; i<list->size; ++i)
		list->base[i] = list->base[i+1];
		 	   
	} 
	list->size--;	 
	return true; 
 }
bool delete_val(SeqList *list, ElemType pos,ElemType key)//9
{ 
	if(isempty(list))
		return false;
	for(int i=0;i<=list->size;++i)
		if(list->base[i] == key)
    {
		pos = i;
	    delete_pos(list,pos);
	}    
	return true;
	   
	
}
bool find(SeqList *list,ElemType key,ElemType p)//10
{
	if(isempty(list)) 
		return false;
	{
		for(int i=0; i<list->size; ++i)
		if(	list->base[i] == key)
		{
		   int pos=i;
		   cout<<pos<<endl;	   
		}
	}
		 
	return true;
}
bool getvalue(SeqList *list,ElemType value,ElemType i)//11
{
	if(isempty(list)) 
		return false;
    if(i<0 || i>list->size)
		return false;
	{
		value = list->base[i];
		cout<<value<<endl;
	} 

    return true;
}

bool modify(SeqList *list,ElemType p,ElemType i)//12
{	
	if(isempty(list))
		return false;
     if(p<0 || p>list->size)
	     return false; 
     list->base[p] = i;
	 return true;
}
bool clear(SeqList *list )//13
{
    if(isempty(list))
		return false;
  list->size = 0;
       return true;
}
bool destroy(SeqList *list)//14
{
	if(isempty(list))
		return false;
   if(list->base)
<span style="white-space:pre">	</span>free(list->base);
        list->size = 0;
        list->capacity = 0;
       return true;
}
bool sort(SeqList *list,ElemType pos, ElemType item)//15
{
	if(isempty(list))
		return false;
	for(int i=0;i < list->size;i++)
    {
	    for(int j=0;j<list->size-1;j++)
		{
			pos = list->base[i];
			if(pos<list->base[j])
		{
			list->base[i] = list->base[j];
	        list->base[j] = pos;
		}
		}
	}
  return true;  
}
bool resver(SeqList *list,ElemType pos, ElemType item)//16
{
	if(isempty(list))
		return false;
	int j = list->size-1;
	for(int i=0;i < ((list->size)/2); i++)
    {
        pos = list->base[i];
	    list->base[i] = list->base[j];
	    list->base[j] = pos;
      	--j;
	}
   return true;
}
 
bool length(SeqList *list,ElemType count)//17
{
     count = list->size; 
	 cout<<count<<endl;
	  return true;
}
bool next(SeqList *list,ElemType pos, ElemType key)//18
{
	if(isempty(list)) 
		return false;
	 for(int i=0;i<=list->size;++i)
	 {
		 if(list->base[i] == key)
    {
		pos = i+1;
	    if(pos<list->size)
		cout<<"此数的后继是"<<list->base[pos]<<endl;
	     
	}    
	  }
      return true;
}
bool prio(SeqList *list,ElemType pos, ElemType key)//19
{

	if(isempty(list)) 
		return false;
	 for(int i=0;i<=list->size;++i)
	 {	if(list->base[i] == key)
    {
		pos = i-1;
		if(pos>=0)
		cout<<"此数的前驱是"<<list->base[pos]<<endl;
	 }    
	 }
      return true;
}

#ifndef _SEQLIST_H
#define _SEQLIST_H

#include<iostream>
#include<assert.h>
using namespace std;

#define ElemType int
#define SEQLIST_DEFAULT_SIZE 10

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

}SeqList;

int begin();
int end(SeqList *list);
void InitSeqList(SeqList *list);
bool isempty(SeqList *list);
bool isfull(SeqList *list);
bool push_back(SeqList *list,ElemType x);
bool push_front(SeqList *list,ElemType x);
bool pop_back(SeqList *list);
bool pop_front(SeqList *list);
bool insert_pos(SeqList *list, ElemType p, ElemType x);
bool insert_val(SeqList *list, ElemType p, ElemType i);
bool delete_pos(SeqList *list, ElemType key);
bool delete_val(SeqList *list, ElemType pos,ElemType key);
bool find(SeqList *list,ElemType key,ElemType p );
bool getvalue(SeqList *list,ElemType value,ElemType i);
bool modify(SeqList *list,ElemType p, ElemType i);
bool clear(SeqList *list);
bool destroy(SeqList *list);
bool sort(SeqList *list,ElemType p, ElemType i);
bool resver(SeqList *list,ElemType p, ElemType i);
bool length(SeqList *list,ElemType count);
bool next(SeqList *list,ElemType p, ElemType i );
bool prio(SeqList *list,ElemType p, ElemType i);
void show(SeqList *list);



#endif














sense_long_h
关注
专栏目录
线性表各种基本操作实现代码
qq_41954073的博客
05-22 5144
//容易 //线性表各种基本操作实现代码 #include<cstdio> #include<cstring> #include<cstdlib> #include<ctime> #define ElemType int #define Status int #define ERROR 0 #define OK 1 using namespace std; typedef struct Node { ElemType data;//单链表结点的数据.
408数据结构——线性表之C++实现顺序表
long99920的博客
05-22 542
可修改main函数内的注释，测试相应的顺序表操作。 #include <iostream> using namespace std; #define initSize 10 // 顺序表初始容量 // 创建顺序线性表(顺序表),动态分配内存空间地址 typedef struct { int *array; // 指向顺序表的指针 int maxSize,length; // 顺序表最大容量,顺序表当前长度 }sqList;
线性表各种功能的实现
05-17
顺序表 链表 循环 双向 等等，数据结构必需源码 线性表各种功能的实现
线性表基本功能实现
qq_40196529的博客
02-03 636
在介绍功能之前我们先定义一个线性表的结构体： #ifndef _SEQUENCELIST_H_ #define _SEQUENCELIST_H_ #define SIZE       10 #define FAILURE    10000 #define SUCCESS    10001 typedef int DataType; struct Sequenc
数据结构线性表全代码
12-11
花了好久整理出来的有关数据结构的线性表，归纳完整，可以用来学习，也可以用作资源存储起来，以便要用的时候方便调用~~希望对你有帮助~~
数据结构之线性表全部代码
07-01
数据结构实用教程之线性表的应用，里面有线性表的定义以及应用，线性表的应用包含 两个有序表的合并、集合运算、一元多项式的表示和相加
数据结构——线性表（C语言实现）
最新发布
m0_56399733的博客
07-12 1872
数据结构线性表的内容：顺序表+链表，增删查改，C语言实现，含有运行结果！！！动态顺序变、单链表、双链表，循环链表；
数据结构——线性表的实现.zip
09-18
本资料包“数据结构——线性表的实现.zip”着重介绍了线性表的两种常见实现方式：链表和数组。 1. 链表实现： 链表是一种物理存储单元非连续、非顺序的存储结构，它通过节点间的指针链接来表示元素之间的逻辑关系...
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
数据结构——线性表(选择题).docx
07-11
总结来说，线性表是数据结构的基础，理解其概念、性质以及在顺序存储和链式存储下的操作对于学习数据结构至关重要。顺序存储便于随机访问但插入和删除操作可能涉及大量元素的移动，而链式存储虽然插入和删除更灵活，...
数据结构线性表的各种实现
04-22
用java实现了各种线性表（表，队列，栈等），包括顺序数组实现和链表实现
数据结构——线性表分享.pdf
01-01
数据结构——线性表分享 一、顺序存储结构 在数据结构中，顺序存储结构是一种常用的存储方式，它将线性表的每个元素存储在一块连续的存储空间中。这种存储方式的优点是可以快速访问任意一个元素，但缺点是插入或...
数据结构线性表功能大全
Haifamaster的博客
03-18 511
#include #include #define MAXSIZE 100 typedef int DataType; #define OK 1 #define ERROR -1 #define FALSE 0 #define True 2 typedef struct {   DataType data[MAXSIZE];   int length; } SqLi
线性表结构、类别以及功能的实现。
一个无聊的人做一些有意思的事
03-28 2186
一  线性表 1 顺序表： typedef struct { int elem[100]; int length; //length是顺序表的长度 } SqList; 顺序表的长度是固定的，elem存放数据，存入一个数据length+1。 1.1 顺序表的创建 void Dnital(Sqlist &L) { cout << "请输入线性表的长度" << endl;
数据结构中线性表的c语言代码实现
DawN
08-14 5764
/* LinkList *L定义了一个LinkList指针 LinkList *&amp;L是指针的引用 */ #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; typedef char ListData; //定义线性表 char int等类型 typedef struct List { ListData data;...
数据结构实验三——线性表的操作（代码功能完整）
热门推荐
Ruky_Z的博客
12-02 1万+
线性表的各种基本操作
线性表基本功能的实现
Jury吖
08-02 276
学习内容：线性表：存储，插入，删除，求长度，遍历等等。 分为3部分：头文件，函数，主函数 #include "SequenceList.h" #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; int SequenceInit(SqList *l) { if(NULL==l) { return FAILURE;...
数据结构-----顺序栈的实现
sense_long_h的专栏
05-10 1426
#ifndef _SEQSTACK_H #define _SEQSTACK_H #include #include using namespace std; typedef int ElemType; #define STACK_INIT_SIZE 8 typedef struct Stack { ElemType *base; int top; int ca
改进版快速排序（平均复杂度O(NlogN)）
sense_long_h的专栏
06-27 1350
#includeusing namespace std; #define MAXSIZE 21 typedef int SqList[MAXSIZE]; #define ElementType int void Swap(int &a, int &b) { a = a^b; b = a^b; a = a^b; } //*********
数据结构实验报告——线性表、二叉树、图的实现
这篇文档是吕鹏泽同学的一份数据结构实验报告，主要探讨了基于不同存储结构的线性表、二叉树以及图的实现。以下是各部分的详细知识点： 1. 基于顺序存储结构的线性表实现 - 问题描述：使用动态分配的顺序表来实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值