/****************
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;
}
*/