数据结构复习1 线性表

于 2020-08-17 21:25:55 发布
阅读量207 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AIGNl/article/details/108053078
版权

顺序结构

#define OK 1
#define ERROR 0
#define OVERFLOW -2
#include<stdlib.h>
#include<stdio.h>

#define MAXsize 100
typedef int ElemType
typedef int Status
typedef struct SqList{
	int length;
	ElemType * elem;
}OrderList;
//init
void InitList(OrderList* l){
	//allocate memory and initiate length
	l->elem=(OrderList*)malloc(sizeof(ElemType)*MAXsize);
	if(l->elem==NULL){
		exit(OVERFLOW);
	}
	l->length=0;
	return OK;
}
int isfull(OrderList* l){
	return l->length==MAXsize;
}
//get_value by number(index+1) in O(1)
Status GetElem(OrderList* L,int i,ElemType *e){
	//i in sense
	if(i>L->length||i<1)
		return ERROR;
	//get
	*e=L->elem[i-1];
	return OK;
}
//search in O(N)
int LocateElem(OrderList* l,ElemType e){
	for(int i=0;i<l->length;i++){
		if(l->elem[i]==e){
			return i+1;
		}
		return ERROR;
	}
}
//insert in O(N)
Status ListInsert(OrderList* l,ElemType e,int i){
	//i in sense
	if(i<1||i>l->length+1){
		return ERROR;
	}
	//array is not full
	if(isfull(l)){
		return ERROR;
	}
	//move
	for(int j=l->length-1;j>=i-1;j--){
		l->elem[j+1]=l->elem[j];
	}
	//insert
	l->elem[i-1]=e;
	l->length++;
	return OK;
}
//delete in O(N)
Status ListDelete(OrderList* l,ElemType* e,int i){
	//i in sense
	if(i<1||i>l->length)
		return ERROR;
	//elem is not empty
	if(l->length==0)
		return ERROR;
	//move and delete
	for(int j=i;j<=l->length-1;j++){
		l->elem[j-1]=l->elem[j];
	}
	//length -1
	l->length--;
	return OK;
}

链式结构

#define OK 1
#define ERROR 0
#define OVERFLOW -2
#include<stdlib.h>
#include<stdio.h>

#define MAXsize 100
typedef int ElemType
typedef int Status
typedef struct LNode{
	ElemType elem;
	struct LNode* next;
} LinkList;

//init
Status InitList(LinkList* l){
	//allocate memory
	l=(LinkList*)malloc(sizeof(LinkList));
	//init member
	l->next=NULL;
	return OK;
}
//get in O(N)
Status GetElem(LinkList* l,int i,ElemType *e){
	//first node and counter
	LinkList* p=l->next;int ctr=1;
	//move p and count
	while(p!=NULL&&ctr<i){
		p=p->next;
		ctr++;
	}
	//i in sense or have no result
	if(p==NULL || ctr>i)
		return ERROR;
	//get
	*e=p->elem;
	return OK;
}
//insert in O(N)
Status ListInsert(LinkList* l,ElemType e,int i){
	LinkList* p=l->next;
	int ctr=1;
	//find location
	while(p!=NULL&&ctr<i){
		p=p->next;
		ctr++;
	}
	//i in sense
	if(p==NULL||ctr>=i){
		return ERROR；
	}
	//insert
	LinkList* new;
	new=(LinkList*)malloc(sizeof(LinkList));
	new->next=p->next;
	new->data=e;
	p->next=new;
	return OK;
	
}
//search in O(N)
LinkList* LocateElem(LinkList* l,ElemType e){
	LinkList* p=l->next;
	while(p!=NULL&&p->elem!=e){
		p=p->next;
	}
	return p;
}
//delete in O(N)
Status ListDelete(LinkList* l,ElemType* e,int i){
	int ctr=1;
	LinkList* p=l->next;
	//find location
	while(p!=NULL&&ctr<i){
		p=p->next;
		ctr++;
	}
	if(p==NULL||ctr>=i){
		return ERROR;
	}
	//get elem and pointer
	LinkList* t=p->next;
	*e=p->next->elem;
	//replace
	p->next=p->next->next;
	free(t);
	return OK;
}

c++（顺序结构.h和顺序结构.cpp）

#ifndef List_H
#define List_H
enum bool{false,true};
template<class ElemType>
class List{
public:
	List();
	~List();
	virtual int Size() const=0;//memory size
	virtual int Length() const=0;//length
	virtual int Search(ElemType &x) const=0;//serach by elem
	virtual int Locate(int i)const=0;//search by index+1
	virtual bool GetData(int i,ElemType &x)const=0;//get elem by index+1
	virtual bool SetData(int i,ElemType &x)=0;//change elem by index+1
	virtual bool Insert(int i,ElemType &x)=0;//insert one elem after the index+1 location
	virtual bool Remove(int i,ElemType &x)=0;//remove one elem by index+1
	virtual bool IsEmpty()const=0;//additive function
	virtual bool IsFull()const=0;
	virtual void Sort()=0;
	virtual void input()=0;
	virtual void output()=0;
	virtual List<ElemType> operator=(List<ElemType> &l)=0;
};
#endif
//--------------------------------------//
#include<stdlib.h>
#include<iostream>
#include"List.h"
#define MAXsize 100
using namespace std;
template<class T>
class OrderList:public List<T>{
protected:
	T *elem;
	int capacity;
	int rear;
	void resize(int newsize);
public:
	OrderList(int size=MAXsize);
	OrderList(OrderList<T> &l);
	~OrderList(){delete []elem;}
	int Size()const{return capacity;}
	int Length()const{return rear+1;}
	int Search(T &x)const;
	int Locate(int i)const;
	bool GetData(int i,T &x)const{
		if(i>0&&i<=rear+1){
			x=data[i-1];
			return true;
		}else{
			return false;
		}
	}
	void SetData(int i,T &x){
		if(i>0&&i<=rear+1){
			data[i-1]=x;
		}
	}
	
	bool Insert(int i,T &x);
	bool Remove(int i,T &x);
	bool IsEmpty(){return (rear==-1);}
	bool IsFull(){return (rear==MAXsize-1);}
	void input();
	void output();
	OrderList<T> operator = (OrderList<T> &l);
};

template<class T>
OrderList<T>::OrderList(int size){
	if(size>0){
		capacity=size;
		rear=-1;
		elem=new T[capacity];
	}
	if(elem==NULL){
		cerr<<"allocate memory error"<<endl;
		exit(1);
	}
}

template<class T>
OrderList<T>::OrderList(OrderList<T> &l){
	capacity=l.capacity;
	rear=l.Length()-1;
	data=new T[MAXsize];
	//
	T value;
	if(elem==NULL){
		cerr<<"allocate memory error"<<endl;
		exit(1);
	}
	for(int i=0;i<=rear;i++){
		l.GetData(i,value);elem[i]=value;
	}
}

template<class T>
void OrderList<T>::resize(int newsize){
    //newsize in sense
    if(newsize<=0){
        cerr<<"new size not in sense"<<endl;
        return;
    }
    //modify size
    if(newsize!=MAXsize){
        T *newarray=new T[newsize];
        if(newarray==NULL){
            cerr<<"allocate memory error"<<endl;
            exit(1);
        }
        //copy elem
        int n=rear+1;
        T *src=elem;
        T *dest=newarray;
        while(n != 0){
            *dest=*src;
            dest++;
            src++;
            n--;
        }
        delete []elem;
        elem=newarray;MAXsize=newsize;
    }
}

template<class T>
int OrderList<T>::Search(T &X)const{
    for(int i=0;i<=rear;i++){
        if(elem[i]=x){
            return i+1;

        }
    }
    return 0;
}

//int Locate(int i)const;
template<class T>
int OrderList<T>::Locate(int i)const{
    //i in sense
    if(i>=1 && i<=rear+1)
        return i;
    else
    {
        return 0;
    }
    
    //find location
}
/*
	bool Remove(int i,T &x);
	bool IsEmpty(){return (rear==-1);}
	bool IsFull(){return (rear==MAXsize-1);}
	void input();
	void output();
	OrderList<T> operator = (OrderList<T> &l); 
    
    
    T *elem;
	int capacity;
	int rear;
	void resize(int newsize);
    */
template<class T>
bool OrderList<T>::Insert(int i,T &x){
    //list is full
    if(isFull()){
        return false;
    }
    //i in sense
    if(i<1 || i>rear+1){
        return false;
    }
    //move and insert
    for(int j=rear+1;j>=i+1;j--){
        elem[j]=elem[j-1];
    }
    elem[i]=x;
    rear++;
    return true;

}

template<class T>
bool OrderList<T>::Remove(int i,T &x){
    //i in sense
    if(i<1 || i>rear+1){
        return false;
    }
    //isempty
    if(IsEmpty()){
        return false;
    }
    //move and transmit value and decrease length
    x=elem[i-1];
    for(int j=i;j<=rear;j++){
        elem[j]=elem[j+1];
    }
    rear--;
    return true;
}

template<class T>
void OrderList<T>::input(){
    while(true){
        cin>>rear;
        if(rear<=MAXsize-1){
            break;
        }
    }

    for(int i=0;i<=rear;i++){
        cin>>elem[i];
        cout<<i+1<<endl;
    }
}

template<class T>
void OrderList<T>::output(){
    for(int i=0;i<=rear;i++){
        cout<<i+1<<":"<<elem[i]<<endl;
    }
}

template<class T>
OrderList<T> OrderList<T>::operator = (OrderList<T> &l){
    if(this==&l){
        return l;
    }
    if(elem!=NULL)
        delete []elem;
    T value;
    elem=new T[l.rear];
    if(elem == NULL){
        cerr<<"allocate memory error"<<endl;
    }
    for(int j=0;j<=l.rear;j++){
        l.GetData(j,value);elem[j]=value;
    }
}

链式存储.cpp和链式存储.h

#ifndef LinkNode_H
#define LinkNode_H
template<class T>
struct LinkNode
{
    T elem;
    LinkNode<T> *link;
    LinkNode(LinkNode<T> *l=NULL){link=l;}
    LinkNode(const T &e,LinkNode<T> *l=NULL){link=l;elem=e;}
};

/* default argument has to be set at rear of arg list*/

#endif // !
//.......................................................
#include<iostream>
#include"LinkNode.h"

using namespace std;

template<class T>
class LinkList:public List<T>{
    private:
    LinkNode<T> *first;
    public:
    LinkList(){first=new LinkNode<T>;}
    LinkList(const T &x){first=new LinkNode<T>(x);}
	LinkList(LinkList<T> &l);
	~LinkList(){MakeEmpty();}
	void MakeEmpty();
	int Length()const;
	LinkNode<T> *GetHead()const{return first;}
	LinkNode<T> *Search(T x);
	LinkNode<T> *Locate(int i);
	bool GetData(int i,T &x)const;
	bool SetData(int i,T &x);
	bool Insert(int i,T &x);
	bool Remove(int i,T &x);
	bool IsEmpty()const{return first->link==NULL?true:false;}
	bool IsFull()const{return false;}
	void Sort();
	void Input();
	void Output();
	LinkList<T>& operator=(LinkList<T> &l); 
};
/* #ifndef LinkNode_H
#define LinkNode_H
template<class T>
struct LinkNode
{
    T elem;
    LinkNode<T> *link;
    LinkNode(LinkNode<T> *l=NULL){link=l;}
    LinkNode(const T &e,LinkNode<T> *l=NULL){link=l;elem=e;}
}; */


/* LinkList(LinkList<T> &l);
	~LinkList(){MakeEmpty();}
	void MakeEmpty();
	int Length()const;
	LinkNode<T> *GetHead()const{return first;}
	LinkNode<T> *Search(T x);
	LinkNode<T> *Locate(int i);
	bool GetData(int i,T &x)const;
	bool SetData(int i,T &x);
	bool Insert(int i,T &x);
	bool Remove(int i,T &x);
	bool IsEmpty()const{return first->link==NULL?true:false;}
	bool IsFull()const{return false;}
	void Sort();
	void Input();
	void Output();
	LinkList<T>& operator=(LinkList<T> &l);  */
/* LinkNode<T> *first; */
template<class T>
LinkList<T>::LinkList(LinkList<T> &l){
	//copy constructer
	T value;
	LinkNode<T> *src=l.GetHead();
	LinkNode<T> *dest=first=new LinkNode<T>;
	//transmit data
	while(src->link!=NULL){
		value=src->link->elem;
		dest->link=new LinkNode<T>(value,NULL);
		src=src->link;
		dest=dest->link;
	}
}

template<class T>
void LinkList<T>::MakeEmpty(){
	LinkNode<T> *p,*t;
	while(p->link!=NULL){
		t=p->link;
		p->link=p->link->link;
		delete t;
	}
}

template<class T>
int LinkList<T>::Length()const{
	LinkNode<T> *p=first;
	int ctr=0;
	while(p->link!=NULL){
		ctr++;
		p=p->link;
	}
	return ctr;
}
/* 
template<class T>
LinkList<T>:: 

*/

template<class T>
LinkNode<T> * LinkList<T>::Search(T x){
	LinkNode<T> *p=first;
	while(p->link!=NULL){
		if(x==p->link->elem){
			return p;
		}
		p=p->link;
	}
	return p;
}

template<class T>
LinkNode<T> * LinkList<T>::Locate(int i){
	if(i<=0||i>Length()){
		return NULL;
	}
	LinkNode<T> *p=first->link;
	int ctr=1;
	while(p!=NULL){
		if(ctr==i){
			return p;
		}
		ctr++;
		p=p->link;
	}
}


template<class T>
bool LinkList<T>::GetData(int i,T &x)const{
	if(i<=0||i>Length()){
		return false;
	}
	if(IsEmpty()){
		return false;
	}
	LinkNode<T> *p=Locate(i);
	return true;
}

template<class T>
bool LinkList<T>::SetData(int i,T &x){
	if(i<=0||i>Length()){
		return false;
	}
	if(IsEmpty()){
		return false;
	}
	LinkNode<T> *p=Locate(i);
	p->elem=x;
	return true;
}

/* 
template<class T>
LinkList<T>:: 

*/

/* bool Insert(int i,T &x);
	bool Remove(int i,T &x);
	bool IsEmpty()const{return first->link==NULL?true:false;}
	bool IsFull()const{return false;}
	void Sort();
	void Input();
	void Output();
	LinkList<T>& operator=(LinkList<T> &l);
	struct LinkNode
{
    T elem;
    LinkNode<T> *link;
    LinkNode(LinkNode<T> *l=NULL){link=l;}
    LinkNode(const T &e,LinkNode<T> *l=NULL){link=l;elem=e;}
}; */

template<class T>
bool LinkList<T>::Insert(int i,T &x){
	if(i<=0||i>Length()+1){
		return false;
	}
	//get i location
	LinkNode<T> *p=Locate(i-1);//insert
	LinkNode<T> *newnode=new LinkNode<T>(x,p->link);
	p->link=newnode;
	return true;
	
}


template<class T>
bool LinkList<T>::Remove(int i,T &x){
	if(i<=0||i>Length()){
		return false;
	}
	if(IsEmpty()){
		return false;
	}
	LinkNode<T> *p=Locate(i-1);
	x=p->link->elem;
	LinkNode<T> *t;
	t=p->link;
	p->link=p->link->link;
	delete t;
	return true;
}
C++数据结构 ---- 循环双链表
Jade1998
07-12 194
环境配置 codeblocks windows10 项目结构 代码 CDLinkListClass.h #ifndef _CDLINKLISTCLASS_H_ #define _CDLINKLISTCLASS_H_ #include <iostream> template <typename T> class DLinkListNode { publi...
数据结构 第一篇 链表
北京-大白的博客
05-27 274
引言 最大子序列和 整数序列A1， A2，… An （可能有负数），求A1~An的一个子序列Ai~Aj，使得Ai到Aj的和最大 注意：序列是有顺序的，不是把所有正数相加就可以的 #include &lt;iostream&gt; using namespace std; int Data[]={-2, 11, -4, 13, -5, 2, -5, -3, 12, -9}; i...
实现循环单链表各种基本运算的算法
小凤的博客
01-27 4415
/*algo2-1.cpp*/ #include #include typedef char ElemType; typedef struct LNode/*定义单链表结点类型*/ {  ElemType data;  struct LNode * next; }LinkList; void InitList(LinkList * &L)/*创建头结点*/ {  L=(Lin
数据结构 线性表 插入 删除
mmmm0303的博客
04-22 1万+
数据结构线性表的插入，删除 任务描述 本关任务：实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数，以实现线性表中数据的插入、删除与查找等功能。 相关知识) 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用不同的存储策略。下面给出了一种基于顺序存...
资料—链表 c中错误指示翻译
一介码农，热爱金融。
02-15 2283
单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。  动态单链表 单向链表的数据结构可以分为两部分：数据域和指针域，数据域存储数据，指针域指向下一个储存节点的地址。 /*線性表的單鏈表存儲结構*/ typedef struct LNode{   ElemType data;   struct LNode *next; }LNod
数据结构-单链表的两种实现方式
ytuyzh的博客
03-22 554
单链表的两种实现方式：带头结点和不带头结点 需要注意的地方： 1、带头结点和不带头结点在实现插入和删除操作时的区别 2、封装的方便之处（见InsertPriorNode(LNode *p,ElemType e)），能够使代码更简洁，更加清晰 3、带头结点方式中，头结点不装入数据，并且看作成第0个结点。不带头结点方式，没有头结点，从第1个结点开始。 4、注意一些特判情况 例如： 按位序...
Java数据结构复习：线性表实现与应用
"Java基础复习笔记04数据结构-线性表" 这篇复习笔记主要涵盖了Java中的数据结构——线性表。线性表是一种基本的数据结构，它包含了一组有序的元素，每个元素都有一个唯一的索引。在Java中，线性表可以由数组或链表...
数据结构复习：线性表操作与重点
该资源是一份关于数据结构的复习课件，主要涵盖了线性表的基本操作，适合计算机科学的学习者。课程强调了理论与实践相结合，推荐了几本相关的教材，并提出了学习要求和联系方式。 在数据结构中，线性表是最基础的...
数据结构实验报告 线性表 串 队列 栈.doc
04-01
本实验报告的主题围绕线性表、串、队列和栈这四种基本的数据结构展开，旨在通过实践加深对这些概念的理解。线性表是一种线性的数据结构，其中元素按特定顺序排列，每个元素只有一个前驱和一个后继，除了第一个和最后...
数据结构复习：线性表到图的算法解析
"该资源是一份关于数据结构的复习资料，涵盖了线性表、栈、队列、字符串、数组、广义表、查找算法、排序算法等核心概念，并提供了具体的函数功能解析和例题解答。" 这篇复习资料详细介绍了数据结构中的多个重要主题...
数据结构复习：线性表操作与算法分析
本资源是一份关于数据结构课后的复习练习参考资料，主要涉及线性结构的概念和相关问题。具体内容包括两部分：理论题目和编程练习。 首先，针对线性结构部分，有两道题目： 1. **线性表插入操作的平均移动元素数**：...
顺序线性表实现（SqList）
weixin_30340617的博客
10-05 735
数据结构第一次作业... 顺序表的实现( C and C++）： C语言版: 1#include<stdio.h> 2#include<malloc.h> 3#include<stdlib.h> 4 5#defineLIST_INIT_SIZE10 6#defineLISTINCREMENT2...
线性表——链式存储结构之循环双链表
seu_nuaa_zc的博客
06-12 356
该文章主要介绍线性表的链式存储运算以及相关运算—循环双链表。 头文件：CDLinkList.h template struct DLinkList //循环双链表结点类型 { T data; //存放数据元素 DLinkList *prior; //指向前一个结点的域 DLinkList *next; //指向下一个结点的域 }; temp
数据结构笔记—2.2线性表的顺序存储结构及实现
hhztian的博客
06-01 464
2.1顺序表顺序表的定义和特点顺序表的类定义及其操作 顺序表的定义和特点 线性表的存储方式有多种，有基于数组的存储表示、基于链表的存储表示、散列的存储表示，其中顺序表是线性表基于数组的存储表示。 其用一段地址连续的存储单元，依次存储线性表中的数据元素。 其特点有 各个表项的逻辑顺序与物理顺序一致。 对顺序表中的所有表项，可以顺序访问，也可以随机访问。 顺序表的类定义及其操作 顺序表可以用C+...
error: request for member '*' in '*', which is of non-class type '*'
热门推荐
鶸的博客
12-18 4万+
今天碰到这个问题， 问题是vector变量名和for循环里面定义的变量名重复了，循环里面没有调用到外面的vector，而是调用了int a，
C++数据结构 ---- 双链表
Jade1998
07-12 124
环境配置 codeblocks windows10 项目结构 代码 DLinkListClass.cpp #ifndef _DLINKLISTCLASS_H_ #define _DLINKLISTCLASS_H_ template <typename T> class DLinkListNode { public: T data; DLinkListNode&l...
c++ 学习错误列表
王定桥的专栏
03-03 4万+
c++ primer学习过程中调试常见错误归纳 这是学习c++ primer过程中练习程序时，调试时出现的错误即解决方法列表,不断更新。 No.1: prog2.cpp(8) : error C2664: '__thiscall std::list >::std::list >(unsigned int,const int &, const class std::allocator
【每日算法】链表 & 例题选讲
jiange_zh的博客
02-24 2500
单链表 链表是常用的数据结构，其优点是插入和删除元素时不需要移动，表的容量可扩充，且存储空间可以不连续。 另外，由于涉及到指针，所以很受面试官的青睐。 本文将主要介绍单链表，并简单介绍下双链表和环形链表，并通过一系列的题目来强化这方面的知识。 链表节点的结构： templateclass DataType> struct Node { DataType data; N
request for member in , which is of pointer type
weixin_46028606的博客
05-23 1万+
原因 其实就是因为结构体成员引用符 ". " 和指针的箭头运算符 ‘’->’’ 用错了 只要根据自己的代码把‘点’和->改回去就行了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值