2、【线性结构】数组、单向链表及双向链表

概要

　　线性表是一种线性结构，它是具有相同类型的n(n≥0)个数据元素组成的有限序列。线性表的几个基本组成部分：数组、单向链表、双向链表。

一、数组

　　数组有上界和下界，数组的元素在上下界内是连续的。

　　数组的特点是：数据是连续的；随机访问速度快。
　　数组中稍微复杂一点的是多维数组和动态数组。

二、单向链表

定义：

　　单向链表（单链表）时链表的一种，它由节点组成，每个节点都包含下一个节点的指针。

　　单链表的特点是：节点的链接方向是单向的；相对于数组来说，单链表的的随机访问速度较慢，但是单链表删除/添加数据的效率很高。

实现：

     单链表的实现方式有很多种，常见的有

   　　  （1）带头结点的单链表    

    　　 （2）不带头结点的单链表

     　　（3）带头节点和尾节点的单链表

     （1）和（2）的主要区别是：（1）的头节点是个空节点，其主要作用是指向链表的第一个节点，（2）的头结点不是空节点，是整个链表的第一个节点。（3）是一个循环链表，即链表的尾节点指向头结点；下面会对各种实现方式进行具体的介绍。

C++实现单链表（带头结点）

SList.h

typedef int Type;
//定义节点类
struct Node
{
    Node(const Type x);
    Type data;
    Node *next;
};

class SList
{
public:
    SList();//构造函数
    SList(const SList&s);//拷贝构造函数
    SList &operator=(SList &s);//赋值运算符重载
    ~SList();//析构函数

public:
    //单链表的具体操作
    bool isEmpty();
    int length();
    void reverseList();//逆置
    void printList();//打印链表
    void Clear();
    //void sortList();//排序
    void pushBack(const Type &data);//在尾部插入一个节点
    void popBack();//删除尾节点
    void pushFront(Type data);//头插
    void popFront();//删除头节点

private:
    Node *head;
    int len;//链表长度
};

SList.cpp

#include <iostream>
#include "SList.h"

using namespace std;
//节点类的构造函数
Node::Node(const Type x)
    :data(x),next(NULL)
{

}
//构造函数
SList::SList()
    :head(NULL),len(0)
{
    head = new Node(NULL);
    head->next = NULL;
}
//拷贝构造函数
SList::SList(const SList &s)
{
    head->next = NULL;
    len = s.len;
    Node *current; //自己链表的尾部元素
    Node *sCurrent = s.head->next;//s的第一个元素
    while(sCurrent != NULL)
    {
        for(int i = 1; i <= s.len; i++)
        {
            Node *newNode = new Node(sCurrent->data);

            if(i == 1)
            {
                head->next = newNode;
                current = head->next;
            }
            else
            {
                current->next = newNode;
                current = current->next;
            }
            sCurrent = sCurrent->next;
        }
    }
}
//赋值运算符重载
SList& SList::operator=(SList &s)//推荐写法
{
    if(this != &s)
    {
        swap(head, s.head);
    }
    return *this;
}

//析构函数
SList::~SList()
{
    Clear();
}
//清空链表
void SList::Clear()
{
    Node *current = NULL;
    Node *p = head->next;
    while(p != NULL)
    {
        current = p->next;
        delete p;
        p = current;
    }
    delete current;
    current = NULL;

    delete head;
    p = NULL;
    len = 0;
}

//链表尾部插入
void SList::pushBack(const Type &data)
{
    if(head->next == NULL)
    {
        head->next = new Node(data);
        len++;
    }
    else
    {
        Node *p = head->next;
        while(p->next != NULL)
        {
            p = p->next;
        }
        p->next = new Node(data);
        len++;

        p = NULL;
    }
}
//链表尾部删除
void SList::popBack()
{
    if(head->next == NULL)
        cout << "this SList is empty." << endl;
    else
    {
        Node *current;
        Node *p = head->next;
        for(int i = 1; i < len-1; i++)
        {
            p = p->next;
        }
        current = p->next;
        p->next = current->next;
        delete current;
        current = NULL;
        len--;
    }
}
void SList::printList()
{
    if(head->next == NULL)
        cout << "this SList is empty." << endl;
    else
    {
        Node *temp = head->next;
        while(temp != NULL)
        {
            cout << temp->data << " ";
            temp = temp->next;
        }
        cout << endl;
        delete temp;
        temp = NULL;
    }
}

//判断链表是否为空
bool SList::isEmpty()
{
    if(head->next == NULL)
        return true;
    else
        return false;
}

//获取链表长度
int SList::length()
{
    return len;
}

//链表逆置
void SList::reverseList()
{
    Node *temp = head->next;
    head->next = NULL;
    if(temp == NULL)
        cout << "this SList is empty." << endl;
    else
    {
        while(temp != NULL)
        {
            Node *p = temp->next;
            temp->next = head->next;
            head->next = temp;
            temp = p;
        }
    }
}

void SList::pushFront(Type data)
{
    if(head->next == NULL)
        head->next = new Node(data);
    else
    {
        Node *temp = new Node(data);
        temp->next = head->next;
        head->next = temp;
    }
}

void SList::popFront()
{
    if(head->next == NULL)
        cout << "this SList is empty." << endl;
    else
    {
        Node *temp = head->next;
        head->next = temp->next;
        delete temp;
    }
}

main.cpp

#include <iostream>
#include "SList.h"

using namespace std;

int main()
{
    SList mylist;

    mylist.pushBack(1);
    mylist.pushBack(2);
    mylist.pushBack(3);
    mylist.printList();

    mylist.popBack();
    mylist.printList();

    mylist.reverseList();
    mylist.printList();

    mylist.pushFront(5);
    mylist.printList();

    mylist.popFront();
    mylist.printList();
    return 0;
}

C++实现单链表（不带头结点）

SList.h

typedef int Type;
//定义节点类
struct Node
{
    Node(const Type x);
    Type data;
    Node *next;
};

class SList
{
public:
    SList();//构造函数
    SList(const SList&s);//拷贝构造函数
    SList &operator=(SList &s);//赋值运算符重载
    ~SList();//析构函数

public:
    //单链表的具体操作
    bool isEmpty();
    int length();
    void reverseList();//逆置
    void printList();//打印链表
    void Clear();
    //void sortList();//排序
    void pushBack(const Type &data);//在尾部插入一个节点
    void popBack();//删除尾节点
    void pushFront(Type data);//头插
    void popFront();//删除头节点

private:
    Node *head;
    int len;//链表长度
};

SList.cpp

#include <iostream>
#include <assert.h>
#include "SList.h"

using namespace std;
//节点类的构造函数
Node::Node(const Type x)
    :data(x),next(NULL)
{

}
//构造函数
SList::SList()
    :head(NULL),len(0)
{

}
//拷贝构造函数
SList::SList(const SList &s)
{
    head = NULL;
    len = s.len;
    Node *current; //自己链表的尾部元素
    Node *sCurrent = s.head;//s的第一个元素
    while(sCurrent != NULL)
    {
        for(int i = 1; i < s.len; i++)
        {
            Node *newNode = new Node(NULL);
            newNode->data = sCurrent->data;
            newNode->next = NULL;
            if(i ==1)
            {
                head = newNode;
                current = head;
            }
            else
            {
                current->next = newNode;
                current = current->next;
            }
            sCurrent = sCurrent->next;
        }
    }
}
//赋值运算符重载
SList& SList::operator=(SList &s)//赋值运算符重载()
{
    if(this != &s)
    {
        swap(head, s.head);
    }
    return *this;
}

//析构函数
SList::~SList()
{
    Clear();
}
//清空链表
void SList::Clear()
{
    Node *current;
    while(head != NULL)
    {
        current = head;
        head = current->next;
        delete current;
    }
    head = NULL;
    len = 0;
}
//尾部插入新节点
void SList::pushBack(const Type &data)
{
    if(head == NULL)
    {
        head = new Node(data);
        len++;
    }
    else
    {
        Node *p = head;
        while(p->next != NULL)
        {
            p = p->next;
        }
        p->next = new Node(data);
        len++;

        p = NULL;
    }
}
//打印链表
void SList::printList()
{
    if(head == NULL)
    {
        cout << "this SList is empty ! " << endl;
        return ;
    }
    else
    {
        Node *temp = head;
        while(temp != NULL)
        {
            cout << temp->data << " ";
            temp = temp->next;
        }
        cout << endl;
    }
}
//判断链表是否空
bool SList::isEmpty()
{
    if(head == NULL)
        return true;
    else
        return false;
}
//获取链表长度
int SList::length()
{
    return len;
}
//头插法逆置矩阵
void SList::reverseList()
{
    Node *current = head;
    head = NULL;
    if(current == NULL)
    {
        cout << "this SList is empty." << endl;
    }
    else
    {
        while(current != NULL)
        {
            Node *nextCurrent = current->next;
            //头插法链表逆置
            current->next = head;//head = NULL
            head = current;
            current = nextCurrent;
        }
    }
}
//删除尾节点
void SList::popBack()
{
    if(head == NULL)
        cout << "this SList is empty." << endl;
    else
    {
        Node *p = head;
        //找到倒数第二个节点
        for(int i = 1; i < len-1; i++)
        {
            p = p->next;
        }
        Node *current = p->next;
        p->next = current->next;
        delete current;
        len--;
    }
}

//头部插入
void SList::pushFront(Type Data)
{
    if(head == NULL)
    {
        pushBack(Data);
    }
    else
    {
        Node *temp = head;
        head = new Node(Data);
        head->next = temp;
    }
}

//头部删除
void SList::popFront()
{
    if(head == NULL)
        cout << "this SList is empty." << endl;
    else
    {
        Node *temp = head;
        head = temp->next;
        delete temp;
    }
}

main.cpp

#include <iostream>
#include "SList.h"

using namespace std;

int main()
{
    SList myList;
    myList.pushBack(1);
    myList.pushBack(2);
    myList.pushBack(3);
    myList.printList();

    myList.reverseList();
    myList.printList();

    myList.popBack();
    myList.printList();

    myList.pushFront(4);
    myList.printList();

    myList.popFront();
    myList.printList();
    return 0;
}

C++实现单链表（带头结点和尾结点）

SList.h

typedef int Type;
//定义节点类
struct Node
{
    Node(const Type x);
    Type data;
    Node *next;
};

class SList
{
public:
    SList();//构造函数
    SList(const SList&s);//拷贝构造函数
    SList &operator=(SList &s);//赋值运算符重载
    ~SList();//析构函数

public:
    //单链表的具体操作
    bool isEmpty();
    int length();
    void reverseList();//逆置
    void printList();//打印链表
    void Clear();
    //void sortList();//排序
    void pushBack(const Type &data);//在尾部插入一个节点
    void popBack();//删除尾节点
    void pushFront(Type data);//头插
    void popFront();//删除头节点

private:
    Node *head;
    Node *tail;
    int len;//链表长度
};

SList.cpp

#include <iostream>
#include <assert.h>
#include "SList.h"

using namespace std;
//节点类的构造函数
Node::Node(const Type x)
    :data(x),next(NULL)
{

}
//构造函数
SList::SList()
    :head(NULL),tail(NULL),len(0)
{

}
//拷贝构造函数
SList::SList(const SList &s)
{
    if(s.head == NULL)
        return;
    Node *temp = s.head;
    do{
        pushBack(temp->data);
        temp = temp->next;
    }while(temp != s.head);
    len = s.len;
}
//赋值运算符重载
SList& SList::operator=(SList &s)//赋值运算符重载()
{
    if(this != &s)
    {
        swap(head, s.head);
        swap(tail, s.tail);
    }
    return *this;
}

//析构函数
SList::~SList()
{
    Clear();
}
//清空链表
void SList::Clear()
{
    Node *current = head;
    while(current != tail)
    {
        head = head->next;
        delete current;
        current = head;
    }
    head = NULL;
    tail = NULL;
    len = 0;
}
//尾部插入新节点
void SList::pushBack(const Type &data)
{
    if(head == NULL)
    {
        head = new Node(data);
        tail = head;
        tail->next = head;
    }
    else
    {
        tail->next = new Node(data);
        tail = tail->next;
        tail->next = head;
    }
    len++;
}
//打印链表
void SList::printList()
{
    if(head == NULL)
    {
        cout << "this SList is empty ! " << endl;
        return ;
    }
    else
    {
        Node *temp = head;
       do{
            cout << temp->data << " ";
            temp = temp->next;
       }while(temp != head);
        cout << endl;
    }
}
//判断链表是否空
bool SList::isEmpty()
{
    if(head == NULL)
        return true;
    else
        return false;
}
//获取链表长度
int SList::length()
{
    return len;
}
//头插法逆置矩阵
void SList::reverseList()
{
    if(head == NULL || head->next == tail)
    {
        return ;
    }
    tail = new Node(head->data);
    Node *begin = NULL;
    Node *temp = tail;
    while(len--)
    {
        Node *del = head;
        head = head->next;
        delete del;
        begin = new Node(head->data);
        begin->next = temp;
        tail->next = begin;
        temp = begin;
    }
    head = begin;
}
//删除尾节点
void SList::popBack()
{
    if(head == NULL)
        cout << "this SList is empty." << endl;
    else if(head == tail)
    {
        delete head;
        head = NULL;
        tail = NULL;
    }
    else
    {
        Node *current = head;
        while(current->next != tail)
        {
            current = current->next;
        }
        delete tail;
        tail = current;
        tail->next = head;
    }
}

//头部插入
void SList::pushFront(Type Data)
{
    if(head == NULL)
    {
        pushBack(Data);
    }
    else
    {
        Node *temp = head;
        head = new Node(Data);
        head->next = temp;
        tail->next = head;
    }
}

//头部删除
void SList::popFront()
{
    if(head == NULL)
    {
        cout << "this SList is empty." << endl;
        return ;
    }
    else
    {
        Node *temp = head;
        head = head->next;
        tail->next = head;
        delete temp;
    }
}

main.cpp

#include <iostream>
#include "SList.h"

using namespace std;

int main()
{
    SList myList;
    myList.pushBack(1);
    myList.pushBack(2);
    myList.pushBack(3);
    myList.printList();

    myList.reverseList();
    myList.printList();

    myList.popBack();
    myList.printList();

    myList.pushFront(4);
    myList.printList();

    myList.popFront();
    myList.printList();
    return 0;
}

三、双向链表

　　双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

DList.h

typedef int DataType;

struct DNode
{
    DataType data;
    DNode *prev;
    DNode *next;
    DNode(const DataType x);
};

class DList
{
public:
    DList();//构造函数
    DList(const DList &s);//拷贝构造函数
    DList &operator=(DList &s);//赋值运算符重载
    ~DList();//析构函数

public:
    void reverseList();
    void printList();
    void pushBack(DataType x);
    void popBack();
    void pushFront(DataType x);
    void popFront();
    //void removeNode(DataType x);
    void Clear();
    int getLength();

private:
    DNode *head;//指向头结点
    DNode *tail;//指向尾结点
    int len;
};

DList.cpp

#include <iostream>
#include <assert.h>
#include "DList.h"

using namespace std;
//结点构造函数
DNode::DNode(const DataType x)
    :data(x), prev(NULL), next(NULL)
{

}
//构造函数
DList::DList()
    :len(0), head(NULL), tail(NULL)
{}

//拷贝构造函数
DList::DList(const DList &s)
    :len(0), head(NULL), tail(NULL)
{
    len = s.len;
    if(s.head == NULL)
        return;
    DNode *temp = s.head;
    while(temp)
    {
        pushBack(temp->data);
        temp = temp->next;
    }
}

//赋值运算符重载(推荐写法)，其本质上是与拷贝构造函数的工作是一样的
DList &DList::operator=(DList &s)
{
    if(this != &s)
    {
        swap(head, s.head);
        swap(tail, s.tail);
        len = s.len;
    }
    return *this;
}

DList::~DList()
{
    Clear();
}

void DList::Clear()
{
    DNode *temp = head;
    while(temp != tail)
    {
        head = head->next;
        delete temp;
        temp = head;
    }
    head = NULL;
    tail = NULL;
    len = 0;
}
//尾部插入新结点
void DList::pushBack(DataType x)
{
    if(head == NULL)
    {
        head = new DNode(x);
        tail = head;
        len++;
    }
    else
    {
        tail->next = new DNode(x);
        tail->next->prev = tail;
        tail = tail->next;
        len++;
    }
}

//尾部删除一个结点
void DList::popBack()
{
    if(head == NULL)
    {
        cout << "this DList is empty." << endl;
        return;
    }
    else if(head == tail)
    {
        delete head;
        head = NULL;
        tail = NULL;
        len = 0;
    }
    else
    {
        DNode *temp = head;
        while(temp->next != tail)
        {
            temp = temp->next;
        }
        delete tail;
        tail = temp;
        tail->prev = temp->prev;
        tail->next = NULL;
        len--;
    }
}

//头部插入一个新节点
void DList::pushFront(DataType x)
{
    if(head == NULL)
    {
        pushBack(x);
        len++;
    }
    else
    {
        DNode *temp = head;
        head = new DNode(x);
        head->next = temp;
        temp->prev = head;
        len++;
    }
}

//头部删除一个结点
void DList::popFront()
{
    if(head == NULL)
    {
        cout << "this DList is empty." << endl;
        return;
    }
    else if(head == tail)
    {
        delete head;
        head = NULL;
        tail = NULL;
        len = 0;
    }
    else
    {
        DNode *temp = head->next;
        delete head;
        head = temp;
        head->next = temp->next;
        temp->next->prev = head;
        len--;
    }
}

int DList::getLength()
{
    return len;
}

void DList::reverseList()
{
    if(head == NULL || head == tail)
    {
        return;
    }
    //头插法逆置双链表
    tail = new DNode(head->data);
    DNode *begin = NULL;
    DNode *temp = tail;
    while(--len)
    {
        DNode *del = head;
        head = head->next;
        delete del;
        begin = new DNode(head->data);
        begin->next = temp;
        temp->prev = begin;
        temp = begin;
    }
    head = begin;
}

void DList::printList()
{
    if(head == NULL)
    {
        cout << "this DList is empty." << endl;
        return ;
    }
    else
    {
        DNode *temp = head;
        while(temp != NULL)
        {
            cout << temp->data << " ";
            temp = temp->next;
        }
        cout << endl;
    }
}

main.cpp

#include <iostream>
#include "DList.h"

using namespace std;

int main()
{
    DList myDList;
    myDList.pushBack(1);
    myDList.pushBack(2);
    myDList.pushBack(3);
    myDList.pushBack(4);
    myDList.printList();

    cout << "链表长度len = " << myDList.getLength() << endl;

    myDList.reverseList();
    myDList.printList();

    myDList.pushFront(1);
    myDList.printList();

    return 0;
}