DS--顺序表和链表

/****************

Project: List(Sequence List and LinkList)
Data: 2021/09/14,2021/11/11整理完毕
Author: Alex_yrdm

****************/

顺序表的实现

/*****************
Part1: Sequence List
*****************/

/*
 Sequence List dynamic allocation:
 void show(SqList L);                               参数:顺序表L.功能:打印输出表L中所有元素.时间复杂度:O(n)
Status ListInsert_Sq(SqList& L, int i, int e);      参数:顺序表L,位置i,插入元素e.功能:将元素e插入到位置i处.时间复杂度:O(n)
Status InitList_Sq(SqList& L);                      参数:顺序表L.功能:初始化顺序表L.时间复杂度:O(1)
Status ListDelete_Sq(SqList& L, int i, int& e);     参数:顺序表L,位置i,用于接受删除位置值的变量e.功能:删除位置为i的元素并返回该值.时间复杂度:O(n)

*/
//全局默认常量
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define InFEASIBLE -1
#define OVERFLOW -2
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10 
typedef int Status;
typedef int Elemtype;
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
struct SqList {
    Elemtype* elem;
    int length;
    int listsize;
};
void show(SqList L);
Status ListInsert_Sq(SqList& L, int i, Elemtype e);
Status InitList_Sq(SqList& L);
Status ListDelete_Sq(SqList& L, int i, Elemtype& e);
int main() {
    /*








    */
    return 0;
}



void show(SqList L) {
    for (int i = 0; i < L.length; i++) {
        cout << L.elem[i] << " ";
    }
    cout << endl;
}

Status ListInsert_Sq(SqList& L, int i, Elemtype e) {
    if (i<1 || i>L.length - 1) return ERROR;
    if (L.length >= L.listsize) {
        Elemtype* newbase;
        newbase = (Elemtype*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(Elemtype));
        if (!newbase) return OVERFLOW;
        L.elem = newbase;//这样写避免了realloc失败直接将空指针赋值给原地址导致原始数据内存块丢失
        L.listsize += LISTINCREMENT;
    }
    Elemtype* q = &(L.elem[i - 1]);
    for (Elemtype* p = &(L.elem[L.length - 1]); p >= q; p--) {
        *(p + 1) = *p;
    }
    *q = e;
    L.length++;
    return OK;
}

Status InitList_Sq(SqList& L) {
    L.elem = (Elemtype*)malloc(LIST_INIT_SIZE * sizeof(Elemtype));
    if (!L.elem) exit(OVERFLOW);
    L.length = 0;
    L.listsize = LIST_INIT_SIZE;
    return OK;
}


Status ListDelete_Sq(SqList& L, int i, Elemtype& e) {
    if (i<1 || i>L.length + 1) return ERROR;
    Elemtype* p = &(L.elem[i - 1]);
    e = *p;
    Elemtype* q = L.elem + L.length - 1;
    for (++p; p <= q; ++p) {
        *(p - 1) = *p;
    }
    L.length--;
    return OK;
}

链表

/******************
Part2: LinkList
******************/


/*
* 带有头节点链表:
    LinkList functions:
    int InitList(LinkList& L);                          参数:链表L.功能:初始化链表.时间复杂度:O(1)
    int createList(LinkList& L, int n);                 参数:链表L,初始化链表元素数目n.功能:创建n个元素的链表;时间复杂度:O(n)
    int size(LinkList L);                               参数:链表L.功能:返回链表中元素数目.时间复杂度:O(n)
    int ListInsert(LinkList& L, int i,Elemtype e);      参数:链表L,位置i,插入元素e.功能:在位置i处插入e.时间复杂度:O(n)
    int ListDelete(LinkList& L, int i, Elemtype& e);    参数:链表L,位置i,用于接收被删除节点元素的变量e.功能:删除位置i处的节点.时间复杂度:O(n)
    int ListOppose(LinkList& L);                        参数:链表L.功能:实现链表逆转.时间复杂度:O(n)

*/
#include<stdio.h>
#include<stdlib.h> 
typedef int Elemtype;
typedef struct LNode //单向链表
{
    Elemtype data;
    struct LNode* next;
}LNode, * LinkList;
int InitList(LinkList& L);
int createList(LinkList& L, int n);
int size(LinkList L);
int ListInsert(LinkList& L, int i,Elemtype e);
int ListDelete(LinkList& L, int i, Elemtype& e);
int ListOppose(LinkList& L);

int main() {
    return 0;
}
int InitList(LinkList& L) {
    L = NULL;
    return 1;
}
int createList(LinkList& L, int n) //正常顺序创建链表
{
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    LinkList q=L;
    for (int i = n; n > 0; i--) {
        LinkList p;
        p = (LinkList)malloc(sizeof(LNode));
        if (!p)
            return -1;
        scanf("%d", &p->data);
        p->next = NULL;
        q->next = p;
    }
    return 1;
}
/*int createList(LinkList& L, int n)//头插法创建链表
{
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    for (int i = n; i > 0; i--) {
        LinkList p;
        p = (LinkList)malloc(sizeof(LNode));
        if (!p) return -1;
        scanf("%d", &p->data);
        p->next = L->next;
        L->next = p;
    }
    return 1;
}*/
int size(LinkList L) {
    int num = 0;
    while (L->next) {
        num++;
        L = L->next;
    }
    return num;
}
int ListInsert(LinkList& L, int i, Elemtype e) {
    if (!L || i<1 || i>size(L) + 1)
        return -1;
    LinkList p;
    p = L;
    for (int j = 0; j < i - 1; j++) {//找到第i-1个结点
        p = p->next;
    }
    LinkList s;
    s = (LinkList)malloc(sizeof(LNode));
    if (!s) return -1;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return 1;
}
int ListDelete(LinkList& L, int i, Elemtype& e) {
    if (!L || i<1 || i>size(L))
        return -1;
    LinkList p;
    p = L;
    for (int j = 0; j < i - 1; j++) {//找到第i-1个结点
        p = p->next;
    }
    LinkList s;//用s指向即将被删除结点
    s = p->next;
    p = p->next->next;
    free(s);
    return 1;
}


int ListOppose(LinkList& L)//实现链表逆转
{
    LinkList p, q;
    p = L;
    p = p->next;
    L->next = NULL;
    while (p) {
        q = p;
        p = p->next;
        q->next = L->next;
        L->next = q;
    }
    return 1;
}
/*typedef struct DuLNode//双向链表
{
    int data;
    struct DuLNode* prior;
    struct DuLNode* next;
}DuLNode, * DuLinkList;*/
//int ListInsert_DuL(DuLinkList& L, int i, int e);
//int ListDelete_DuL(DuLinkList& L, int i, int& e);
/*
int ListInsert_DuL(DuLinkList& L, int i, int e)//双向链表插入元素
{
    DuLinkList p, q, s;
    p = L;
    for (int j = 1; j < i; j++) {
        p = p->next;
    }
    q = p->next;
    if (!(s = (DuLinkList)malloc(sizeof(DuLNode)))) return -1;
    s->data = e;
    p->next = s;
    s->prior = p;
    s->next = q;
    q->prior = s;
    return 1;
}
int ListDelete_DuL(DuLinkList& L, int i, int& e)//双向链表删除元素并用e返回
{
    DuLinkList p, q;
    p = L;
    for (int j = 1; j < i; j++) {
        p = p->next;
    }
    q = p->next;
    e = q->data;
    p->next = p->next->next;
    p->next->prior = p;
    free(q);
    return 1;
}
*/