数据结构-单链表

数据结构-单链表

#include <stdio.h>
#include <stdlib.h>

typedef struct 
{
    int data;
    LNode *next;
}LNode,*LinkList; //一个节点  一个指针类型

//初始化 一个空的单链表 不带头
bool InitNoHeadLinkList(LinkList &L)
{
    L = NULL; //空表
    return true;
}

//初始化 一个空的单链表 带头
bool InitLinkList(LinkList &L)
{
    //申请一个节点  L指向该节点
    L= (LNode *) malloc(sizeof(LNode));
    if (L==NULL)
    {
        return false;//内存不足  分配失败
    }
    L->next = NULL;
    return true;
}

//插入  --不带头节点
bool InsertNoHList(LinkList &L, int i, int e)
{
    if (i < 1)
    {
        return false; //判断插入位置合法
    }
    // 插入位置是第一个 区别
    if(i==1)
    {
        //创建节点  下面可以用 return InsertNextNode(p,e);代替
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = e;    //赋值
        s->next = L; //
        L=s;       //
        return true;
    }
    LNode *p;
    int j = 1; //当前p节点的位置  区别：无头结点  所以第一个节点就是L
    p = L;
    while (p != NULL && j < i - 1)
    {
        //遍历L中的节点到i的位置  时间复杂度O(n)
        p = p->next;
        j++;
    }
    if (p == NULL)
    {
        return false; //i值不合法
    }
    //创建节点
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;    //赋值
    s->next = p->next; //将前一个节点的next给新节点的next
    p->next = s;       //将前一个节点的next变为自己 插队
    return true;
}

//插入  --带头节点
bool InsertNode(LinkList &L,int i,int e)
{
    if (i<1)
    {
        return false;//判断插入位置合法
    }
    LNode *p;
    int j = 0;  //当前p节点的位置 因为带了头节点的
    p = L;
    while (p!=NULL&&j<i-1)
    {
        //遍历L中的节点到i的位置  时间复杂度O(n)
        p = p->next;
        j++;
    }
    if (p==NULL)
    {
        return false;//i值不合法 
    }
    //创建节点  下面可以用 return InsertNextNode(p,e);代替
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;//赋值
    s->next=p->next;//将前一个节点的next给新节点的next
    p->next = s;//将前一个节点的next变为自己 插队
    return true;
}

//插入  后插O(1)：指定节点后插入新的节点
bool InsertNextNode(LNode *p,int e)
{
    if (p == NULL)
    {
        return false; //P不合法
    }
    //创建节点
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s==NULL)
    {
        return false; //内存申请失败
    }
    s->data = e;    //赋值
    s->next = p->next; //将前一个节点的next给新节点的next
    p->next = s;       //将前一个节点的next变为自己 插队
    return true;
}

//插入  前插 复杂度O(1) :  未知区域 ~ ~ X（P）节点->Y节点~~~  要在P前面插入一个新的节点：将新的节点S插入到XY之间  对S和X的元素值进行替换
bool InsertPriorNode(LNode *p, int e)
{
    if (p == NULL)return false; //i值不合法
    //创建节点
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s == NULL) return false;
    s->next = p->next; //将前一个节点的next给新节点的next
    p->next = s;       //将前一个节点的next变为自己 插队
    //关键如下  交换值
    s->data = p->data;
    p->data = e;
    return true;
}
  
//删除O(n):按位 e接受被删除的值
bool DeleteIndexNode(LinkList &L, int i, int &e)
{
    if(i<1)return false;
    //替换： LNode *p=SearchIndexNode(L,i-1);
    LNode *p;
    int j = 0;
    p = L;
    while (p!=NULL&&j<i-1)
    {
        p = p->next;
        j++;
    }

    if (p==NULL)
    {
        return false;
    }
    if (p->next==NULL)
    {
        return false;
    }
    LNode *q = p->next; //q为被删除节点
    e = q->data;

    p->next = q->next;
    free(q);
    return true;
}

//删除指定节点p O(1)：未知区域 ~ ~ X（P）节点->Y节点~~~  删除Y节点：交换xy两个的值，然后进行next的交换 将Y节点释放
bool DeleteNode(LNode *p, int e)
{
    if (p == NULL)
        return false; //i值不合法
    LNode *q;
    q = p->next;
    p->data = q->data;//交换值
    //断链
    p->next = q->next;
    free(q);
    return true;
}

//查询按位O(n)： 带头结点
LNode * SearchIndexNode(LinkList L, int i)
{
    if (i < 0)
        return NULL;
    LNode *p;
    int j = 0;
    p = L;
    while (p != NULL && j < i ) //i=0时  返回头节点
    {
        p = p->next;
        j++;
    }
    return p;
}

//查询按值：带头结点
LNode *SearchNode(LinkList L,int e)
{
    LNode *p = L->next;
    while (p!=NULL&&p->data==e)
    {
        p = p->next;
    }
    return p;
}

//单链表的插入方法：头插、尾插
//尾插法 创建链表的时候将两个指针指向头结点 每插入一个节点  尾指针后移
void InsertTail(LinkList &L)
{
    LNode *s, *r;//r是表未指针
    r = L;
    int a = 0;
    scanf("%d",&a);
    while (a!=9999)   
    {
        s = (LNode *)malloc(sizeof(LNode));
        s->data = 1;//新节点赋值
        //开始尾插
        r->next = s;
        r = s;
    }
    r->next = NULL;
    //尾插结束  L-a->b->c->d->NULL
    //                     r 
}

//头插法:（逆置重点）  输入 a b c d 在链表中：d c b a  其都是前面的后插操作
void InsertHeadList(LinkList &L)
{
    LNode *s;
    int a = 0;
    scanf("%d", &a);
    L->next = NULL;
    while (a != 9999)
    {
        s = (LNode *)malloc(sizeof(LNode));
        s->data = 1; //新节点赋值
        //开始头插
        s->next = L->next;
        L->next = s;//L始终在前面
    }
}

//双链表  双指向
typedef struct 
{
    int data;
    DNode *prior, *next;//前驱结点 后继节点
}DNode,*DLinkList;

//双链表初始化
bool InitDLinkList(DLinkList &L)
{
    L = (DNode *)malloc(sizeof(DNode));
    if (L==NULL)
    {
        return false;
    }
    L->prior = NULL;
    L->next = NULL;
    return true;
}

//插入s到p的后面
void InsertNextDNode(DNode *p,DNode *s)
{
    s->next = p->next;
    if (p->next!=NULL)p->next->prior = s;

    s->prior = p;
    p->next = s;
}

//删除p后面的后继节点
bool deleteDNode(DNode *p)
{   
    //找到p的后继节点
    DNode *q = p->next;
    if (q==NULL)
    {
        return false;//p没有后继
    }
    
    p->next = q->next;
    if(q->next!=NULL)
    q->next->prior = q;

    free(q);
    return true;
}
//销毁双链表
void DestroyDNode(DLinkList &L)
{
    while (L->next!=NULL)
    {
        deleteDNode(L);
    }
    free(L);
    L = NULL;
}
    
    //循环单链表
/**
 * 在单链表的基础上将最后一个节点的next指向头指针L  L->next=L  可以用来判断是否空表：L->next==L
 * 一般L的位置放在链表的最后，方便插入新的节点O(1) 且L->next就是头结点的地址
 */

    //循环双链表
/**
 * 表头节点的前驱 指向表尾
 * 表尾节点的后继 指向头节点
 * 判空：if(L->next==L)
 * 判断节点p是否是循环双链表的最后一个节点：p->next=L
 */
    
    
    int main()
{
    // LinkList L; //声明一个单链表L
    // InitLinkList(L);//初始化单链表
    DLinkList L;
    InitDLinkList(L); //初始化双链表
}