数据结构与算法 Chapter 2 线性表

最新推荐文章于 2022-02-11 21:42:22 发布
最新推荐文章于 2022-02-11 21:42:22 发布
阅读量240 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/fsbblogs/p/10466959.html
版权

2.1 线性表定义

线性表是由长度为n的一组节点组成的有限序列，其中除了首末结点之外，每个结点都有直接的前驱结点和后继结点。

2.2 线性表的顺序存储结构

顺序存储结构使用一组连续的存储单元来存储线性表。 其特点有：线性表的逻辑顺序与物理顺序一致、数据元素之间的关系采用物理位置的相邻来表示。其可以随机存取，常用一维数组表示：

#include <iostream>
using namespace std;

template<class Elem>
class Alist
{
private:
    int maxSize;
    int listSize;
    int curr;
    Elem * listArray;
public:
    Alist(int size = 100)
    {
        maxSize = size;
        listSize = 0;
        curr = 0;
        listArray = new Elem[maxSize];
    }
    ~Alist(){ delete [] listArray;}
    void clear() {listSize = curr = 0;}
    void Prev() {if (curr>0) curr--;}
    void Next() {if (curr < listSize-1) curr++;}
    bool setPos(int pos)
    {
        if (pos < 0 || pos >= listSize)
            return false;
        curr = pos;
    }
    bool insert(const Elem it)
    {
        if (listSize == maxSize) return false;
        for (int i = listSize; i > curr; i--)
            listArray[i] = listArray[i-1];
        listArray[curr] = it;
        listSize++; // update length of the list
        return true;
    }
    bool append(const Elem it)
    {
        if (listSize == maxSize) return false;
        listArray[listSize++] = it;
        return true;
    }
    bool remove(Elem & it)
    {
        if (!listSize) return false;
        if (curr < 0 || curr >= listSize) return false;
        it = listArray[curr];
        for (int i = curr; i < listSize-1; i++)
            listArray[i] = listArray[i+1];
        listSize--;
        curr--; // in case you removed the last one
        return true;
    }
    void print()
    {
        for (int i = 0; i < listSize; i++)
            cout << listArray[i] << " ";
        cout << endl;
    }
};

int main()
{
    int temp;
    Alist<int> mylist;
    mylist.append(2);
    mylist.append(10);
    mylist.append(8);
    mylist.append(5);
    mylist.append(7);
    mylist.print();
    mylist.setPos(3);
    mylist.insert(100);
    mylist.Next();
    mylist.print();
    mylist.remove(temp);
    mylist.remove(temp);
    mylist.remove(temp);
    mylist.print();
}
  1. 在线性表中随机访问任意位置上的元素，时间复杂度为O(1)，因此顺序表示可以随机存取的。
  2. 在顺序存储的线性表中插入或删除一个节点，时间复杂度为O(n)，而且需要移动大量元素。
  3. 顺序表空间扩展的代价高，往往需要重新分配。

2.3 线性表的链式存储结构

单链表

单链表的每个数据元素用一个结点来存储，每个结点包含一个数据域和一个指针域。头结点是链表最开头的结点，没有存储任何数据元素，通过指针head找到，其他结点的地址通过前驱的next指针找到。最后一个结点没有后继，因此其指针域内容为NULL。下面是单链表的定义、操作实现与一个例子：

#include <iostream>
using namespace std;

template<class Elem>
class Link
{
public:
    Elem element;
    Link * next;
    Link(const Elem & item, Link * nextval = NULL) {element = item; next = nextval;}
    Link(Link * nextval = NULL) {next = nextval;}
};

template<class Elem>
class LList
{
private:
    Link<Elem> * head;
    Link<Elem> * tail;
    Link<Elem> * curr;
    void init() {curr = tail = head = new Link<Elem>;}
    void removeall()
    {
        while (head != NULL)
        {
            curr = head;
            head = head->next;
            delete curr;
        }
    }
public:
    LList() {init();}
    ~LList() {removeall();}
    bool getValue(Elem & e)
    {
        if (curr == NULL) return false;
        e = curr->element;
        return true;
    }
    Link<Elem> * Locate(Elem e)
    {
        Link<Elem> * p = head;
        while (p != NULL)
        {
            p = p->next;
            if (p->element == e)
                return p;
        }
        return NULL;
    }
    bool isEmpty() {return head->next == NULL;}
    void Prev()
    {
        if (curr == head) return;
        Link<Elem> * p = head;
        while (p->next != curr)
            p = p->next;
        curr = p;
    }
    void Next()
    {
        if (curr->next == NULL)
            return;
        curr = curr->next;
    }
    bool setPos(int pos)
    {
        Link<Elem> * p = head;
        for (int i = 0; i < pos; i++)
        {
            if (p->next == NULL)
                return false;
            p = p->next;
        }
        curr = p;
        return true;
    }
    bool Insert(Elem x)
    {
        Link<Elem> * s = new Link<Elem>;
        s->element = x;
        s->next = curr->next;
        curr->next = s;
        return true;
    }
    bool remove(Elem &e)
    {
        if (curr->next == NULL) return false;
        Link<Elem> * q = curr->next;
        e = q->element;
        curr->next = q->next;
        delete q;
        return true;
    }
    void clear() {removeall(); init();}
    void Print()
    {
        Link<Elem> * p = head;
        while (p->next != NULL)
        {
            p = p->next;
            cout << p->element << " ";
        }
        cout << endl;
    }
};

int main()
{
    int a;
    LList<int> mylist;
    mylist.Insert(2);
    mylist.Insert(3);
    mylist.Insert(8);
    mylist.Print();
    mylist.Next();
    mylist.Next();
    mylist.Insert(10);
    mylist.Prev();
    mylist.remove(a);
    mylist.Print();
    return 0;
}

在单链表上，删除和插入一个结点的时间复杂度为O(1)，但随机访问任意位置上的结点时间复杂度为O(n)。

顺序表与单链表比较

  1. 空间上：顺序表所有空间都用于存储数据，而单链表一部分空间用于存储指针域。
  2. 访问上：顺序表可以O(1)时间访问任意元素，而单链表随机访问的时间复杂度为O(n)。
  3. 插入删除上：顺序表的平均时间复杂度为O(n)，而单链表的时间复杂度为O(1)。
    由于插入删除是更经常的操作，因此单链表在很多方面都优于顺序表。

双向链表

一个双向链表中的结点包含两个指针域和一个数据域，其中两个指针域分别为前驱与后继，改进了单链表找前驱结点时间复杂度为O(n)的缺点。一个带头结点的双向链表的定义、操作实现与一个例子如下：

#include <iostream>
using namespace std;

template<class Elem>
class DLink
{
public:
    Elem element;
    DLink * prev;
    DLink * next;
    DLink(const Elem & it, DLink * p = NULL, DLink * n = NULL)
    {
        element = it;
        prev = p;
        next = n;
    }
    DLink(DLink *p = NULL, DLink *n = NULL) {prev = p; next = n;}
};

template<class Elem>
class DList
{
private:
    DLink<Elem> * head, * tail, * curr;
public:
    DList()
    {
        head = tail = curr = new DLink<Elem>;
    }
    ~DList()
    {
        while (head != NULL)
        {
            curr = head;
            head = head->next;
            delete curr;
        }
    }

    void Prev() {curr = curr->prev;}
    void Next() {curr = curr->next;}
    bool setPos(int pos)
    {
        DLink<Elem> * p = head;
        for (int i = 0; i < p; i++)
        {
            if (p->next == NULL) return false;
            p = p->next;
        }
        curr = p;
    }
    bool getValue(Elem & x)
    {
        if (head->next == NULL) return false;
        x = curr->element;
        return true;
    }
    bool Insert(const Elem x) // insert an element after curr
    {
        if (curr->next != NULL)
        {

            DLink<Elem> * newptr, * nextptr;
            nextptr = curr->next;
            newptr = new DLink<Elem>(x, curr, nextptr);
            curr->next = newptr;
            nextptr->prev = newptr;
            return true;
        }
        else // when curr->next == NULL
        {
            DLink<Elem> * newptr = new DLink<Elem>(x, curr, NULL);
            curr->next = newptr;
            return true;
        }
    }
    bool remove(Elem & x) // remove the element of curr
    {
        if (head->next == NULL || curr == NULL) return false;
        DLink<Elem> * temp = curr;
        x = temp->element;
        curr->prev->next = curr->next;
        curr->next->prev = curr->prev;
        curr = curr->next; // reset curr to a valid node
        delete temp;
        return true;
    }
    void Print()
    {
        DLink<Elem> * p = head;
        while (p->next != NULL)
        {
            p = p->next;
            cout << p->element << " ";
        }
        cout << endl;
    }
};

int main()
{
    int a;
    DList<int> mylist;
    mylist.Insert(2);
    mylist.Insert(3);
    mylist.Insert(8);
    mylist.Print();
    mylist.Next();
    mylist.Next();
    mylist.Next();
    //mylist.getValue(a);
    //cout << a << endl;
    mylist.Insert(10);
    mylist.Prev();
    mylist.remove(a);
    mylist.Print();
    return 0;
}

循环链表

循环单链表的特点在于，单链表的尾结点rear->next为空，但循环单链表的尾结点rear->next==head，这使得插入删除时不用考虑头尾节点的特殊性。循环双链表类似地有rear->next==head且head->prev==rear。下面是一个循环单链表的定义与操作实现，并用其解决Josephus问题：

#include <iostream>
using namespace std;

template<class Elem>
class CLinkNode
{
public:
    Elem element;
    CLinkNode<Elem> * next;
    CLinkNode(CLinkNode<Elem> * nexts = NULL) : next(nexts) {};
    CLinkNode(Elem d, CLinkNode<Elem> * nexts = NULL) : element(d), next(nexts) {}
};

template<class Elem>
class CList
{
private:
    CLinkNode<Elem> * head, * curr;
public:
    CList() {head = NULL; curr = NULL;}
    ~CList()
    {
        while (head != NULL)
        {
            curr = head;
            head = head->next;
            delete curr;
        }
    }
    bool Insert(const Elem x)
    {
        if (head == NULL)
        {
            head = new CLinkNode<Elem>(x, head);
            head->next = head;
            curr = head;
            curr = curr->next;
            return true;
        }
        else
        {
            CLinkNode<Elem> * newptr = new CLinkNode<Elem>(x, curr->next);
            newptr->next = curr->next;
            curr->next = newptr;
            curr = curr->next;
            return true;
        }
    }
    void Prev()
    {
        CLinkNode<Elem> * p = curr;
        while (p->next != curr)
            p = p->next;
        curr = p;
    }
    bool remove(Elem & x)
    {
        if (curr == NULL) return false;
        x = curr->element;
        CLinkNode<Elem> * temp = curr;
        Prev();
        curr->next = temp->next;
        delete temp;
        return true;
    }
    CLinkNode<Elem> * getHead() {return head;}
    void Print()
    {
        CLinkNode<Elem> * p = head;
        while (p != head)
        {
            p = p->next;
            cout << p->element << " ";

        }
        cout << endl;
    }
};

int main()
{
    int n, m;
    cin >> n >> m;
    CList<int> clist;
    for (int i = 1; i <= n; i++)
        clist.Insert(i);
    clist.Print();
    CLinkNode<int> * p = clist.getHead(), * pre = NULL;
    for (int i = 0; i < n; i++)
    {
        for (int j = 1; j < m; j++)
        {
            pre = p;
            p = p->next;
        }
        cout << "OUT: " << p->element << endl;
        m = p->element;
        pre->next = p->next;
        delete p;
        p = pre->next;
    }
    return 0;
}

2.4 线性表应用

一元多项式表示

可以利用单链表表示一元多项式，其中每个结点有两个数据与与一个指针域，两个数据域分别存储多项式当中一项的系数与次数，不同项之间的次数按从头到尾从低到高排列。在此基础上，可以定义多项式链表的加法与减法运算:

Poly sum(Poly a, Poly b)
{
    Poly c;
    Node * p = a.getHead()->next;
    Node * q = b.getHead()->next;
    Node * r = c.getHead();
    while (p && q)
    {
        if (p->exp == q->exp)
        {
            Node * s = new Node(p->coef + q->coef, p->exp, NULL);
            r->next = s;
            r = s;
            p = p->next;
            q = q->next;
        }
        else if(p->exp > q->exp)
        {
            Node * s = new Node(q->coef, q->exp, NULL);
            r->next = s;
            r = s;
            q = q->next;
        }
        else if(p->exp < q->exp)
        {
            Node * s = new Node(p->coef, p->exp, NULL);
            r->next = s;
            r = s;
            p = p->next;
        }
    }
    if (p) r->next = p;
    else r->next = q;
    return c;
}

商品链更新

与一元多项式的表示相似，也可以由单链表存储并定义加减法以追踪货物情况。

2.5 本章练习

Ex13. 设线性表L=(a1,a2,...,an)以带头结点的单链表作存储结构。请编写函数使得当n为奇数时让L成为L=(a2,a4,...,an-1,a1,...,an)。

#include <iostream>
using namespace std;

template<class Elem>
class Link
{
public:
    Elem element;
    Link * next;
    Link(const Elem & item, Link * nextval = NULL) {element = item; next = nextval;}
    Link(Link * nextval = NULL) {next = nextval;}
};

template<class Elem>
class LList
{
private:
    Link<Elem> * head;
    Link<Elem> * tail;
    Link<Elem> * curr;
    void init() {curr = tail = head = new Link<Elem>;}
    void removeall()
    {
        while (head != NULL)
        {
            curr = head;
            head = head->next;
            delete curr;
        }
    }
public:
    LList() {init();}
    ~LList() {removeall();}
    bool getValue(Elem & e)
    {
        if (curr == NULL) return false;
        e = curr->element;
        return true;
    }
    Link<Elem> * Locate(Elem e)
    {
        Link<Elem> * p = head;
        while (p != NULL)
        {
            p = p->next;
            if (p->element == e)
                return p;
        }
        return NULL;
    }
    bool isEmpty() {return head->next == NULL;}
    void Prev()
    {
        if (curr == head) return;
        Link<Elem> * p = head;
        while (p->next != curr)
            p = p->next;
        curr = p;
    }
    void Next()
    {
        if (curr->next == NULL)
            return;
        curr = curr->next;
    }
    bool setPos(int pos)
    {
        Link<Elem> * p = head;
        for (int i = 0; i < pos; i++)
        {
            if (p->next == NULL)
                return false;
            p = p->next;
        }
        curr = p;
        return true;
    }
    bool Insert(Elem x)
    {
        Link<Elem> * s = new Link<Elem>;
        s->element = x;
        s->next = curr->next;
        curr->next = s;
        curr = curr->next;
        return true;
    }
    bool remove(Elem &e)
    {
        if (curr->next == NULL) return false;
        Link<Elem> * q = curr->next;
        e = q->element;
        curr->next = q->next;
        delete q;
        return true;
    }
    void clear() {removeall(); init();}
    void Print()
    {
        Link<Elem> * p = head;
        while (p->next != NULL)
        {
            p = p->next;
            cout << p->element << " ";
        }
        cout << endl;
    }
    Link<Elem> * getHead() {return head;}
};

template<class Elem>
void Shuffle(LList<Elem> & l)
{
    Link<Elem> * l2, *p, *q;
    p = l.getHead();
    l2 = new Link<Elem>; // head node
    q = l2;
    int count = 1;
    while (p->next)
    {
        if (count % 2 == 1)
        {
            q->next = p->next;
            q = q->next;
            p->next = p->next->next;
            count++;
        }
        else
        {
            p = p->next;
            count++;
        }
    }
    p->next = l2->next;
}

int main()
{
    LList<int> l;
    for (int i = 1; i < 10; i++)
        l.Insert(i);
    l.Print();
    Shuffle(l);
    l.Print();
    return 0;
}

Ex20. 写一算法将单链表中所有重复的结点删除，使所得结果表中各结点值均不相同。

#include <iostream>
using namespace std;

template<class Elem>
class Link
{
public:
    Elem element;
    Link * next;
    Link(const Elem & item, Link * nextval = NULL) {element = item; next = nextval;}
    Link(Link * nextval = NULL) {next = nextval;}
};

template<class Elem>
class LList
{
private:
    Link<Elem> * head;
    Link<Elem> * tail;
    Link<Elem> * curr;
    void init() {curr = tail = head = new Link<Elem>;}
    void removeall()
    {
        while (head != NULL)
        {
            curr = head;
            head = head->next;
            delete curr;
        }
    }
public:
    LList() {init();}
    ~LList() {removeall();}
    bool getValue(Elem & e)
    {
        if (curr == NULL) return false;
        e = curr->element;
        return true;
    }
    Link<Elem> * Locate(Elem e)
    {
        Link<Elem> * p = head;
        while (p != NULL)
        {
            p = p->next;
            if (p->element == e)
                return p;
        }
        return NULL;
    }
    bool isEmpty() {return head->next == NULL;}
    void Prev()
    {
        if (curr == head) return;
        Link<Elem> * p = head;
        while (p->next != curr)
            p = p->next;
        curr = p;
    }
    void Next()
    {
        if (curr->next == NULL)
            return;
        curr = curr->next;
    }
    bool setPos(int pos)
    {
        Link<Elem> * p = head;
        for (int i = 0; i < pos; i++)
        {
            if (p->next == NULL)
                return false;
            p = p->next;
        }
        curr = p;
        return true;
    }
    bool Insert(Elem x)
    {
        Link<Elem> * s = new Link<Elem>;
        s->element = x;
        s->next = curr->next;
        curr->next = s;
        return true;
    }
    bool remove(Elem &e)
    {
        if (curr->next == NULL) return false;
        Link<Elem> * q = curr->next;
        e = q->element;
        curr->next = q->next;
        delete q;
        return true;
    }
    void clear() {removeall(); init();}
    void Print()
    {
        Link<Elem> * p = head;
        while (p->next != NULL)
        {
            p = p->next;
            cout << p->element << " ";
        }
        cout << endl;
    }
    Link<Elem> * getHead() {return head;}
};

template<class Elem>
void noRedun(LList<Elem> & l)
{
    Link<Elem> * p, * q, * pre;
    p = l.getHead();
    p = p->next;
    q = p->next;
    pre = p;
    while (p->next)
    {
        q = p->next;
        pre = p;
        while (q)
        {
            if (p->element == q->element)
            {
                Link<Elem> * temp = q;
                pre->next = q->next;
                delete q;
                q = pre->next;
            }
            else
            {
                pre = q;
                q = q->next;
            }
        }
        p = p->next;
    }
}

int main()
{
    LList<int> l;
    for (int i = 1; i < 10; i++)
        l.Insert(rand() % 10);
    l.Print();
    noRedun(l);
    l.Print();
    return 0;
}

转载于:https://www.cnblogs.com/fsbblogs/p/10466959.html

dianzili1007
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构学习笔记（第二章线性表）
阿七的博客
07-01 490
线性表是具有相同数据类型的n（n>=0）个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为L=（a1,a2,.....an）a1是表头元素，an是表尾元素。除a1外都有前驱，除an外都有后继线性表是一种逻辑结构，表示元素之间一对一的相邻关系。线性表包括顺序表和链表，顺序表里面元素的地址是连续的。链表里面节点的地址不一定连续的，是通过指针连起来的。顺序表和链表是指存储结构。InitList(&L):初始化线性表Length(L):求表长LocateElem(L,e
[数据结构] 线性表之一（白）遮百丑（顺序表、动态顺序表实现）
Nick 的笔记
04-09 409
​ 🍹欢迎各路大佬来到 Nick 主页指点 ☀️本期文章将学习 [数据结构] 线性表（顺序表），我是博主Nick。✨ ✨我的博客主页：Nick_Bears 🌹꧔ꦿ 🌹꧔ꦿ博文内容如对您有所帮助，还请给个点赞 + 关注 + 收藏✨ ​
数据结构与算法——线性表
李好好先生的博客
08-11 254
数据结构与算法之线性表相关代码。今后会不定期更新。
关于线性表
魏莘墨的专栏
10-01 450
线性表类模板：template class List {y void clear(); //线性表置空 bool isEmpty(); //线性表为空时，返回true bool append(const T value); //在表尾添加一个元素value，表的长度增1 bool insert(const int p, const T value); //在位置p上插入一
线性表1.数组表示方法
qq_51741751的博客
02-11 782
线性表是一种线性结构。所谓线性结构是指数据元素与自然数之间存在着一对一的关系，这里的一对一并一定只得是一个数据，而是从抽象角度来说的集合，两个集合之间的元素两两相互对应。 废话不多说，上代码 #include<iostream> using namespace std; const int LIST_SIZE = 5000; class ELEM {//存储的表元素（自定义数据） private: int key; public: ELEM() { this->key = 0;
数据结构与算法Chapter3受限线性表 定义线性表节点的结构.pdf
04-18
数据结构与算法中的“受限线性表”是指在特定条件下操作的线性表，例如只能在表尾进行插入和删除的栈。栈是一种特殊的线性表，它遵循“后进先出”（LIFO）原则，即最后进入的元素最先出来。栈的主要操作包括创建、...
Chapter2 线性表1
最新发布
08-04
线性表是数据结构中的基础概念，用于组织和操作一...总的来说，线性表是数据结构的基础，它的设计和实现直接影响到算法的效率和应用程序的性能。在计算机科学和人工智能领域，理解和掌握线性表的原理及其应用至关重要。
数据结构——线性表类模板
12-19
在`Chapter3`文件中，可能会进一步探讨线性表的其他高级特性，如链式存储、排序操作、合并与分割等，这些都是数据结构和算法课程中的重要内容。学习这些知识有助于提升解决实际问题的能力，特别是在设计和优化算法时...
数据结构与算法PPT
11-22
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。这份"数据结构与算法PPT"提供了国外经典教材的详细讲解，旨在帮助学习者深入理解这一领域。以下是基于PPT文件名所涵盖的主要知识点： 1. **...
数据结构线性表相关内容的代码实现
04-01
在IT领域，数据结构是计算机科学中的核心概念，它研究如何高效地组织和存储数据，以便于算法的执行。线性表是数据结构中最基础的一种，它由有限个相同类型元素构成的有序序列。本篇将围绕“数据结构线性表相关内容的...
数据结构实验二
Ambition_Tn的博客
11-01 1996
实验目录 1、编写函数slnklist delx(linklist head, datatype x)，删除不带头结点单链表head中第一个值为x 的结点。 并构造测试用例进行测试。 2、假设线性表（a1,a2,a3,…an）采用不带头结点的单链表存储， 请设计算法函数linklist reverse1(linklist  head)和 void reverse2(linklist *h
数据结构线性表课后习题（数据结构考试重点）
kaakllhjkhjalv的博客
07-08 1万+
1. 简述线性表两种存储结构各自的主要特点。 答：线性表的两种存储结构分别是顺序存储结构和链式存储结构。顺序存储结构的主 要特点如下： ① 数据元素中只有自身的数据域，没有关联指针域。因此，顺序存储结构的存储密度 较大。 ② 顺序存储结构需要分配一整块比较大存储空间，所以存储空间利用率较低。 ③ 逻辑上相邻的两个元素在物理上也是相邻的，通过元素的逻辑序号可以直接其元素 值，即具有随机存取特性。 ④ 插入和删除操作会引起大量元素的移动。 链式存储结构的主要特点如下： ① 数据结点中除自身的数据域，还有表示逻辑
不带头结点的单链表——数据结构课堂作业
weixin_33894640的博客
11-04 2055
#include <stdio.h>#include <stdlib.h>/**************************************//* 链表实现的头文件，文件名slnklist.h *//**************************************/ #include <stdio.h> #include &l...
数据结构实验1-线性表的顺序实现
12-05 1837
/************************/ /文件名称：lab1-01.c / /************************/ /基于sequlist.h中定义的顺序表，编写算法函数reverse(sequence_list *L)，实现顺序表的就地倒置。/include “sequlist.h”/请将本函数补充完整，并进行测试/ void rever
数据结构-线性表
szplzx1314的博客
10-12 97
线性表是最简单基础也是最常用的线性结构.元素之间存在一对一的线性关系,在线性表中元素类型是相同的. 线性表运算 //初始化线性表 void initiate(); //返回线性表中元素个数 int length(); //返回线性表索引为num的值(0 <= index < length) dataType getValue(int index); //dataType是元素类型 //查找数据元素,找到返回数据元素的索引值,没有找到返回-1 int getIndex(da
电商项目（二）--------商品数据结构以及数据库表结构的分析和整理
热门推荐
一个人在上海的博客
08-01 2万+
       随着项目的深入，你会发现如果对于数据结构没有一个准确的把握和理解，那么如同瞎子过河，全靠蒙。所以在这里我将自己的一些看法和认识用文字的方式记录下来，一方面给读者看，一方面让我发现自己的不足。   作为一个传统的电商项目，最难的地方也就在于数据库中表的关联，以及多表之间的查询关联，缕清楚表与表之间的关系，才能进行随心所欲的CRUD。我的上一篇文章简单的分析了部分表，那么现在我把所有...
数据结构线性表之吐血攻略
闲狗的博客
10-17 623
这是一篇闲狗写给闲狗看的线性表攻略。 1 线性表 1.1 线性表的概述 线性表简称表，是零个或多个元素的有穷序列 1.2 线性表类模板 C++版 template &lt;class T&gt; class List { void clear(); // 置空线性表 bool isEmpty(); // 线性表为空时，返回 true //在表尾添加一个元素...
数据结构篇————线性表
kkkkk0826的专栏
01-22 868
数据结构篇————线性表 线性表的抽象数据类型的定义： ADT 线性表(List) Data 线性表的数据对象集合为{a1,a2,....,an},每个元素的类型均为DataType。其中，除了第一个元素a1外，每一个元素有且只有一个直接前驱元素，除最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。 Operation InitList...
EE屌丝的数据结构笔记（二）
Fontaine的编程生涯
12-05 322
本来链表的文件早写好了，无奈老师一道链表倒置的题着实伤了下脑筋，使用标准思路却忘了我设置了头节点，一个小细节导致程序老是处于崩溃状态，一番调试后终于调试成功，故在此分享下想关心得。 Link类头文件 #ifndef LINK_H_ #define LINK_H_ #include template class Link { public: Elem element; Link* n
考研数据结构算法经典.doc
05-06
本文件提供的内容是针对考研复习的数据结构算法经典例题，主要涵盖线性表相关的操作，包括逆转顺序表、删除特定元素的线性链表节点、逆转线性链表、链表的复制以及两个有序链表的合并。 1. **逆转顺序表中的所有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值