1、【資料結構】線性結構之單鏈表

阿新 • • 發佈：2018-12-17

單向連結串列

一、定義：

單向連結串列（單鏈表）時連結串列的一種，它由節點組成，每個節點都包含下一個節點的指標。

單鏈表的特點是：節點的連結方向是單向的；相對於陣列來說，單鏈表的的隨機訪問速度較慢，但是單鏈表刪除/新增資料的效率很高。

二、實現：

單鏈表的實現方式有很多種，常見的有

（1）帶頭結點的單鏈表

（2）不帶頭結點的單鏈表

（3）帶頭節點和尾節點的單鏈表

（1）和（2）的主要區別是：

（1）的頭節點是個空節點，其主要作用是指向連結串列的第一個節點，（2）的頭結點不是空節點，是整個連結串列的第一個節點。

（3）是一個迴圈連結串列，即連結串列的尾節點指向頭結點；下面會對各種實現方式進行具體的介紹。

三、實現

（1）帶頭結點的單鏈表的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;
}

1、【資料結構】線性結構之單鏈表

單向連結串列一、定義：單向連結串列（單鏈表）時連結串列的一種，它由節點組成，每個節點都包含下一個節點的指標。單鏈表的特點是：節點的連結方向是單向的；相對於陣列來說，單鏈表的的隨機訪問速度較慢，但是單鏈表刪除/新增資料的效率很高。二、實現：

【資料結構】線性結構：儲存&運算&時間複雜度

版權宣告：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/shamingai/article/details/48914005 邏輯結構：表內元素的關係，共有集合、線性結構（線性表、棧、佇列、陣列）、樹形結構（樹、二叉樹、森林）、圖結構（圖）四種；

【課程設計】【資料結構】編制一個演示單鏈表的建立、列印、查詢、插入、刪除等操作的程式。

實驗題目編制一個演示單鏈表的建立、列印、查詢、插入、刪除等操作的程式。 1．需求分析要求用TC編寫一個演示程式，首先建立一個帶頭結點的整型單鏈表，然後根據使用者選擇，能夠在單鏈表的任意位置插入、刪除結點，以及確定某一元素在單鏈表中的位置。 1.1 建立單鏈

【資料結構】逆序輸出單鏈表資料

思路：遞迴。形式為（輸出該資料之後的連結串列值）+輸出這個資料。值得一提的是，如果帶有頭節點的單鏈表，需要前行前行一位，使連結串列指向開始節點。程式碼如下： void printDeverse_main(LinkList List) { List = List-&g

1、【C++基礎】簡介

void指針通用 if...else 重載全局變量但是區別模板庫 stl C++ 簡介 C++ 是一種靜態類型的、編譯式的、通用的、大小寫敏感的、不規則的編程語言，支持過程化編程、面向對象編程和泛型編程。 C++ 被認為是一種中級語言，它綜合了高級語言和低級語言

1、【C++ SLT】簡介

一、基本概念 STL（Standard Template Library），即標準模板庫，是一個具有工業強度的，高效的C++程式庫。它被容納於C++標準程式庫（C++ Standard Library）中，是ANSI/ISO C++標準中最新的也是極具革命性的一部分。該庫包含了諸

1、【資料庫技術】資料庫技術基礎

一、資料庫技術基礎 1、資料庫和資料庫管理系統資料庫系統：包括資料庫、資料庫管理系統、資料庫的使用者和支撐資料管理系統執行的軟硬體。模式是資料庫中全體資料的邏輯結構和特徵描述。資料庫系統的三級模式：內模式（物理層）、概念模式（邏輯層）、外模式（使用者層）。

1、【網路程式設計】Socket/TCP/UDP/HTTP/HTTPS/網路分層模型

一、簡介 1、相關概念 TCP：傳送控制協議(Transmission Control Protocol) UDP：使用者資料報協議（UDP：User Datagram Protocol） HTTP：全稱是HyperText Transfer Pro

數據結構（三）之單鏈表反向查找

hid 默認 splay del 下標 com 設置 display fbo 一、反向查找單鏈表 1、簡單查找　　先遍歷獲取單鏈表單長度n，然後通過計算得到倒數第k個元素的下標為n-k，然後查找下標為n-k的元素。 2、優化查找先找到下標為k的元素為記錄點p

【C語言】兩個有序單鏈表的合併

Node *MergeList(PLinkList p1,PLinkList p2) { PLinkList newhead = NULL; //新連結串列的頭結點 PLinkList end = newhead ;

【資料結構】線性表的鏈式儲存連結串列的初始化、插入元素、刪除元素操作(三)

雙向連結串列的初始化插入與刪除程式碼收穫雙向連結串列刪除結點需要注意要刪除最後一個結點和不是最後一個結點分類討論。插入和刪除時注意修改上一個結點裡指向下一個結點的指標與下一個結點裡指向上一個結點的指標。 #include <stdio.h>

【資料結構】線性表的鏈式儲存(二)迴圈連結串列

線性錶鏈式儲存的迴圈單鏈表迴圈連結串列從任意一點出發，可以訪問全部節點。一般為了便於操作，將連結串列的頭指標變為尾指標，指向尾節點，連結串列的頭節點則為尾指標的next。程式碼收穫用尾指標進行操作雖然省下迴圈，但是插入刪除等操作都需要移動尾指標導致

【資料結構與演算法】之單鏈表、雙鏈表、迴圈連結串列的基本介紹及其Java程式碼實現---第三篇

一、連結串列的基本介紹連結串列的定義：連結串列是一種遞迴的資料結構，它或者為空(null)，或者是指向一個結點(node)的引用，該結點含有一個泛型的元素和一個指向另一條連結串列的引用。----Algorithms Fourth Edition 常見的連結串

3、【資料結構】樹形結構之二叉查詢樹

一、樹的介紹 1. 樹的定義樹是一種資料結構，它是由n（n>=1）個有限節點組成一個具有層次關係的集合。　　把它叫做“樹”是因為它看起來像一棵倒掛的樹，也就是說它是根朝上，而葉朝下的。它具有以下的特點：　　(1) 每個節點有零個或多個子節點；

6、【資料結構】堆形結構之二叉堆

一、堆和二叉堆的介紹 1、堆的定義堆(heap)，這裡所說的堆是資料結構中的堆，而不是記憶體模型中的堆。堆通常是一個可以被看做一棵樹，它滿足下列性質： [性質一] 堆中任意節點的值總是不大於(不小於)其子節點的值； [性質二] 堆總是一

8、【資料結構】圖之鄰接矩陣、鄰接表無向圖

一、鄰接矩陣無向圖 1、基本定義 #define MAX 10 class MatrixUDG { private: char mVexs[MAX]; //頂點集合 int mVexNum; //頂點

9、【資料結構】圖之鄰接矩陣、鄰接表有向圖

一、鄰接矩陣有向圖 1、基本定義 #define MAX 10 class MatrixDG { private: char mVexs[MAX]; // 頂點集合 int mVexNum; // 頂點數

10、【資料結構】圖之深度優先和廣度優先搜尋

一、深度優先搜尋 1、深度優先搜尋介紹圖的深度優先搜尋(Depth First Search)，和樹的先序遍歷比較類似。它的思想：假設初始狀態是圖中所有頂點均未被訪問，則從某個頂點v出發，首先訪問該頂點，然後依次從它的各個未被訪問的鄰接點出發

【資料結構】線性表的邏輯結構

基本特徵有序（次序）集唯一前驅唯一後繼抽象資料型別（DSP）資料定義操作抽象資料型別線性表定義　　基本操作：　　　　結構初始化操作構造一個空的線性表　　　　結構銷燬操作　　　　結構引用型操作知識引用遍

【資料結構】線性表的鏈式儲存結構--單鏈表

1. 線性表的鏈式儲存結構鏈式儲存：用一組任意的儲存單元儲存線性表中的資料元素。用這種方法儲存的線性表簡稱線性連結串列。儲存連結串列中結點的一組任意的儲存單元可以是連續的，也可以是不連續的，甚至是零散分佈在記憶體中的任意位置上的。連結串列中結點的邏輯順序和物理順序不

1、【資料結構】線性結構之單鏈表

單向連結串列

一、定義：

二、實現：

三、實現

（1）帶頭結點的單鏈表的C++實現

相關推薦