C++线性表和链表

typedef struct { char c; } s; // 定义名为s的struct类型

typedef int *p; //定义了一个名为p的指针类型, 它指向int (中文描述指针好累)

typedef int f(); // 定义一个名为f, 参数为空, 返回值为int的函数类型
 
typedef int g(int); // 定义一个名为g, 含一个int参数, 返回值为int行的函数类型

#include<iostream>
#include<time.h>
using namespace std;
#define MAX_SIZE 100
#define ERROR -1
#define OK 1
typedef int Status;
typedef int ElemType;
//生成随机数
int GetRandomNumber()
{
    int RandomNumber;
    srand((unsigned)time(NULL));//time()用系统时间初始化种。为rand()生成不同的随机种子。
    RandomNumber = rand() % 100 + 1;//生成1~100随机数
    return RandomNumber;
}
typedef struct Lnode 
{
    ElemType data;
    struct Lnode* next;
}LNode;
//定义先行列表的结构
typedef struct sqlist
{
    ElemType Elem_array[MAX_SIZE];
    int length=0;
}SqList;
//初始化线性列表
SqList* InitializeList() {
    SqList* L;
    for (int i{ 0 }; i < 50; i++) {
        L->Elem_array[i] = GetRandomNumber();
        L->length++;
    }
    return L;
}
//插入线性表  顺序线性表的删除则是相反过程
Status Insert_SqList(SqList* L, int i, ElemType e)
{
    int j;
    if (i<0 || i>L->length - 1) return ERROR;
    if (L->length >= MAX_SIZE)
    {
        cout << "线性表溢出！\n"; return ERROR;
    }
    for (j = L->length; j >= i - 1; --j) {
        L->Elem_array[j + 1] = L->Elem_array[j];
    }
    L->Elem_array[i - 1] = e;
    L->length++;
    return OK;
}
//删除线性表中值为x的第一个节点
Status Locate_Delete_SqList(SqList* L, ElemType x)
{
    int j=0, k;
    while (j<L->length)
    {
        if (L->Elem_array[j] != x) j++;
        else {
            for (k = j; k < L->length - 1; k++) {
                L->Elem_array[k] = L->Elem_array[k + 1];
            }
            L->length--;
            break;
        }
        if (j > L->length) {
            cout << "要删除的元素不存在！\n";
            return ERROR;
        }
        else
        {
            return OK;
        }
    }
}
//建立单链表（头插法）
LNode* creat_LinkList(void)
{
    int data;
    LNode* head, * p;
    head = (LNode*)malloc(sizeof(LNode));
    head->next = NULL;
    while (true)
    {
        cout << "请输入单链表数据（当数据为520时停止输入）" << endl;;
        cin >> data;
        if (data != 520)
        {
            p = (LNode*)malloc(sizeof(LNode));
            p->data = data;
            p->next = head->next;
            head->next = p;
        }
        else
        {
            break;
        }
    }
    return(head);
}
//单链表（尾插法）
LNode* creat_LinkList(void)
{
    int data;
    LNode* head, * p, * q;
    head =q= (LNode*)malloc(sizeof(LNode));
    head->next = NULL;
    while (true)
    {
        cout << "请输入单链表数据（当数据为520时停止输入）" << endl;;
        cin >> data;
        if (data != 520)
        {
            p = (LNode*)malloc(sizeof(LNode));
            p->data = data;
            p->next = q->next;
            q->next = p;
            q = p;
        }
        else
        {
            break;
        }
    }
    return(head);
}
//单链表的插入（插入到第i个节点）
LNode* Insert_LNode(LNode* L, int i, ElemType e)
{
    int j;
    LNode* p, * q;
    p = L->next;
    while (j < i-1 && p!=NULL)
    {
        p = p->next;
        j++;
    }
    if (j != i - 1) cout << "i太大，超出范围！！" << endl;
    else {
        q = (LNode*)malloc(sizeof(LNode));
        q->data = e;
        q->next = p->next;
        p->next = q;
    }
}
//单链表的按值索引删除
void Delete_LinkList(LNode* L, int i)
{
    int j;
    LNode* p,*q;
    p = L; q = L->next;
    while (q->next!=NULL&&j<i)
    {
        p = q;
        q = q->next;
        j++;
    }
    if (j != i) cout << "i太大了" << endl;
    else {
        p->next = q->next; free(q);
    }
}
//删除以L为头节点的单链表值为key的第一个节点
void Delete_LinkList(LNode* L, int i)
{
    LNode* p, * q;
    p = L; q = L->next;
    int j;
    LNode* p,*q;
    p = L; q = L->next;
    while (p->next!=NULL&&p->data!=i)
    {
        p = q;
        q = q->next;
    }
    p->next = q->next;
    free(q);
}
//单链表的合并La 和 Lb 合成Lc，默认两个链表有空的head
LNode* Mergr_LinkList(LNode* La, LNode* Lb)
{
    LNode* Lc, * pa, * pb, * pc, * ptr;
    Lc = La; pc = La; pa = La->next; pb = Lb->next;
    while (pa!=NULL&&pb!=NULL)
    {
        if (pa->data < pb->data)
        {
            pc->next = pa;
            pc = pa;
            pa = pa->next;
        }
        if (pa->data > pb->data)
        {
            pc->next = pb;
            pc = pb;
            pa = pb->next;
        }
        if (pa->data == pb->data)
        {
            pc->next = pa;
            pc = pa;
            pa = pa->next;
            ptr = pb;
            pb = pb->next; free(ptr);
        }
        if (pa != NULL) pc->next = pa;
        else pc->next = pb;
        free(Lb);
    }
    return Lc;
}
//循环列表
LNode* creat_LinkList(void)
{
    int data;
    LNode* head, * p, * q;
    head = q = (LNode*)malloc(sizeof(LNode));
    head->next = NULL;
    while (true)
    {
        cout << "请输入单链表数据（当数据为520时停止输入）" << endl;;
        cin >> data;
        if (data != 520)
        {
            p = (LNode*)malloc(sizeof(LNode));
            p->data = data;
            p->next = q->next;
            q->next = p;
            q = p;
        }
        else
        {
            //首位相连
            p->next = head;
            break;
        }

    }
    return(head);
}
//双向列表的定义
typedef struct Dulnode
{
    ElemType data;
    struct Dulnode* prior, * next;
}DulNode;
//初始化双向列表
DulNode* DulNode_List()
{
    int data;
    DulNode* head, * p, * q;
    head =q = (DulNode*)malloc(sizeof(DulNode));
    head->next = NULL;
    head->prior = NULL;
    while (true)
    {
        cout << "请输入单链表数据（当数据为520时停止输入）" << endl;;
        cin >> data;
        if (data != 520)
        {
            p = (DulNode*)malloc(sizeof(DulNode));
            p->data = data;
            p->next = q->next;
            p->prior = q;
            q->next = p;
            q = p;
        }
        else
        {
            break;
        }
    }
    return(head);
}
int main() {
    SqList* L = InitializeList();

}