线性表--顺序表、单链表、双链表 总结

线性表--顺序表、单链表、双链表 基础操作总结

函数：
         王道--数据结构--已在Visio Stdio 2019验证成功！
                     顺序表插入 删除 查找
                     单链表的头插法、尾插法，按值/按序查找，插入/删除
                     双链表的头插法、尾插法，按值/按序查找，插入/删除

验证：

// 栈、队列与顺序表.cpp : 此文件包含 "main" 函数。
#include <iostream>
#include "stdio.h"
#define MaxSize 50 
typedef int  ElemType;

typedef struct {//静态顺序线性表定义
    ElemType data[MaxSize];
    int length;
}SqList;

typedef struct{//动态顺序线性表定义
    ElemType * data;
    int seqlist_maxsize, Length;
}SeqList;
typedef struct LNode {//单链表定义
    ElemType data;
    struct LNode* next;
}*LinkList;
typedef struct DNode {//双链表定义
    ElemType data;
    struct DNode *prior,*next;
}DNode,*DLinkList;
/************************顺序线性表****************************/
//插入操作：在镜头顺序表L的第i位置插入新元素e;
bool ListInsert(SqList* L, int i,ElemType e )
{
    if (i<0 || i>L->length)
        return false;
    if (i > MaxSize)
        return false;
    for (int j = L->length; j >= i; j--)
        L->data[j] = L->data[j-1];
    L->data[i - 1] = e;
    L->length++;
    return true;
}
//删除操作：删除顺序表中的第i个元素，删除原始通过e返回
bool ListDelete(SqList &L,int i,ElemType *e)
{
    if (i<0 || i>L.length)
        return false;
    if (i > MaxSize)
        return false;
    *e = L.data[i-1];
    for (int j = i; j < L.length; j++)
        L.data[j-1] = L.data[j];
    L.length--;
    return true;
}
//顺序查找：按值查找
int LocateElem(SqList L, ElemType e)
{
    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] == e)
            return i + 1;
    }
    return 0;
}
/************************链式顺序表****************************/
void PrintLink(LNode* head)
{
    LNode* p = head->next;
    for (; p; p = p->next)
        printf("%5d", p->data);
}
//创建单链表1--头插法
LinkList List_HeadInsert(LinkList &L)
{
    LNode* s; int x;
    L = (LinkList)malloc(sizeof(LNode));//创建头节点
    L->next = NULL;                     //初始为空链表
    printf("头插法L输入节点数据：");
    scanf_s("%d",&x);
    while (x!=999)
    {
        s = (LNode*)malloc(sizeof(LNode));//创建新节点
        s->data = x;
        s->next = L->next;
        L->next = s;
        scanf_s("%d", &x);
    }
    return L;
}
//创建单链表2--尾插法
LinkList List_TailInsert(LinkList &L)
{
    LNode* s; int x;
    L = (LinkList)malloc(sizeof(LNode));//
    L->next = NULL;                     //初始为空链表
    LNode *r=L;                         //r为附加设置的表尾指针
    printf("\n尾插法L2输入节点数据：");
    scanf_s("%d", &x);
    while (x != 999)
    {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;

        r=s;                          //r指向新的表尾结点
        scanf_s("%d", &x);
    }
    r->next = NULL;                    //尾结点指针置空
    return L;
}
//按序查找结点:查找单链表中第i个结点
LNode* GetElem(LinkList L,int i)
{
    int j = 1;
    LNode* p=L->next;//头结点指针 
    if (i == 0)//0返回头结点
        return L;
    if (i < 1)//无效返回空
        return NULL;
    while (p&&j < i)
    {
        p = p->next;
        j++;
    }
    printf("\n按序查找结果：%d", p->data);
    return p;
}
//按值查找结点：查找值为e的元素并返回该指针
LNode* LocateElem(LinkList L, ElemType e)
{
    LNode* p = L->next;
    while (p && p->data != e)
        p = p->next;
    if (p == NULL)
        printf("\n按值查找结果：无");
    else
        printf("\n按值查找结果：存在该元素");
    return p;
}
//插入新结点
bool ListFrontInsert(LinkList L, int i, ElemType e)
{
    LNode* p = L->next;
    p = GetElem(L,i-1);
    if (p == NULL) return false;
    LNode* s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next=p->next;
    p->next = s;
    return true;
}
//删除新结点
bool ListDelete(LinkList L, int i)
{
    LNode* p = L->next;
    p = GetElem(L, i - 1);
    if (p == NULL) return false;
    p->next= p->next->next;
    return true;
    //LNode* p = L->next;
    //p = GetElem(L, i - 1);
    //if (p == NULL) return false;
    //LinkList q;
    //q = p->next;
    //p->next = q->next;
    //free(q);
    //return true;
}
/***********************双指针链式顺序表************************/
//创建双链表1--头插法
DLinkList Dlist_head_insert(DLinkList& DL) { //List_head_insert
    DNode* s; int x;
    DL = (DLinkList)malloc(sizeof(DNode));//建立头结点
    DL->next = NULL;
    DL->prior = NULL;
    printf("\n双链表-输入：");
    scanf_s("%d", &x);
    while (x != 999) {
        s = (DNode*)malloc(sizeof(DNode));
        s->data = x;
        s->next = DL->next;
        if (DL->next != NULL) {
            DL->next->prior = s;
        }
        s->prior = DL;
        DL->next = s;
        scanf_s("%d", &x);
    }
    return DL;
}
//创建双链表2--尾插法
DLinkList Dlist_tail_insert(DLinkList& DL) {//List_tail_insert
    int x;
    DL = (DLinkList)malloc(sizeof(DNode));
    DNode* s, * r = DL;
    DL->prior = NULL;
    printf("\n双链表-输入：");
    scanf_s("%d", &x);
    while (x != 999) {
        s = (DNode*)malloc(sizeof(DNode));
        s->data = x;
        r->next = s;
        s->prior = r;
        r = s;
        scanf_s("%d", &x);
    }
    r->next = NULL;
    return DL;
}
//按序查找结点:查找单链表中第i个结点
DNode* GetElem(DLinkList DL, int i) {
    int j = 1;
    DNode* p = DL->next;
    if (i == 0)
        return DL;
    if (i < 1)
        return NULL;
    while (p && j < i) {
        p = p->next;
        j++;
    }
    return p;
}
//插入新结点
bool DListFrontInsert(DLinkList DL, int i, ElemType e) {
    DLinkList p = GetElem(DL, i - 1);
    if (NULL == p) {
        return false;
    }
    DLinkList s = (DNode*)malloc(sizeof(DNode));
    s->data = e;
    s->next = p->next;
    p->next->prior = s;
    s->prior = p;
    p->next = s;
    return true;
}
//删除新结点
bool DListDelete(DLinkList DL, int i) {
    DLinkList p = GetElem(DL, i - 1);
    if (NULL == p) {
        return false;
    }
    DLinkList q;
    q = p->next;
    if (q == NULL)
        return false;
    p->next = q->next;
    if (q->next != NULL) { //删除最后一个元素，需要的判断 
        q->next->prior = p;
    }
    free(q);
    return true;
}
//打印双链表
void PrintDList(DLinkList DL) {
    DL = DL->next;
    while (DL != NULL) {
        printf("%3d", DL->data);
        DL = DL->next;
    }
    printf("\n");
}
//顺序线性表
void Seq_List()
{
    SqList L;
    int data_buff;
    for (int i = 0; i < 8; i++) { L.data[i] = i; L.length = i + 1; }
    printf("\n插入前:");
    for (int i = 0; i < L.length; i++) printf("%d\t", L.data[i]);

    if (true == ListInsert(&L, 1, 9))
    {
        printf("\n插入后:");
        for (int i = 0; i < L.length; i++) printf("%d\t", L.data[i]);
    }
    else
    {
        printf("\n插入 失败！");
    }

    if (true == ListDelete(L, 1, &data_buff))
    {
        printf("\n删除后:");
        for (int i = 0; i < L.length; i++) printf("%d\t", L.data[i]);
    }
    else
    {
        printf("\n删除失败");
    }
    data_buff = LocateElem(L, 3);
    if (data_buff == 0)
    {
        printf("\n查找失败！");
    }
    else
    {
        printf("\n按值查找到元素位置为%d！\n", data_buff);
    }
}
//单链表的操作
void Link_List()
{
    LNode* L,*head,*node,*L2;
    bool statue=false;
    //head = List_HeadInsert(L);//头插建立
    //PrintLink(head);
    head = List_TailInsert(L2); //尾插建立
    PrintLink(head);
    node=GetElem(L2,1);         //按序查找
    node=LocateElem(L2,3);      //按值查找
    if (true == ListFrontInsert(L2,2,0))
    {
        printf("\n插入成功！插入结果：");
        PrintLink(L2);
    }
    else
    {
        printf("\n插入失败！结果：");
        PrintLink(L2);
    }
    if (true == ListDelete(L2, 2))
    {
        printf("\n删除成功！删除结果：");
        PrintLink(L2);
    }
    else
    {
        printf("\n删除失败！结果：");
        PrintLink(L2);
    }
       
}
//双链表的操作
void DLink_List()
{
    DNode *DL, * DL2,*dead;
    ElemType buff;
    dead = Dlist_head_insert(DL);   //头插法
    PrintDList(DL);
    dead = Dlist_tail_insert(DL2);  //尾插法
    PrintDList(DL2);
    GetElem(DL2,1);                 //按序查找
    if (true == DListFrontInsert(DL2, 2, 0))  //在i位插入
    {
        printf("\n双链表插入成功！");
        PrintDList(DL2);
    }
    else
    {
        printf("\n双链表插入失败！");
    }
    
    if (true == DListDelete(DL2, 2))  //在i位插入
    {
        printf("\n双链表删除成功！");
        PrintDList(DL2);
    }
    else
    {
        printf("\n双链表删除失败！");
    }
}
int main()
{
    std::cout << "Hello World!\n";
    //Seq_List();//顺序表插入 删除 查找
    //Link_List();//单链表的头插法、尾插法，按值/按序查找，插入/删除
    DLink_List();//双链表的头插法、尾插法，按值/按序查找，插入/删除
    system("pause");
}