数据结构中的线性表代码实现

define ElemType int

define OK 1

define ERROR 0

include “stdafx.h”

include“iostream” 不能用<>奇怪只能用“”

include“errors.h”不能用<>奇怪只能用“”你们报错可以在vs用<>

typedef int Statue;

int const LINST_INIT_SIZE = 100;
int const LISTINCREATMENT = 10;

typedef struct
{
ElemType *elem;
int length;
int listsize;
}SqList;

//初始化链表
Statue InitList_Sq(SqList &L)
{
//构造空表L
L.elem = (ElemType )malloc(LINST_INIT_SIZE sizeof(ElemType));

//分配成功判断

if (!L.elem) exit(OVERFLOW);

//线性表元素初始为0个
L.length = 0;

//保存当前线性表的内存容量
L.listsize = LINST_INIT_SIZE;

return OK;

}

//线性表的插入
Statue ListInsert(SqList &L, int i, ElemType e)
{
//在顺序表L中第i个位置插入新元素e

//插入位置判断
if (i < 1 || i > L.length + 1) return ERROR;

//满判断
if (L.length >= L.listsize)  perror("OVERFLOW");

//开始腾出待插入位置
for (int i = L.length - 1; i > i - 1; i--)
{
    L.elem[i + 1] = L.elem[i];
}

//开始插入元素e
L.elem[i - 1] = e;

//线性表元素增加1
L.length++;


return OK;

}

//线性表的删除
Statue LinkDelete_Sq(SqList &L, int i, ElemType &e)
{
//删除位置判断
if (i < 1 || i > L.length) return ERROR;

//空链表判断
if (L.length == 0) perror("当前链表为空，无法删除数据。");

//开始保存待删除位置的元素
e = L.elem[i - 1];

//开始移动删除元素后面的全部数据
for (int j = i - 1; j < L.length - 1; j++)
{
    L.elem[j] = L.elem[j + 1];
}

//开始减少1个元素
L.length--;

return OK;

}

//判断线性表L是否为空
bool ListEmpty(SqList &L)
{
return L.length == 0;
}

//得到线性表的长度，即线性表中元素的数量

int ListLength(SqList &L)
{
return L.length;
}

//线性单链表的节点数据类型定义
typedef struct LNode
{
ElemType data;
struct LNode *next;
} LNode, *LinkList;

//初始化线性链表
Statue InitList_L(LinkList &L)
{
//建立头节点
L = (LinkList)malloc(sizeof(LNode));

//开始给头节点初始化
L->data = -1;
L->next = NULL;

return OK;

}

//在线性链表中取第i个数据存放在元素e
//默认单链表有头节点
Statue GetElem_L(LinkList L, int i, ElemType &e)
{
//保存单链表头指针，防止更改了头指针里面的地址，导致其他地方无法使用
LinkList p = L;
int j = 1; //用来记录节点增加的数目

//开始定位i位置的节点
//开始拿到第一个节点元素地址
p = p->next;

//通过循环找到待查找节点的位置
while (p && j < i) //当p不为空以及没有跑到所要节点位置就一直循环
{
    p = p->next;
    j++;    
}

//开始判断是不是找到待查节点的位置
//当p = null代表定位的位置超出链表节点数量
//首先我们默认i只能取值从1开始表示第一个节点
//得到j > i告诉了我们定位的i取值小于1也就是想找第一个节点之前的
//当然是不存在这种节点
if (!p || j > i) 
  return ERROR;//没有找到待查找的位置

//代码进入这里说明在链表中找到了待查位置的节点
//开始保存需要节点的数据到e中
e = L->data;

return OK;

}

//往带头结点单链表插入节点e
Statue InsertNode(LinkList L, int i, ElemType &e)
{
//首先定义一个节点类型变量保存当前链表地址
LinkList q = L;

//新建一个节点，用于将e数据存入新节点当中
LinkList p = (LinkList)malloc(sizeof(LNode));

//判断是不是分配成功
if (!p) exit(OVERFLOW);

//开始写入数据
p->data = e;

//定义变量用于记录节点增加数量
int j = 1;

//开始通过循环找到待插位置的前一个节点
while (q && j < i - 1)
{
    q = q->next;
    j++;
}

//判断是不是找到需要的节点
if (!p || j > i)  return ERROR;

//开始将节点p插入链表
p->next = q->next;
q->next = p;

return OK;

}

//单链表定位元素e的位置
LNode* LocateElem_L(LinkList L, ElemType e)
{
//找到第一个出现值和e相同的节点，并返回其地址，不存在则返回null
//先判当前链表是不是为null

LinkList p;
if (!L)
{
    return NULL;
}

p = L;

//开始遍历链表查找节点中数据为e的节点
while (p && p->data != e)
{
    p = p->next;
}

return p;

}

//线性表的应用
//比如2个线性表的大小 注意A,B是用的顺序存储链表
int Compare(SqList A, SqList B)
{
//如果A < B 返回-1，A = B 返回0 反之返回1

int j = 0; //用于记录顺序链表A和B共同部分的索引值

//开始使用循环遍历链表节点比较A和B链表上的节点大小
while (j < A.length && j < B.length) //保证遍历完顺序表中长度小的链表
{
    if (A.elem[j] > B.elem[j])
    {
        return 1;  //出现A链表中的节点数据大
    }
    else if(A.elem[j] == B.elem[j]) //如果比较的节点是相等，那么我们都把索引+1，比较顺序表下一个节点数据
    {
        j++;
    }
    else   //B中节点大
    {
        return -1;
    }

    if (A.length == B.length) return 0; //执行上面循环出现当前结果表示链表长度一样，并且数据也都相等

    if (A.length > B.length) return 1;  //表示A链表和B链表共有部分数据是一样的，但是A链表元素更多


    return -1;  //这个是B链表元素多的情况
}

}

int main()
{
return 0;
}