2. 程式人生 > >數據結構-單向鏈表 C和C++的實現

數據結構-單向鏈表 C和C++的實現

阿新 • • 發佈：2017-07-14
下標 using print find 十分 for null type 一位

數據結構，一堆數據的存放方式。

今天我們學習數據結構中的 鏈表：

數組，大家相當熟悉的存放數據方式，而鏈表是數組的一種特殊方式，它每個節點包括兩個部分：

  • 數據域：存放數據，此部分與數組相同
  • 指針域：存放了下一個節點的地址

鏈表比數組多了指針域，因為鏈表需要通過上一個節點的指針域去找下一個數據，比如有一個鏈表ABCD四個節點，我們要訪問D裏邊的數據。操作如下：

  1. 先通過A節點的指針域找到B節點
  2. 再通過B節點的指針域找到C節點
  3. 再通過C節點的指針域找到D節點
  4. 獲取D節點數據域的數據

對比數組直接通過下標訪問，鏈表的訪問方式相當麻煩，既然這麽麻煩，為什麽還有鏈表這種數據結構呢？因為鏈表插入刪除節點方式十分便捷，在數據量大的時候，刪除數組的數據需要把刪除數據後面的數據都前移一位，而鏈表只需要改變前一個元素的指針域，插入和刪除操作速度快

。

這麽厲害的東西，還是看程序比較直接

單向鏈表

C

（此處插入代碼）

C++

在C++中，使用模板的方法實現

本程序包括3個文件組成，他們分別是：

技術分享

定義節點類：Node.h

這個類定義了每個節點的兩個區域：m_tpData數據域 和 m_tpNext指針域：

#include <iostream>

using namespace std;

template <typename T>
class Node
{
public:
    Node();
    Node(T data);
    ~Node();
    void setData(T data);
    T getData();
    
 
void setNext(Node<T> *next);
    Node* getNext();
    void printData();
private:
    T *m_tpData;
    Node<T> *m_tpNext;
};


template <typename T>
Node<T>::Node()
{
    m_tpData = new T;
    m_tpNext=NULL;
}

template <typename T>
Node<T>::Node(T data)
{
    m_tpData 
 
= new T(data);
    m_tpNext=NULL;
}

template <typename T>
Node<T>::~Node()
{
    delete m_tpData;
    m_tpData=NULL;
}

template <typename T>
void Node<T>::setData(T data)
{
    *m_tpData = data;
}

template <typename T>
T Node<T>::getData()
{
    return *m_tpData;
}

template <typename T>
void Node<T>::setNext(Node<T> *next)
{
    m_tpNext = next;
}

template <typename T>
Node<T>* Node<T>::getNext()
{
    return m_tpNext;
}

template <typename T>
void Node<T>::printData()
{
    cout<<*m_tpData<<endl;
}

鏈表類 LinkList.h

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

using namespace std;

template <typename T>
class LinkList
{
public:
    LinkList();
    ~LinkList();
    bool isListEmpty();
    bool clearList();
    int getListLength();
    int getElemIndex(T &elem);
    bool getListElem(int index,T* elem);
    //bool getListPrevious(int index,T* elem); 
    //bool getListNext(int index,T* elem);
    bool ListInsert(int index,T &elem);
    bool ListDelete(int index,T *elem);
    void ListPrint(void);
private:
    Node<T> *m_pList;
    int m_iLength;
};

template <typename T>
LinkList<T>::LinkList()
{
    m_pList = new Node<T>;
    m_pList->setData(NULL);
    m_pList->setNext(NULL);
    m_iLength=0;
}

template <typename T>
LinkList<T>::~LinkList()
{
    Node<T> *nextNode = m_pList;
    while(nextNode->getNext()!=NULL)    //delete Node while pointerNext == NULL
    {        
        nextNode=m_pList->getNext();
        delete m_pList;
        m_pList = nextNode;
    }
    delete m_pList;//delete last Node
    m_pList = NULL;
}

template <typename T>
bool LinkList<T>::isListEmpty()
{
    if(m_iLength==0)
        return true;
    return false;
}


template <typename T>
bool LinkList<T>::clearList()
{
    if(isListEmpty())
    {
        cout<<"List empty clear fail"<<endl;
        return false;
    }

    //delete All node except first node
    Node<T> *nowNode = m_pList->getNext();
    Node<T> *nextNode = m_pList->getNext();
    while(nextNode->getNext()!=NULL)    
    {        
        nextNode=nowNode->getNext();
        delete nowNode;
        nowNode = nextNode;
    }
    delete nowNode;//delete last Node

    m_iLength = 0;
    m_pList->setNext(NULL);
    return true;
}

template <typename T>
int LinkList<T>::getListLength()
{
    return m_iLength;
}
template <typename T>
int LinkList<T>::getElemIndex(T &elem)
{
    Node<T> *tempNode = m_pList;
    for(int i=0;i<m_iLength;i++)
    {
        tempNode = tempNode->getNext();
        if(elem == tempNode->getData())
        {
            return i;
        }
    }
    return -1;
}
template <typename T>
bool LinkList<T>::getListElem(int index,T* elem)
{
    if(index<0 || index>= m_iLength)
    {
        return false;
    }

    Node<T> *tempNode = m_pList;
    for(int i=0;i<=index;i++)
    {
        tempNode=tempNode->getNext();
    }

    *elem = tempNode->getData();
    return true;
}



template <typename T>
bool LinkList<T>::ListInsert(int index,T &elem)
{
    //index out of range
    if(index<0 || index>m_iLength)
    {
        return false;
    }

    //
    Node<T> *tempPreNode = m_pList; 
    for(int i=0;i<index;i++)
    {
        tempPreNode = tempPreNode->getNext();
    }

    Node<T> *newnode = new Node<T>;    //create a new node
    if(newnode == NULL)
    {
        cout<<"new node create fail"<<endl;
        return false;
    }
    Node<T> *tempNode= tempPreNode->getNext();//save pre node pointer
    tempPreNode->setNext(newnode); //set pre node pointer to new node address
    newnode->setNext(tempNode);//set new node pointer to pre node pointer
    newnode->setData(elem);    //set new node new data
    m_iLength++;
    return true;
}

template <typename T>
bool LinkList<T>::ListDelete(int index,T *elem)
{
    //index out of range
    if(index<0 || index>=m_iLength)
    {
        return false;
    }

    //
    Node<T> *tempPreNode = m_pList; //pre node
    for(int i=0;i<index;i++)//find pre node
    {
        tempPreNode = tempPreNode->getNext();
    }

    Node<T> * tempNode = tempPreNode->getNext();//save delete point pointer 
    tempPreNode->setNext(tempNode->getNext());//set pre node  point to next node
    *elem = tempNode->getData();
    delete tempNode;

    m_iLength--;
    return true;        
}

template <typename T>
void LinkList<T>::ListPrint(void)
{
    if(isListEmpty())
    {
        cout<<"List empty"<<endl;
        return;
    }
    Node<T> *tempNode=m_pList->getNext();
    while(tempNode->getNext() != NULL)
    {        
        tempNode->printData();
        tempNode = tempNode->getNext();
    }
    tempNode->printData();
    cout<<"end"<<endl;
}

單項鏈表模板定義完了，我們在main.cpp中使用int類型實例化它、並測試它的功能

#include <iostream>
#include <string>
#include "LinkList.h"
using namespace std;

int main(void)
{
    /*insert data check*/
    int data[10]={0,1,2,3,4,5,6,7,8,9};
    LinkList<int> *linklist = new LinkList<int>;
    for(int i=0;i<5;i++)
    {
        linklist->ListInsert(i,data[i]);
    }
    linklist->ListPrint();

    /*getElemIndex check*/
    cout<<"getElemIndex:"<<linklist->getElemIndex(data[4])<<endl;

    /*getListElem check*/
    int getdata;
    linklist->getListElem(2,&getdata);
    cout<<"getListElem:"<<getdata<<endl;


    /*delete data check*/
    int deletedata;
    linklist->ListDelete (0,&deletedata);
    cout<<"delete data:"<<deletedata<<endl;
    linklist->ListPrint();

    /*clearList check*/
    linklist->clearList();
    linklist->ListPrint();

    delete linklist;
    linklist = NULL;
    system("pause");
    return 0;
}

運行結果如下：

技術分享

數據結構-單向鏈表 C和C++的實現

相關推薦

數據結構-單向鏈表 C和C++的實現

下標 using print find 十分 for null type 一位 數據結構，一堆數據的存放方式。 今天我們學習數據結構中的 鏈表： 數組，大家相當熟悉的存放數據方式，而鏈表是數組的一種特殊方式，它每個節點包括兩個部分： 數據域：存放數據，此部分與數組相同

c++數據結構之鏈表詳情1(順序鏈表)

length thead cout main.c 元素 protected 序表 3.2 font 長大是人必經的潰爛 ---大衛塞林格 代碼是年輕人的新生！！！！！！ 程序 = 數據結構 + 算法 --Niklaus EmilWirth 這篇博客在參考

數據結構之鏈表

ret 需要 ror std 用戶輸入 用戶 存儲 足夠 存在 數據結構——鏈表 在c++中，數組對應著一個連續存儲的內存塊，將同類型的元素一個一個地排列起來，是組織數據的很好的方法。聲明數組的同時我們需要告訴編譯器數組的大小，以便開辟足夠大小的內存。但是，在解決實際問

redis源碼分析（3）-- 基本數據結構雙鏈表list

direction 函數指針 all eas 源碼 計數 type ima blog 一、雙鏈表結構 redis中實現的雙鏈表結構體如下： 1 typedef struct list { 2 listNode *head; # 鏈表頭 3 listNode

基本數據結構：鏈表

lis 最大 src 雙向鏈表 頻繁 鏈式表 結構 節點 aid 談到鏈表之前，先說一下線性表。線性表是最基本、最簡單、也是最常用的一種數據結構。線性表中數據元素之間的關系是一對一的關系，即除了第一個和最後一個數據元素之外，其它數據元素都是首尾相接的。線性表有兩種存儲方

數據結構之鏈式隊列(C實現)

num 返回 創建 位置 刪除 () temp 結點 pan linkqueue.h #ifndef LINKQUEUE_H #define LINKQUEUE_H #include <stdio.h> #include <malloc.h>

數據結構-雙向鏈表&雙向循環鏈表

class 項目 none png text mes 分享 row 兩個 借圖：http://www.cnblogs.com/skywang12345/p/3561803.html#a33 雙向鏈表 雙向鏈表(雙鏈表)是鏈表的一種。和單鏈表一樣，雙鏈表也是由節點組成，它的每

數據結構之鏈表操作

index stat nbsp ID prev set append his 改進 對鏈表的增刪改查簡單實現 public class LinkedList<E> { private class Node{ public Node

數據結構之鏈表及實現

oid void scan pan 尋找 最大 執行 連續 邏輯 線性表的鏈式表示和實現 線性表的順序存儲結構的特點是邏輯關系上相鄰的兩個元素在物理位置上也相鄰。正由於這種特點，在做插入和刪除操作時，需移動大量元素。 鏈式存儲：不要求邏輯上相鄰的元素在物理位置上也相鄰，特點

數據結構：鏈表（三）

尾插法 .com 鏈表 inf fin 數據 code com python 一、鏈表基礎 1、什麽是鏈表？ 鏈表中每一個元素都是一個對象，每個對象稱為一個節點，包含有數據域key和指向下一個節點的指針next。通過各個節點之間的相互連接，最終串聯成一個鏈表。 2、節點定義

最基礎的動態數據結構：鏈表

truct exc shadow equal this stack 讓其 靜態 垃圾 什麽是鏈表 鏈表是一種線性結構，也是最基礎的動態數據結構。我們在實現動態數組、棧以及隊列時，底層都是依托的靜態數組，靠resize來解決固定容量的問題，而鏈表是真正的動態數據結構。學習鏈表

Java數據結構——雙向鏈表

.com bubuko http 分享圖片 null wid string 元素 java數據結構 什麽是雙向鏈表？每一個結點不僅配有next引用，同時還有一個prev引用，指向其上一個結點（前驅結點）， 沒有前驅的時候就為NULL。 （以下圖片均來自網絡，侵刪）

數據結構-排序算法原理和Python實現

遞歸 pivot 依次 新的 樹形 希爾排序 image pso 代碼 排序算法概覽 插入排序 基本思想是每次講一個待排序的記錄，按其關鍵字大小插入到前面已拍好的子序列中，直到全部完成。 直接插入排序 講元素L(i)插入到有序序列L[1,…,i-1]中，執行以下操作： 1

[讀書筆記]-大話數據結構-3-線性表(三)-靜態鏈表、循環鏈表和雙向鏈表

ima 是否 特殊 ont 雙向鏈表 位置 方便 實現 部分 靜態鏈表 對於沒有指針的編程語言，可以用數組替代指針，來描述鏈表。讓數組的每個元素由data和cur兩部分組成，其中cur相當於鏈表的next指針，這種用數組描述的鏈表叫做靜態鏈表，這種描述方法叫做遊標實

【數據結構】順序表和鏈表

頭刪 enc 遍歷 情況 ear count 數據 表的基本操作 直接 一、順序表 順序表定義 ：順序表是在計算機內存中以數組的形式保存的線性表，線性表的順序存儲是指用一組地址連續的存儲單元依次存儲線性表中的各個元素、使得線性表中在邏輯結構上相鄰的數據元素存儲在相鄰的物理存

c++實現數據結構1.順序表

seq 程序 主程 num c++ round private gravity ext 頭文件seqlist.h #ifndef _SEQLIST_H_ #define _SEQLIST_H_ #include<iostream> using namesp

【C++/數據結構】單鏈表的基本操作

clear default als troy pub 插入 else fonts pac #pragma once #ifndef _CLIST_H_ #define _CLIST_H_ #include <iostream> #include <

數據結構之線性表代碼實現順序存儲，鏈式存儲，靜態鏈表（選自大話數據結構）

新元素 error 失敗 尾插法 後繼 順序存儲 %d 帶表頭 tle 一，線性表順序存儲 #include <stdio.h> #include <string.h> #include <ctype.h> #i

數據結構之線性表（鏈表）

位置 鏈表 ont 調用 void 刪除鏈表 個數 urn over 鏈表 1.鏈表的定義：線性表的鏈式存儲結構的特點是用一組任意的存儲單元存儲線性表的數據元素（這組存儲單元可以是 連續的，也可以是不連續的）。因此，為了表示每個數據元素ai與其直接後繼數據元素ai+

數據結構——哈希表的構造和查找

info flag true char key值 技術分享 bsp truct ear #include<stdio.h> #include<malloc.h> #define MAXSIZE 25 #define P 1