• 静态链表 初始化 插入


     #include <stdio.h>
    #include <stdlib.h>
    
    #define OK 1
    #define TRUE 1
    #define ERROR -1
    #define FALSE -1
    #define OVERFLOW -2
    #define ElemType int
    #define Status int
    //线性单链表 初始化 插入 取出 头插法 合并升序排列
    //-------------------------------线性单链表
    typedef struct LNode{ //封装一个线性单链表
        ElemType data; //数据域
        struct LNode *next; //指针域
    }LNode, *LinkList;//类型重定义struct LNode为Lnode,类型重定义 Lnode的*指针 为LinkList
    Status InitList_L(LinkList &L) {  //初始化线性链表
        L = (LinkList)malloc(sizeof(LNode)); //新开辟内存,返回指针L
        L->next = Null;//L->//对于指针p  p->a  被定义为 (*p).a   (不成文的标准)
        return TRUE;
    }
    Status GetElem_L(LinkList L,int i,ElemType &e){ //取出元素,i是序号,e为值
        //L为带头结点的单链表的头指针
        //当第i个元素存在时,将值返回给e,返回TRUE, 否则FALSE
        p = L->next; j = 1;//初始化,p指向第一个结点,j为计数器
        while (p && j<i) { //p指针非空,j计数器<i,所以循环的终点是i
            p = p->next; ++j;//指针后移一个,计数器+1一个
        }
        if (!p || j>i) return FALSE;//第i个元素不存在
        e = p->data;//取出第i个元素,值为e
        return TRUE;
    }//GetElem_L
    Status ListInsert_L(LinkList &L, int i, ElemType e) { //在带head的单链表L中第i个位置之前插入元素e    
        p = L; j = 0;//p为指针,被插入的previous Node
        while (p && j < i - 1) { p = p->next; ++j; }//寻找第i个结点,指针下移,j最后停在i
        if (!p || j>i) return FALSE;
        s = (LinkList)malloc(sizeof(LNode));//生成新节点,开辟内存空间 返回指针s,insert
        s->data = e;//s->data域的赋值 assignment
        s->next = p->next;//指针操作 ,=右往左,指针 指向 
        p->next = s;
    }
    Status ListDelete_L(LinkList &L, int i, ElemType &e) { //在带head的单链表L中第i个位置 删除元素e        
        p = L; j = 0;//p为指针,被插入的previous Node
        while (p && j < i - 1) { p = p->next; ++j; }//寻找第i个结点,下标最后是i-1,指针下移,j最后停在i
        if (p->next || j>i - 1) return FALSE;//删除位置不合理
        
        q = p->next; //q是被删除的节点    
        p->next = q->next;//P的next,指向q->next
        
        e = q->data; //取出 值为e
        free(q);//返回值,释放空间
    }
    LNode * LocateElem_L(LinkList L, ElemType e) { //在L中找到第一个值和e相同的结点,返回其地址,若不存在,返回空值NULL。
        if (!L) return NULL;
        p = L;
        while (p&&p->data != e) { p = p->next };//if(!p) p=null;
        return p;//时间复杂度O(n)
    }
    void CreateList_L(LinkList &L, int n) { //头插法 生成单链表
        //逆位序输入n个元素的值,建立带表头结点的单链线性表L
        L = (LinkList)malloc(sizeof(LNode));
        L->next = NULL;//L->next表示头结点的指针,先建立一个带头结点的单链表
        for (i = n; i > 0; --i) {
            p = (LinkList)malloc(sizeof(LNode));
            scanf(&p->data);//输入元素值
            p->next = L->next;//挪动 头指针的后继
            L->next = p;//挪动 头指针的后继
        }
    }
    void MergeList_L(LinkList &La, LinkList &Lb,) { 
        //已知La和Lb升序排列
        //合并得到新的单链表Lc,Lc的元素也按值非递减排列
        pa = La->next;
        pb = Lb->next;
        q = La;//存放临时指针,q就是pa的前驱元素,q必须始终作为pa的前驱元素
        while (pa && pb) {
            if (pa->data <= pb->data) {//如果小于=,pc指针指向pa
                q = pa;//q下移
                pa = pa->next;//pa下移
            }
            else {//如果>,pc指针指向pb
                t = pb;// t 下移
                pb = pb->next;//pb下移
                t->next = pa;//t插入pa的前面
                q->next = t;
                q = t;//q必须始终作为pa的前驱元素,因此t赋值给q
            }//2个结合起来就是小者排前面,这个代码写的真差,不是人类看的,因为C在A和B只见跳来跳去,临时pc变量拆成2个就容易理解了
        }
        if (pb) q->next = pb;
    }//MergeList_L
    //-------双向链表 Y
    typedef struct LNode { //封装 线性单链表
        ElemType data; //数据域
        struct LNode *next; //指针域
    } *Link, *Position;//类型重定义struct LNode * 为Link,Link * 为 Position
    
    Status MakeNode(Link &p, ElemType e){}
    void FreeNode(Link &p)
    
    typedef struct DuLNode { //封装 双向链表
        ElemType data;
        struct DuLNode *prior;//前驱
        struct DuLNode *next;//后继
    }DuLNode, *DuLinkList;
    
    //------静态链表 X 使用数组实现链表,可以在没有指针的编程语言中实现链表结构
    #define MAX_SIZE 1000
    typedef struct { //封装 静态链表
        ElemType data;//数据
        int cur; //游标(Cursor)
    } Component, StaticLinkList[MAX_SIZE]; //声明为StaticLinkList[MAX_SIZE]
    typedef Component SLinkList[MAX_SIZE];
    Status InitList_SL(StaticLinkList &space) { //初始化静态链表                                        
        int i;
        //将一维数组space中各分量链接成一个备用链表,space[0].cur为头指针。
        //“0”表示空指针
        for (i = 0; i < MAX_SIZE - 1; i++)
            space[i].cur = i + 1;    
        //头游标和尾游标 的数据区不存放数据 
        //头游标保存第一个没有数据位置的游标 尾游标保存第一个有数据位置的游标
        //最后一个有数值的分量的cursor游标为0
        //未使用的数组元素成为备用链表
        //除了头游标和尾游标 每个游标保存存放下一个节点的逻辑位置序号
        space[MAX_SIZE - 1].cur = 0;//给最后的游标赋值 
        return TRUE;
    }
    int LocateElem_SL(SLinkList S, ElemType e) { //查找,返回空闲分量的下标
        //在静态单链线性表L中查找第1个值为e的元素
        //若找到,则返回它在L中的依序,否则返回0
        i = S[0].cur;//i模拟指针 ,i指示表中第一个结点
        while (i && S[i].data != e)//在表中顺链查找
            i = S[i].cur;//指针下移
        return i;
    }
    int Malloc_SLL(StaticLinkList space) { //获取当前空闲量的下标,返回空闲分量的下标,未被使用,用getCur更好理解,
        i = space[0].cur;//i模拟指针 ,i指示表中第一个结点
        if(space[0].cur) //非0,为0就是空链表,末尾
            space[0].cur = space[i].cur;//指针下移,空闲分量指针下移,0下标的游标赋值为i下标对应的游标
        return i;
    }
    void Free_SLL(SLinkList &space, int k) { //释放节点
        //将下标为k的空闲结点回收到备用链表
        space[k].cur = space[0].cur; 
        space[0].cur = k;
    }//Free_SLL
    Status ListInsert(StaticLinkList L, int i, ElemType e) {
        int j, k, l;//l是计数器
        k = MAX_SIZE - 1;//k表示数组的最后一个元素
        if (i<1 || i>ListLength(L) + 1) { //ListLength为计算链表长度的函数 
            return FALSE;
        }
        j = Malloc_SLL(L);//j表示空闲分量的下标,是当前节点下标指针
        if (j)
        {
            L[j].data = e;//写入数据
            k = L[k].cur;//最后一个元素的游标指向第一个元素
            for (l = 1; l <= i - 1; l++) ////找到第i个位置
            {
                k = L[k].cur;//返回的是第i个下标节点的游标
            }
            //执行插入后,指针的变化
            L[j].cur = L[k].cur; //翻译成链表 j->next = p->next  当前下标节点指针下移
            L[k].cur = j;//翻译成链表 p->next = j
            return TRUE;
        }
        return TRUE;
    }
  • 相关阅读:
    KETTLE集群搭建
    初识spark
    利用python操作mrjob实例---wordcount
    hive 优化 (转)
    hive权限管理
    hadoop常用操作命令
    hive的分桶
    Hive HQL基本操作
    hadoop--hive数据仓库
    Hive配置项的含义详解
  • 原文地址:https://www.cnblogs.com/blacop/p/6431632.html
Copyright © 2020-2023  润新知