算法数据结构 顺序表的实现+操作 及对产生问题的分析

线性表的顺序存储是将线性表中的元素存放在一组连续的存储单元中。使得在线性表中逻辑上相邻的元素在物理存储单元上也是连续的。采用顺序存储的线性表叫做顺序表。

线性表的顺序存储结构如下：

模块化设计：

头文件 结构体和相应函数的定义，声明

#ifndef _SEQLIST_H
#define _SEQLIST_H

#include<iostream>
#include<assert.h>//断言
#include<string.h>
#include<stdlib.h>

using namespace std;

#define ElemType int
#define SEQLIST_DEFAULT_SIZE 10
#define ERROR -1

/*
结构体 用于存贮顺序表基本信息
*/
typedef struct SeqList
{
	ElemType *base;
	size_t    capacity;//顺序表的容量
	size_t    size;
}SeqList;

int begin();//0
int end(SeqList *list);//表尾
void menu();//菜单函数
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 key, ElemType x);//位置插入
bool delete_val(SeqList *list, ElemType key);//按值删除
void show(SeqList *list);//显示函数
int find(SeqList *list, ElemType key);//查找函数
//bool delete_val(SeqList *list, ElemType key);
bool delete_pos(SeqList *list, ElemType key);//位置删除
int getvalue(SeqList*list, ElemType key);//获取某位置的值
bool modify(SeqList *list, ElemType key, ElemType x);//修改函数
void clear(SeqList *list);//清空顺序表
void destroy(SeqList *list);//销毁顺序表
int length(SeqList *list);//返回表长度
int next(SeqList *list, ElemType key);//查找某位置的后继
int pro(SeqList *list, ElemType key);//查找某位置的前驱
void sort(SeqList *list);//排序（冒泡）
int insert_val_pos(SeqList *list, ElemType x);//按值插入（返回位置）
void resver(SeqList *list);//翻转函数

#endif

#include"SeqList.h"

/*
	各个功能函数
*/

/*
	菜单
*/
void menu()
{
	cout << "								   " << endl;
	cout << "**********************************" << endl;
	cout << "* [1] push_back   [2] push_front *" << endl;
	cout << "* [3] show_seqlist[0] quit_system*" << 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 << "plese chose:>";

}

/*
	初始化顺序表
*/

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

int begin()
{
	return 0;
}

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

/*
	判断是否为空
*/
bool isempty(SeqList *list)
{
	return end(list) == 0;
}

/*
	判断是否满
*/
bool isfull(SeqList *list)
{
	return end(list) >= list->capacity;
}

/*
	尾部插入
*/
bool push_back(SeqList *list, ElemType x)
{
	return insert_pos(list, end(list), x);
}

/*
	头部删除
*/
bool push_front(SeqList *list, ElemType x)
{
	return insert_pos(list, begin(), x);
}
/*
bool push_back(SeqList *list,ElemType x)
{
if(isfull(list))
return false;
list->base[list->size++] = x;
return true;
}

bool push_front(SeqList *list,ElemType x)
{
if(isfull(list))
return false;

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

list->size++;
return true;
}
*/

/*
	尾部删除
*/
bool pop_back(SeqList *list)
{
	if (isempty(list))
		return false;
	list->size--;	//删除结束 数目减1
	return true;
}

/*
	头部插入
*/
bool pop_front(SeqList *list)
{
	if (isempty(list))
		return false;
	for (int i = begin(); i<end(list) - 1; ++i)
	{
		list->base[i] = list->base[i + 1];
	}
	list->size--;	//删除结束 数目减1
	return true;
}

/*
	位置插入
*/
bool insert_pos(SeqList *list, ElemType key, ElemType x)
{
	if (isfull(list) || key < begin() || key > end(list))
		return false;

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

/*
	按值删除
*/
bool delete_val(SeqList *list, ElemType key)
{
	int pos = find(list, key);
	if (pos == -1)
		return false;
	delete_pos(list, pos);
	return true;
}

/*
	查询输入位置的值
*/
int find(SeqList *list, ElemType x)
{
	if (isempty(list))
	{
		cout << "INPUT_ERROR ";
		return ERROR;
	}

	for (int i = begin(); i<end(list); i++)
	{
		if (list->base[i] == x)
			return i;
	}
	cout << "INPUT_ERROR ";
	return ERROR;
}

/*
	位置删除
*/
bool delete_pos(SeqList *list, ElemType key)
{
	if (isempty(list) || key < begin() || key > end(list) - 1)
		return false;
	for (int i = key; i<end(list) - 1; i++)
	{
		list->base[i] = list->base[i + 1];
	}
	list->size--;
	return true;
}

//bool delete_val(SeqList *list, ElemType key)
//{
//    int i = 0;
//    for(int i=0; i<list->size; ++i)
//    {
//        if(list->base[i] == key)
//            break;
//    }
//    if(i >= list->size)
//        return false;
//    for(int k=i; k<list->size-1; ++k)
//    {
//        list->base[k] = list->base[k+1];
//    }
//    list->size--;
//    return true;
//}

/*
	获取输入位置的值
*/
int getvalue(SeqList *list, ElemType key)
{
	if (isempty(list) || key < begin() || key > end(list))
	{
		cout << "INPUT_ERROR ";
		return ERROR;
	}

	for (int i = begin(); i<end(list); i++)
	{
		if (key == i)
			return list->base[i];
	}
	cout << "INPUT_ERROR ";
	return ERROR;
}

/*
	修改某位置的值
*/
bool modify(SeqList *list, ElemType key, ElemType x)
{
	if (isempty(list) || key < begin() || key > end(list) - 1)
		return false;
	for (int i = begin(); i<end(list); i++)
	{
		if (key == i)
			list->base[i] = x;
	}
	return true;

}

/*
	清空顺序表
*/
void clear(SeqList *list)
{
	list->size = 0;

}

/*
	销毁顺序表
*/
void destroy(SeqList *list)
{
	if (list->base)
		free(list->base);
	list->size = 0;
	list->capacity = 0;
}

/*
	获取表长
*/
int length(SeqList *list)
{
	if (list->capacity = NULL)
	{
		cout << "INPUT_ERROR ";
		return ERROR;
	}

	return end(list);
}

/*
	返回输出位置的后继
*/
int next(SeqList *list, ElemType key)
{
	if (isempty(list) || key < begin() || key >= end(list) - 1)
	{
		cout << "INPUT_ERROR ";
		return ERROR;
	}

	return list->base[key + 1];

}

/*
	返回输出位置的前驱
*/
int pro(SeqList *list, ElemType key)
{
	if (isempty(list) || key < 1 || key >= end(list))
	{
		cout << "INPUT_ERROR ";
		return ERROR;
	}

	return list->base[key - 1];
}

/*
	升序排序
*/
void sort(SeqList *list)
{
	for (int i = begin(); i < end(list); i++)
	{
		for (int j = begin(); j < end(list) - i - 1; j++)
		{
			if (list->base[j] > list->base[j + 1])
			{
				list->base[j] = list->base[j] ^ list->base[j + 1];
				list->base[j + 1] = list->base[j] ^ list->base[j + 1];
				list->base[j] = list->base[j] ^ list->base[j + 1];
			}
		}
	}
}

/*
	按照值的大小插入（返回位置），再通过 insert_pos 实现插入功能
*/
int insert_val_pos(SeqList *list, ElemType x)//只返回插入位置
{
	cout << "the changes of SeqList will be incremental ! " << endl;
	sort(list);
	for (int i = begin(); i<end(list); ++i)
	{
		if (x >= list->base[i] && x <= list->base[i + 1])
			return i + 1;
	}
}

/*
	翻转顺序表
*/
void resver(SeqList *list)
{
	int *top = &list->base [0];
	int *end = &list->base[list->size-1];

	for (; top < end; (top++ && end--))
	{
		*top = *top ^ *end;
		*end = *top ^ *end;
		*top = *top ^ *end;
	}
}

/*
	显示
*/
void show(SeqList *list)
{
	for (int i = begin(); i< end(list); ++i)
	{
		cout << list->base[i] << " ";
	}
	cout << endl;
}

#include<iostream>
#include"SeqList.h"
using namespace std;

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

	int select = 1;
	ElemType item;
	int pos = 0;

	while (select)
	{
		menu();
		cin >> select;
		switch (select)
		{
		case 1:
			cout << "please enter data end with -1:>";
			while (cin >> item, item != -1)
			{
				push_back(&mylist, item);
			}
			break;

		case 2:
			cout << "please enter data end with -1:>";
			while (cin >> item, item != -1)
			{
				push_front(&mylist, item);
			}
			break;

		case 3:
			show(&mylist);
			break;

		case 4:
			pop_back(&mylist);
			break;

		case 5:
			pop_front(&mylist);
			break;

		case 6:
			cout << "please enter position(begin 0):>";
			cin >> pos;
			cout << "please enter insert data:>";
			cin >> item;
			insert_pos(&mylist, pos, item);
			break;

		case 7:
			cout << "please enter insert data:>";
			cin >> item;
			insert_pos(&mylist, insert_val_pos(&mylist, item), item);
			break;

		case 8:
			cout << "please enter position(begin 0):>";
			cin >> pos;
			delete_pos(&mylist, pos);
			break;

		case 9:
			cout << "please enter delete data:>";
			cin >> item;
			delete_val(&mylist, item);
			break;

		case 10:
			cout << "please enter data:>";
			cin >> item;
			cout << "the pos is:>" << find(&mylist, item) << endl;
			break;

		case 11:
			cout << "please enter position(begin 0):>";
			cin >> pos;
			getvalue(&mylist, pos);
			cout << "the data of pos is>" << getvalue(&mylist, pos) << endl;
			break;

		case 12:
			cout << "please enter position(begin 0):>";
			cin >> pos;
			cout << "please enter the modify data:>";
			cin >> item;
			modify(&mylist, pos, item);
			break;

		case 13:
			clear(&mylist);
			cout << "the SeqList was cleared !"<<endl;
			break;

	    case 14:
			 destroy(&mylist);
			 cout<<"the SeqList was destroyed !"<<endl;
			 cout << "After destroy ,any operation is invalid!" << endl;
			 cout << "Please quit_system!" << endl;
			 break;

		case 15:
			sort(&mylist);
			cout << "the changes of SeqList will be incremental ! " << endl;
			break;

		case 16:
			cout << "the changes of SeqList will be resver ! " << endl;
			resver(&mylist);
			break;

		case 17:
			length(&mylist);
			cout << "the length of SeqList is:>" << length(&mylist) << endl;
			break;

		case 18:
			cout << "please enter position(begin 0):>";
			cin >> pos;
			getvalue(&mylist, pos);
			cout << "the data of pos is>" << getvalue(&mylist, pos) << endl;
			next(&mylist, pos);
			cout << "the next of data is>" << next(&mylist, pos) << endl;

			break;

		case 19:
			cout << "please enter position(begin 0):>";
			cin >> pos;
			getvalue(&mylist, pos);
			cout << "the data of pos is>" << getvalue(&mylist, pos) << endl;
			next(&mylist, pos);
			cout << "the next of data is>" << pro(&mylist, pos) << endl;
			break;

		default:
			break;
			return 0;
		}
	}

}

运行结果如下：

时间： 2024-10-10 00:42:29

算法数据结构 顺序表的实现+操作 及对产生问题的分析的相关文章

java数据结构与算法之顺序表与链表深入分析

转载请注明出处(万分感谢!): http://blog.csdn.net/javazejian/article/details/52953190 出自[zejian的博客] 关联文章: java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 ??数据结构与算法这门学科虽然在大学期间就已学习过了,但是到现在确实也忘了不少,因此最近又重新看了本书-<数据结构与算法分析>加上之前看的<java数据结构>也算是对数据结构的进一步深入学习了,于是也就打算

【数据结构】用C++实现顺序表的各种操作（包括头删，尾删，插入，逆序，摧毁，清空等等）

//顺序表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等) //头文件 #pragma once #include <iostream> using namespace std; template<class Type> class SeqList { public: SeqList(size_t sz = INIT_SIZE); ~SeqList(); public: bool isfull() const {return size >= capacity; } b

基础数据结构-线性表-顺序表的合并操作

因为最近笔记本B面裂了准备去修,复杂些的会优先加上注释,所以在家先把代码和题目贴上来以后补文字,有疑问可以在下面留言. 顺序表的合并操作 题目描述建立顺序表的类,属性包括:数组.实际长度.最大长度(设定为1000) 已知两个递增序列,把两个序列的数据合并到顺序表中,并使得顺序表的数据递增有序输入第1行先输入n表示有n个数据,接着输入n个数据,表示第1个序列,要求数据递增互不等 第2行先输入m表示有m个数据,接着输入m个数据,表示第2个序列,要求数据递增互不等输出顺序表内容包括顺序表的实际长度和数

【数据结构】用C语言实现顺序表的各种操作（包括头删，尾删，插入，逆序，摧毁，清空等等）

//顺序表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等) //头文件 #ifndef _SEQLIST_H #define _SEQLIST_H #include<stdio.h> typedef int ElemType; #define INIT_SIZE 8 typedef struct SeqList { ElemType *base; size_t capacity; size_t size; }SeqList; int isempty(SeqList *list); in

数据结构——顺序表及其操作

今天总结了一下顺序表的一些操作实现,算是这个本该上而没有上的体育课的一些小收获吧! BTW,青轴用起来是爽,但时间长了感觉自己的手指痛的不行呀/TOT/~~ 1 #include<iostream> 2 3 using namespace std; 4 5 #define MAXSIZE 100 //最大长度 6 #define OK 1 7 #define ERROR -1 8 9 10 //类型重命名 11 typedef int Elemtype; 12 typedef int Stat

数据结构顺序表Java实现

Java实现顺序表算法:1:首先我们需要定义我们的接口,关于顺序表的一些基本的操作:顺序表中的操作都有增删改查. //List接口 public interface IList { //返回线性表的大小,即数据元素的个数. public int getSize(); //如果线性表为空返回 true,否则返回 false. public boolean isEmpty(); //判断线性表是否包含数据元素 e public boolean contains(Object e); //返回数据元素

hrbust-1545-基础数据结构——顺序表（2）

http://acm.hrbust.edu.cn/index.php?m=ProblemSet&a=showProblem&problem_id=1545 基础数据结构——顺序表(2) Time Limit: 1000 MS Memory Limit: 10240 K Total Submit: 412(165 users) Total Accepted: 188(150 users) Rating:  Special Judge: No Description 在长度为n(n<10

数据结构-顺序表

1 #include <iostream> 2 3 using namespace std; 4 5 #define maxSize 20 6 typedef struct 7 { 8 int data[maxSize]; 9 int length; 10 }Sqlist; 11 12 void InitList(Sqlist &L) 13 {//初始化 14 L.length=0; 15 } 16 17 int GetElem(Sqlist L,int p,int &e) 1

算法数据结构 单链表的实现+操作 以及和顺序表的对比

顺序表和单链表的优缺点对比: 顺序表的优点,无需为表示表中元素之间的逻辑关系而增加额外的存储空间: 可以快速的存取表中的任意位置的元素. 顺序表的缺点,插入后删除操作需要移动大量元素: 当线性表长度不稳定时,存储空间难确定,容易造成存储空间碎片. 对于单链表 链式存储即元素存储的内存单元可以是不连续,分散的.对于元素间如何来维护他们的关系(即逻辑结构,每个元素的前驱和后继.) 即用到一个指针域来存储他和前驱或是后继直接的关系. 如上面的是一个单链表的指针结构,即每个元素中存储了他的后继元素的内存