2.数据结构笔记学习--线性表基本操作

• 线性表的结构定义：
  • 顺序表的结构定义：

    typedef struct
    {
        int data[maxSize];  //存放顺序表元素的数组，一般用 int A[maxSize];
        int length;         //存放顺序表的长度,一般用 int n;
    }SeqList;

     

  • 单链表结点定义：

    typedef struct LNode
    {
        int data;  //存放结点的数据域
        struct LNode *next;         //指向后继结点的指针
    }LNode;

     

  • 双链表结点定义：

    typedef struct DLNode
    {
        int data;  //存放结点的数据域
        struct DLNode *prior;        //指向前驱结点的指针
        struct DLNode *next;         //指向后继结点的指针
    }DLNode;

     

• 顺序表的算法操作：
  • 按元素值的查找算法：

    int LocateElem (SeqList L, int e)
    {
        int i;
        for(i=1; i<=L.Length; i++)
            if(e=L.data[i])
            return i;
        return 0;
    }

     

  • 插入数据元素的算法：

    //在p的位置插入新的元素e
    int insert(SeqList &L, int p, int e)  //为啥用&L
    {
        int i;
        if(p<1 || p>L.length+1 || L.length>maxSize-1)  //范围不正确
            return 0;
        for(i=L.length; i>=p; --i)  // 依次后移
        L.data[i+1] = L.data[i];
        ++(L.length);
        return 1;
    }

     

  • 初始化顺序表：

    //初始化顺序表
    void InitList(SeqList &L)
    {
         L.length = 0;
    }

     

  • 求指定位置元素：

    //e返回L中p的元素
    int GetElem (SeqList L, int p,int &e)  //e用引用类型
    {
        if(p<1||p>L.length)
            return 0;
        e = L.data[p];
        return 1;
    }

     

• 单链表的算法操作：
  • 尾插法：

    //n个元素存储在数组a中，尾插法建立链表C
    void CreatelistR(LNode *&C, int a[], int n)  //要改变的变量用引用型
    {
        LNode *s, *r;  //s指向新申请的结点，r指向C的终端结点
        int i;
        C = (LNode *)malloc(sizeof(LNode)); //申请C的头结点空间
        C->next =NULL;
        r=C;  //此时的终端结点就是头结点
        for(i=1; i<=n; ++i)  //为啥++i，不是i++
        {
            s = (LNode* )malloc(sizeof(LNode));
            s->data = a[i];//用新结点接收a的一个元素
            r->next = s; //r接纳新结点
            r = r->next;//r指向终端结点，以便接纳下一个结点
        }
        r->next = NULL;
    }

  • 头插法：

    //n个元素存储在数组a中，头插法建立链表C
    void CreatelistF(LNode *&C, int a[], int n)  //要改变的变量用引用型
    {
        LNode *s;  
        int i;
        C = (LNode *)malloc(sizeof(LNode)); //申请C的头结点空间
        C->next =NULL;
       
        for(i=1; i<=n; ++i)  //为啥++i，不是i++
        {
            s = (LNode* )malloc(sizeof(LNode));
            s->data = a[i];//用新结点接收a的一个元素
            s->next = C->next; //s所指向的指针域next指向C的开始结点
            C->next = s;//头结点的指针域next指向s结点，s成为新的开始结点
        }
    }

• 双链表的算法操作：
  • 尾插法建立双链表

    //尾插法建立双链表
    void CreateDlistR(DLNode *&L, int a[], int n)
    {
        DLNode *s,*r;
        int i;
        L = (DLNode*)malloc(sizeof(DLNode));
        L->next = NULL;
        r=L;  // r始终指向终端结点，开始头结点也是尾结点
        for(i=1; i<=n; i++)
        {
            s = (DLNode*)malloc(sizeof(DLNode));
            s->data = a[i];
            
            //将s插入到L的尾部，并且r指向s，这一部分是主要记忆代码
            r->next = s;
            s->prior = r;
            r = s;
        }
        r->next = NULL;
            
    }

  • 查找结点算法：

    DLNode* searchNode(DLNode *C, int x)
    {
        DLNode *p = C->next;
        while(p!= NULL)
        {
            if(p->data == x)
                break;
            p = p->next;
        }
        return p;
    }

  • 插入结点的算法

    s->next = p->next;
    s->prior = p;
    p->next = s;
    s->next->prior = s;  //假如p指向最后一个结点，本行可去

  • 删除结点的算法：

    q = p->next;
    p->next = q->next;
    q->next->prior = p;
    free(q);