数据结构总结第二章线性表抽象数据类型的具体实现

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#define MAXSIZE 1000
#define ERROR 0
#define OK 1
using namespace std;
typedef int Status;
typedef int ElemType;
/////////////线性表定义(顺序表)////////////////////////
typedef struct
{
    ElemType *elem;
    int length;
}SqList;
/////////////线性表定义(单链表)////////////////////////
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;
/////////////线性表初始化////////////////////////
Status InitList(SqList &L)
{
    L.elem = new ElemType[MAXSIZE];
    if(!L.elem) exit(ERROR);
    L.length = 0;
    return OK;
}
Status InitList(LinkList &L)
{
    L = new LNode;
    L->next = NULL;
    return OK;
}
/////////////线性表销毁//////////////////////////
Status DestoryList(SqList &L)
{
    delete L.elem;
    L.elem = NULL;
    L.length = 0;
    return OK;
}
Status DestoryList(LinkList &L)
{
    LinkList p;
    while(L)
    {
        p = L;
        L = L->next;
        delete p;
    }
    return OK;
}
/////////////线性表清空//////////////////////////
Status ClearList(SqList &L)
{
    L.length = 0;
    return OK;
}
Status ClearList(LinkList &L)
{
    LinkList p;
    L = L->next;
    while(L)
    {
        p = L;
        L = L->next;
        delete p;
    }
    L->next = NULL;
    return OK;
}
/////////////线性表是否为空//////////////////////
Status ListEmpty(SqList L)
{
    if(L.length == 0)
        return OK;
    return ERROR;
}
Status ListEmpty(LinkList L)
{
    if(L->next == NULL)
        return OK;
    return ERROR;
}
/////////////线性表长度//////////////////////////
Status ListLength(SqList L)
{
    return L.length;
}
Status ListLength(LinkList L)
{
    LinkList p;
    int sum = 0;
    p = L->next;
    while(p)
    {
        p = p->next;
        sum++;
    }
    return sum;
}
/////////////获取线性表元素值////////////////////
Status GetElem(SqList L,int i,ElemType &e)
{
    if(i<1 || i>L.length)   return ERROR;
    e = L.elem[i-1];
    return OK;
}
Status GetElem(LinkList L,int i,ElemType &e)
{
    LinkList p;
    p = L->next;
    int j = 1;
    while(p&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i) return ERROR;
    e = p->data;
    return OK;
}
/////////////获取线性表元素位置//////////////////
int LocateElem(SqList L,ElemType e)
{
    for(int i=0;i<L.length;i++)
        if(L.elem[i]==e)    return i+1;
    return ERROR;
}
LNode *LocateElem(LinkList L,ElemType e)
{
    LinkList p;
    p = L->next;
    while(p && p->data!=e)
        p = p->next;
    return p;
}
/////////////返回线性表前驱//////////////////////
Status PriorElem(SqList L,ElemType cur_e,ElemType &pre_e)
{
    int i = 0;
    while(L.elem[i]!=cur_e && i<L.length)
        i++;
    if(i == 0 || i == L.length)    return ERROR;
        L.elem[i-1] = pre_e;
    return OK;
}
Status PriorElem(LinkList L,ElemType cur_e,ElemType &pre_e)
{
    LinkList p,q;
    p = L->next;
    q = L;
    while(p->next)
    {
        q = p->next;
        if(q->data = cur_e)
        {
            pre_e = q->data;
            return OK;
        }
        p = q;
    }
    return ERROR;
}
/////////////返回线性表后继//////////////////////
Status NextElem(SqList L,ElemType cur_e,ElemType &pre_e)
{
    int i = 0;
    while(L.elem[i]!=cur_e && i<L.length)
        i++;
    if(i == 0 || i == L.length)    return ERROR;
        pre_e = L.elem[i-1];
    return OK;
}
Status NextElem(LinkList L,ElemType cur_e,ElemType &next_e)
{
    LinkList p;
    p=L->next;
    while(p->next)
    {
        if(p->data == cur_e)
        {
            next_e = p->next->data;
            return OK;
        }
        p = p->next;
    }
    return ERROR;
}
/////////////线性表插入//////////////////////////
Status ListInsert(SqList &L,int i,ElemType &e)
{
    if((i<1)||(i>L.length)) return ERROR;   //如果插入元素不在表的范围之内，插入失败
    if(L.length == MAXSIZE) return ERROR;   //如果顺序表已满，插入失败
    for(int j = L.length;j >= i-1;j--)      //从第i位开始，每个元素依次向后移动一个单位
    {
        L.elem[j+1] = L.elem[j];
    }
    L.elem[i-1] = e;    //将第i位元素数据域设置为e
    ++L.length;         //表长+1
    return OK;
}
Status ListInsert(LinkList &L,int i,ElemType &e)
{
    LinkList p,s;
    int j=0;
    p=L;
    while(p && (j<i-1)) //查找第i-1个结点，使p指向该结点
    {
        p = p->next;
        ++j;
    }
    if(!p || j>i-1) return ERROR;   //i>n+1或者i<1，插入失败
    s = new LNode;  //为新结点分配内存
    s->data = e;    //新结点数据域置为e
    s->next = p->next;  //新结点的后继设置为p的后继
    p->next = s;    //p的后继设置为s
    return OK;
}
/////////////线性表删除//////////////////////////
Status ListDelete(SqList &L,int i)
{
    if((i<1) || (i>L.length))   return ERROR;   //如果删除元素不在表的范围之内，删除失败
    for(int j = i;j <= L.length;j++)
        L.elem[j-1] = L.elem[j];    //被删除元素之后的元素前移
    --L.length;  //表长-1
    return OK;
}
Status ListDelete(LinkList &L,int i)
{
    LinkList p,q;int j = 0;
    p = L;
    while((p->next) && (j<i-1)) //查找第i-1个结点，p指向该结点
    {
        p = p->next;
        ++j;
    }
    if(!(p->next) || (j>i-1))   return ERROR;   //当i>n或i<1时，删除位置不合适
    q = p->next;    //临时保存被删结点的位置以备释放
    p->next = q->next;  //改变删除结点前驱结点的指针域
    delete q;       //释放删除结点的空间
    return OK;
}
/////////////线性表元素遍历//////////////////////
Status TraverseList(SqList L)
{
    for(int i=0;i<L.length;i++)
    {

    }
    return OK;
}
Status TraverseList(LinkList L)
{
    while(L->next)
    {
        L = L->next;
        cout<<L->data<<‘ ‘;
    }
    return OK;
}
/////////////创建单链表(头插法)(带头节点)//////////////////////
void CreateList_H(LinkList &L,int n)
{
    LinkList p;
    L = new LNode;
    L->next = NULL;
    for(int i = 0;i < n;i++)
    {
        p = new LNode;
        cin>>p->data;
        p->next = L->next;
        L->next = p;
    }
}
/////////////创建单链表(头插法)(不带头节点)//////////////////////
void CreateList_NH(LinkList &L,int n)
{
    LinkList p;
    L->next = NULL;
    for(int i = 0;i < n;i++)
    {
        p = new LNode;
        cin>>p->data;
        p->next = L->next;
        L->next = p;
    }
}
/////////////创建单链表(尾插法)(带头节点)//////////////////////
void CreateList_R(LinkList &L,int n)
{
    LinkList p,r;
    L = new LNode;
    L->next = NULL;
    r=L;
    for(int i = 0;i < n;i++)
    {
        p = new LNode;
        cin>> p->data;
        p->next = NULL;
        r->next = p;
        r = p;
    }
}
/////////////创建单链表(尾插法)(不带头节点)//////////////////////
void CreateList_NR(LinkList &L,int n)
{
    LinkList p,r;
    L->next = NULL;
    r=L;
    for(int i = 0;i < n;i++)
    {
        p = new LNode;
        cin>> p->data;
        p->next = NULL;
        r->next = p;
        r = p;
    }
}
/////////////双向链表定义//////////////////////
typedef struct DuLNode
{
    ElemType data;          //数据域
    struct DuLNode *prior;  //指向直接前驱
    struct DuLNode *next;   //指向直接后继
}DuLNode,*DuLinkList;
/////////////双向链表插入//////////////////////
Status ListInsert_DuL(DuLinkList &L,int i,ElemType e)
{
    DuLinkList p,s;
    int j=0;
    p=L;
    while(p && (j<i-1)) //查找第i-1个结点，使p指向该结点
    {
        p = p->next;
        ++j;
    }
    if(!p || j>i-1) return ERROR;   //i>n+1或者i<1，插入失败
    s = new DuLNode;
    s->data = e;            //s的数据域设置为e
    s->prior = p->prior;    //s的前驱设置为p的前驱
    p->prior->next = s;     //p的前驱元素的后继设置为s
    s->next = p;            //s的后继设置为p
    p->prior = s;           //p的前驱设置为s
    return OK;
}
/////////////双向链表删除//////////////////////
Status ListDelete_DuL(DuLinkList &L,int i)
{
    DuLinkList p,q;int j = 0;
    p = L;
    while((p->next) && (j<i-1)) //查找第i-1个结点，p指向该结点
    {
        p = p->next;
        ++j;
    }
    if(!(p->next) || (j>i-1))   return ERROR;   //当i>n或i<1时，删除位置不合适
    p->prior->next = p->next;   //p的前驱元素的后继设置为p的后继
    p->next->prior = p->prior;  //p的后继元素的前驱设置为p的前驱
    delete p;      //删除元素p
    return OK;
}
/////////////线性表的合并(顺序表)(无序表)//////////////////////
void MergeList(SqList &LA,SqList LB)
{
    int m = LA.length;
    int n = LB.length;
    ElemType e;
    for(int i = 1;i<=n;i++)
    {
        GetElem(LB,i,e);
        if(!LocateElem(LA,e))
            ListInsert(LA,++m,e);
    }
}
/////////////线性表的合并(顺序表)(有序表)//////////////////////
void MergeList_Sq(SqList LA,SqList LB,SqList &LC)
{   //将AB两表中的有序数据统一有序放到一个C表中
    LC.length = LB.length+LA.length;//新表的长度等于两表的长度和
    LC.elem  = new ElemType[LC.length];//为新表申请空间
    ElemType *pa,*pb,*pc,*pa_last,*pb_last;//定位三个表中各个结点的位置
    pc = LC.elem;
    pa = LA.elem;
    pb = LB.elem;
    pa_last = LA.elem + LA.length-1;
    pb_last = LB.elem + LB.length-1;
    while((pa<pa_last)&&(pb<pb_last))//依次摘取两表中数值较小的结点放到c表的最后
    {
        if(*pa<=*pb)    *pc++ = *pa++;//如果当前A表的数据小于B表的数据，先取A表数据
        else    *pc++ = *pb++;      //否则取B表的数据
    }
    while(pa <= pa_last)  *pc++ = *pa++;//如果A表的数据还没有取完，继续取
    while(pb <= pb_last)  *pc++ = *pb++;//如果B表的数据还没有取完，继续取
}
/////////////线性表的合并(链式表)//////////////////////
void MergeList_L(LinkList &LA,LinkList &LB,LinkList &LC)
{
    LinkList pa,pb,pc;
    pa = LA->next;
    pb = LB->next;
    LC = LA;
    pc = LC;
    while(pa && pb)
    {
        if(pa->next <= pb->next)
        {
            pc->next = pa;
            pc = pa;
            pa = pa->next;
        }
        else
        {
            pc->next = pb;
            pc = pb;
            pb = pb->next;
        }
    }
    pc->next = pa? pa:pb;
    delete LB;
}

原文地址：https://www.cnblogs.com/basketball616/p/11143597.html

时间： 2025-01-13 18:52:02

数据结构总结第二章线性表抽象数据类型的具体实现的相关文章

数据结构之第二章线性表之静态链式存储

1--特点:用一维数组来描述线性表,用游标代替指针指示节点在数组中的相对位置.不设“指针”类型的高级语言中适用链表结构. 2--线性表的静态链式存储结构 //// 静态单链表.h// 单链表的静态存储//// 6 // Copyright (c) 2014年 dashuai. All rights reserved.// #ifndef SLIST_H#define SLIST_H#include <stdio.h>#include <stdlib.h> #define MA

数据结构之第二章线性表之链式存储

1~~特点:逻辑上相邻的元素,他的物理位置不一定相邻,其实几乎是不像邻的.表中的元素只能顺序访问,插入,删除等操作只需修改指针而不需要移动元素,存储空间利用率高,表的容量可以动态变化.适合个数变化大的情况. 2--链式存储`的存储结构 typedef struct Node{ int data; struct Node *next; }NODE,*PNODE; 3~~线性表的基本操作 (1)线性表的的插表头建立算法 ” 插表头“方式得到的线性链表,元素存储的顺序和输入顺序相反,这与栈的特

数据结构之第二章线性表

1 线性表的顺序存储 (1)线性表的顺序存储特点:逻辑上相连的元素,物理位置也相连.可随机访问表中元素,表中的存储位置可以用一个简单的,直观的公式表示,但是插入和删除都要移动大量的元素,效率不高,适合元素个数变化不大的情况,此时,如数据元素按照一定的顺序存储,则称为顺序存储的有序表,简称为静态表. (2)线性表的动态分配顺序存储结构 typedef struct{ Elemtype *elem; //存储空间起始地址 int length; //当前长度 int listsize; //

数据结构之第二章线性表~~继续

(3)顺序表的查找 int locatlink(PNODE head,int e,int (*compare)(int ,int )) {//在head中查询第一个满足条件的元素的位置,若不存在,则返回-1 i: while(i<head.length&&!(*compare)(head.elem[i],e)) ++i; if(i<head.length) return i; else return -1; } 有序表的合并 void hebing(PNODE head1,PN

数据结构期末复习第二章线性表

第二章:线性表 1.线性结构的基本特征答:线性结构是若干数据元素构成的有序(次序)集① 集合中必存在唯一的一个“第一元素”:② 集合中必存在唯一的一个 “最后元素”:③ 除第一元素之外,均有唯一的前驱:④ 除最后元素之外,均有唯一的后继. 2.线性表的顺序存储结构和链式存储结构分别是______.( D ) A. 顺序存取的存储结构.顺序存取的存储结构 B. 顺序存取的存储结构.随机存取的存储结构 C. 随机存取的存储结构.随机存取的存储结构 D. 随机存取的存储结构.顺序存取

《数据结构与算法》第二章线性表

线性表定义: 由n个特性相同数据元素(即可有很多数据项)构成的有限序列,同时相邻数据元素之间存在序偶关系. 线性表中元素个数就是表长 . 特点: ·存在唯一一个被称为 “第一个” 的数据元素(线性起点.起始结点): ·存在唯一一个被称为 “最后一个” 的数据元素(线性终点.终端结点): ·除第一个以外,结构中的每个数据元素均只有一个前驱 : ·除最后一个外,结构中的每个数据元素均只有一个后继 . 顺序表示和实现线性表的顺序表示指的是用一组地址连续的存储单元一次存储线性表的数据元素

数据结构-王道2017-第2章线性表

1. 线性表的定义和基本操作 1.1 线性表的定义线性表电话i具有相同数据类型的n(n >= 0)个数据元素的有限序列.其中n为表长,当n=0时,该线性表是一个空表.若用L命名线性表,则一般表示为: L=(a1,a2,a3...ai,ai+1...an) 其中,a1是唯一的第一个数据元素,又称为表头元素:an是唯一的最后一个数据元素,又称为表尾元素.除第一个元素外,每个元素有且仅有一个直接前驱.除最后一个元素外,每个元素有且仅有一个直接后继.以上就是线性表的逻辑特性,这种线性有序的逻辑结构正是

第二章线性表

2.1线性表类型定义线性表描述:A=(a1,a2,...an);A为线性表的名称,ai为线性表的数据元素. 线性表的离散定义:B=<A,R>,A包含n个结点(a1,a2,...an),R中只包含一个关系,即线性关系,R={(ai-1,ai)|i=1,2,....,n}, 一般的线性表的操作可以包含以下几种: * public linklist() 建立一个空的线性表. * public linklist(collection c) 将collection c中的数据依次建立一个线性表.

第二章——线性表

线性表一.定义线性表是最常用且最简单的一种数据结构. 简而言之,一个线性表是n个数据元素的有限的序列. 线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的 (注意,这句话只适用大部分线性表,而不是全部.比如,循环链表逻辑层次上也是一种线性表(存储层次上属于链式存储),但是把最后一个数据元素的尾指针指向了首位结点).by~百度百科二.线性表的顺序表示和实现 1.顺序表示指的是用一组地址连续的储存单元依次储存线性表的数据元素. 通常用数组来

数据结构总结 第二章 线性表 抽象数据类型的具体实现

数据结构总结 第二章 线性表 抽象数据类型的具体实现的相关文章

数据结构总结第二章线性表抽象数据类型的具体实现

数据结构总结第二章线性表抽象数据类型的具体实现的相关文章