資料結構筆記二：線性表

阿新 • • 發佈：2019-01-12

1. 線性表的邏輯結構

線性表是由相同的資料元素組成的有限序列。
在複雜的線性表中，通常資料元素一般由資料項組成，這時一般將資料元素稱為記錄。
線性表可以簡單的表示為：

(a_{1}, a_{2}, \dots, a_{i}, a_{i + 1}, \dots

,an)" role="presentation">

(a_{1}, a_{2}, \dots, a

i , a i + 1 , ⋯ , a n )

$(a_1,a_2, \cdots, a_i, a_{i+1},\cdots, a_n)$
線性表中

a_{i}

$a_i$ 領先於

a_{i + 1}

$a_{i+1}$ ，

a_{i}

$a_i$ 稱為

a_{i + 1}

$a_{i+1}$ 的直接前驅，簡稱為前驅，

a_{i + 1}

$a_{i+1}$ 稱為

a_{i}

$a_i$ 的直接後繼，簡稱為後繼。
為了更精確的定義線性表，下面給出線性表的形式定義：

LinearList = （ D, R ）

$\text{LinearList} = （D,R）$
其中,

D = {a_{i} | a_{i} \in D, i = 1, 2, 3, \dots, n, n \geq 0}

$D=\{a_i | a_i \in D, i=1,2,3,\cdots,n,n \ge 0\}$ ,

D

$D$ 為某個資料集合，

R = N, N = {< a_{i}, a_{i + 1} > | i = 1, 2, \dots, n - 1}

$R={N},N=\{<a_i,a_{i+1}>|i = 1,2, \cdots, n-1\}$
線性表中的資料元素個數

n

$n$ 稱為線性表的長度，當

n = 0

$n = 0$ 時稱為空表。

2. 線性表包括的基本操作

1). int Lenght() const
初始條件：線性表已經存在。
操作結果：返回線性表元素的個數

2). bool Empty() const
初始條件：線性表已經存在。
操作結果：如線性表為空，則返回ture，否則返回false.

3). void Clear()
初始條件：線性表已經存在。
操作結果：清空線性表。

4). void Traverse( void (* Visit)(ElemType &) )
初始條件：線性表已經存在。
操作結果：一次對線性表的每個元素呼叫函式(* Visit)

5). void GetElem(int position, ElemType &e) const
初始條件：線性表已經存在， $1 \le \text{position} \le \text{Length()}$ 。
操作結果：用 $e$ 返回第position位置的元素。

6). void SetElem(int position, const ElemType &e)
初始條件：線性表已經存在， $1 \le \text{position} \le \text{Length()}$
操作結果：將線性表的第position位置的元素的值賦為e。

7). void Delete(int position, ElemType &e)
初始條件：線性表已經存在， $1 \le \text{position} \le \text{Length()}$ 。
操作結果：刪除線性表的第position個位置的元素，並用e返回其值，長度減1.

8). void Insert(int position, const ElemType &e)
初始條件：線性表已經存在， $1 \le \text{position} \le \text{Length() }$

3. 線性表的順序儲存結構

//.h檔案
#pragma once
#include <iostream>

using namespace std;
//首先要建立一個類，這個類中要有三個成員：元素的個數，
//順序表能儲存的最大長度，指向元素儲存空間的指標
#define DEFAULT_SIZE 10
//順序表類
template<typename elemType>
class SqList
{
private:
    //順序表實現的資料成員
    int count;      //存入元素的個數
    int maxSize;    //順序表最大能存入的元素的個數
    elemType* elem; // 指向順序表儲存空間的指標

    //輔助函式
    bool Full() const;//判斷線性表是否已經存滿
    void Init(int size);//初始化順序表

public:
    SqList(int size = DEFAULT_SIZE); //建構函式
    virtual ~SqList();//解構函式（為什麼是虛的）
    int Length() const;//求線性表長度
    bool Empty() const;//判斷線性表示否為空
    void Clear();//將線性表清空
    void Traverse();//遍歷線性表
    bool GetElem(int position, elemType &e);//獲取指定位置的元素
    bool SetElem(int position, const elemType &e);//設定指定位置的元素值
    bool Delete(int position, elemType &e);//刪除元素
    bool Insert(int position, const elemType &e);//插入元素
    int getMaxSize() const;//獲取最大順序表的容量

    SqList( SqList<elemType> &copy);//複製建構函式
    SqList<elemType> &operator=( SqList<elemType> &copy);//賦值運算子過載

};

//具體實現
template<typename elemType>
bool SqList<elemType>::Full() const
//操作結果：如果線性表已滿，則返回ture，否則返回false.
{
    return count == maxSize;
}

template<typename elemType>
void SqList<elemType>::Init(int size)
//操作結果：對線性表進行初始化
{
    maxSize = size;
    if (elem != NULL)
    {
        delete []elem;
    }   
    elem = new elemType [maxSize];
    count = 0;
}

template<typename elemType>
SqList<elemType>::SqList(int size)
//操作結果：構造大小為size的空順序表
{
    elem = NULL;
    Init(size);
}

template<typename elemType>
SqList<elemType>::~SqList()
{
    delete[]elem;
}

template<typename elemType>
int SqList<elemType>::Length() const
{
    return count;
}

template<typename elemType>
bool SqList<elemType>::Empty() const
{
    return count == 0;

}

template<typename elemType>
void SqList<elemType>::Clear()
{
    count = 0;
}

template<typename elemType>
void SqList<elemType>::Traverse()
{
    for (int curposition = 1; curposition <= count; curposition++)
    {
        cout << "第" << curposition << "個元素的值為：" << elem[curposition - 1] << endl;
    }
}

template<typename elemType>
bool SqList<elemType>::GetElem(int position, elemType &e)
{
    if (position < 1 || position > count)
    {
        return false;
    }
    else
    {
        e = elem[position - 1];
        return true;
    }
}

template<typename elemType>
bool SqList<elemType>::SetElem(int position, const elemType &e)
{
    if (position < 1 || position > count)
    {
        return false;
    }
    else
    {
        elem[position - 1] = e;
        return true;
    }
}

template<typename elemType>
bool SqList<elemType>::Delete(int position, elemType &e)
{
    if (position < 1 || position > count || Empty())
    {
        return false;
    }
    else
    {
        e = elem[position - 1];
        for (int curPosition = position; curPosition < count; curPosition++)
        {
            elem[curPosition - 1] = elem[curPosition];
        }
        count--;
        return true;
    }
}

template<typename elemType>
int SqList<elemType>::getMaxSize() const
{
    return maxSize;
}

template<typename elemType>
bool SqList<elemType>::Insert(int position, const elemType &e)
{
    if (this->count == 0)
    {
        elem[0] = e;
        count++;
        return true;
    }
    if (position < 1 || position > this->count + 1 || Full() )
    {
        return false;
    }
    else
    {
        for (int curPosition = this->count; curPosition >= position; curPosition--)
        {
            elem[curPosition] = elem[curPosition - 1];
        }
        elem[position - 1] = e;
        this->count++;
        return true;
    }
}

template<typename elemType>
SqList<elemType>::SqList( SqList<elemType> &copy)
{
    this->Init(copy.getMaxSize());
    this->count = copy.Length();
    this->maxSize = copy.getMaxSize();
    elemType e;
    for (int curPosition = 1; curPosition < this->count + 1; curPosition++)
    {
        copy.GetElem(curPosition, e);
        this->SetElem(curPosition, e);
    }
}

template<typename elemType>
SqList<elemType> & SqList<elemType>::operator=( SqList<elemType> &copy)
{

    if (&copy != this)
    {
        this->Init(copy.getMaxSize());
        this->count = copy.Length();
        this->maxSize = copy.getMaxSize();

        elemType e;
        for (int curPosition = 1; curPosition < this->count+1; curPosition++)
        {
            copy.GetElem(curPosition, e);
            this->SetElem(curPosition, e);
        }
    }
    return *this;
}

測試檔案

#include "SqList.h"

int main(int argc, char** argv)
{
    int e;
    SqList<int> myList;
    myList.Insert(1, 1);
    myList.Insert(2, 2);
    myList.Insert(3, 3);
    //myList.Traverse();
    myList.Delete(2, e);
    //myList.Traverse();
    SqList<int> myList2;
    myList2 = myList;
    myList2.Traverse();
    getchar();
    return 0;
}

線性表的順序結構儲存特點：

(1) 線性表的順序儲存結構用一組地址連續的儲存單元一次儲存線性表的元素。
(2) 順序表的物理儲存結構為：儲存在地址相鄰的儲存單元中。
(3) 線性表的順序儲存結構可以隨機的儲存任意位置的資料元素，因此線性表順序結構是一種隨機儲存的資料結構。
(4) 線性表的順序結構在進行插入和刪除時，要移動大量的資料元素。

4. 線性表的鏈式儲存結構

//.hpp檔案

#pragma once
#include <iostream>

using namespace std;
//節點類
template<typename elemType>
struct Node
{
//資料成員
    elemType data;//資料域
    Node<elemType>* next;//指標域

//建構函式
    Node();//無參建構函式
    Node(elemType item, Node<elemType>* Link = NULL);//已知資料域和指標域建立結構
};

//節點類的實現部分
template<typename elemType>
Node<elemType>::Node()
//操作結果：構造指標域為空的節點
{
    this->next = NULL;
}

template<typename elemType>
Node<elemType>::Node(elemType item, Node<elemType>* Link)
//操作結果：構造資料域為item指標域為Link的節點
{
    this->data = item;
    this->next = Link;
}


//簡單線性連結串列類
template<typename elemType>
class SimpleLinkList
{
//連結串列實現的資料成員
private:
    Node<elemType> *head; //頭節點指標

//輔助函式
    Node<elemType>* getElemPtr(int position) const;//返回指向第position個節點的指標
    void Init();//初始化線性表

public:
//抽象資料型別方法宣告以及過載編譯系統預設方法宣告
    SimpleLinkList();//無引數的建構函式
    virtual ~SimpleLinkList();//解構函式
    int getLength() const;//獲取線性表的長度
    bool isEmpty() const;//判斷線性表是否為空
    void Clear();//將線性表清空
    void Traverse();//遍歷線性表
    int getElem(int position, elemType &e) const;//獲取指定位置的元素值
    int setElem(int position, const elemType &e);//設定指定位置的元素值
    int Delete(int position, elemType &e);//刪除指定位置的值，並返回其值
    int Insert(int position, const elemType &e);//在指定位置插入值e

    SimpleLinkList(SimpleLinkList<elemType> &copy);//複製建構函式
    SimpleLinkList<elemType>& operator =(SimpleLinkList<elemType> &copy);//賦值運算子過載
};


//簡單線性連結串列實現
template<typename elemType>
Node<elemType>* SimpleLinkList<elemType>::getElemPtr(int position) const
//操作結果：獲取第position位置處的指標
{
    Node<elemType>* tempPtr = head;//用tempPtr遍歷線性連結串列以查詢第position個節點
    int curPosition = 0;//記錄tempPtr所在的連結串列的位置

    while (tempPtr != NULL && curPosition < position)
    //順指標向後查詢，直到tempPtr指向第position個節點
    {
        tempPtr = tempPtr->next;
        curPosition++;
    }

    if (tempPtr != NULL && curPosition == position)
    //查詢成功
    {
        return tempPtr;
    }
    else
    //查詢失敗
    {
        return NULL;
    }

}

template<typename elemType>
void SimpleLinkList<elemType>::Init()
{
    head = new Node < elemType > ;//構造頭指標
    head->next = NULL;
}

template<typename elemType>
SimpleLinkList<elemType>::SimpleLinkList()
{
    Init();
}

template<typename elemType>
SimpleLinkList<elemType>:: ~SimpleLinkList()
//操作結果：銷燬線性表
{
    Clear();
    delete head;
}

template<typename elemType>
int SimpleLinkList<elemType>::getLength() const
{
    int count = 0;
    for (Node<elemType> * tempPtr = head->next; tempPtr != NULL; tempPtr = tempPtr->next)
    {
        count++;
    }
    return count;
}

template<typename elemType>
bool SimpleLinkList<elemType>::isEmpty() const
{
    return head->next == NULL;
}

template<typename elemType>
void SimpleLinkList<elemType>::Clear()
//操作結果:清空線性表
{
    elemType tempele;
    while (head->next != NULL)
    {
        Delete(1, tempele);
    }
}

template<typename elemType>
void SimpleLinkList<elemType>::Traverse()
{
    int count = 1;
    for (Node<elemType> * tempPtr = head->next; tempPtr != NULL; tempPtr = tempPtr->next)
    {
        cout << "第" << count << "個元素的值為：" << tempPtr->data << endl;
        count++;
    }
}

template<typename elemType>
int SimpleLinkList<elemType>::getElem(int position, elemType &e) const
{
    Node<elemType>* tempPtr = head;
    int curPosition = 0;
    while (tempPtr->next != NULL && curPosition < position)
    {
        tempPtr = tempPtr->next;
        curPosition++;
    }

    if (curPosition == position && tempPtr != NULL)
    {
        e = tempPtr->data;
        return 1;
    }
    else
    {
        return -1;
    }
}

template<typename elemType>
int SimpleLinkList<elemType>::setElem(int position, const elemType &e)
{
    if (position < 1 || position > this->getLength())
    {
        return -1;
    }
    else
    {
        Node<elemType> * tempPtr = this->getElemPtr(position);
        tempPtr->data = e;
        return 1;
    }
}

template<typename elemType>
int SimpleLinkList<elemType>::Delete(int position, elemType &e)
{
    if (position < 1 || position > this->getLength())
    {
        return -1;
    }
    else
    {
        Node<elemType>* curPtr = this->getElemPtr(position-1);//指向刪除位置節點的前一個節點
        Node<elemType>* nextPtr = curPtr->next;
        curPtr->next = nextPtr->next;
        e = nextPtr->data;
        delete nextPtr;
        return 1;
    }
}

template<typename elemType>
int SimpleLinkList<elemType>::Insert(int position, const elemType &e)
{
    if (position < 1 || position > this->getLength() + 1)//這裡要加一

 
 
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    資料結構筆記二：線性表
       
  
  
 
 
   
    
    
      
      
        
        1. 線性表的邏輯結構 
        2. 線性表包括的基本操作 
        3. 線性表的順序儲存結構 
        4. 線性表的鏈式儲存結構 
         
       

  
 

    

    
    資料結構實驗一：線性表的基本操作
      
							
							
							// 186658-S181-李雙源.cpp : 定義控制檯應用程式的入口點。
//時間 2018-10-27
//內容：線性表的基本操作 

#include "stdafx.h"
#include <iostream>
#include<s 

  
 

    

    
    資料結構（二）:線性表的使用原則以及連結串列的應用-稀疏矩陣的三元組表示
      
								
								            
						
                

下面先對沒有介紹的連結串列中的雙鏈表進行介紹，並通過稀疏矩陣的三元組的鏈式結構來深入理解較為複雜的連結串列儲存結構。最後對三次博文所講述的內容進行梳理，以幫助在實際應用中選擇最合適的儲存結構：順序表 

  
 

    

    
    《資料結構》實驗二：線性表的實驗（實驗報告）
      
                


一．實驗目的

     鞏固線性表的資料結構，學會線性表的應用。

1.回顧線性表的邏輯結構，線性表的物理儲存結構和常見操作。

2.學習運用線性表的知識來解決實際問題。

3.進一步鞏固程式除錯方法。

4.進一步鞏固模板程式設計。

二．實驗時間

   準備時間 

  
 

    

    
    資料結構二：線性表的順序結構實現
      
                
此程式根據高一凡大神的源程式修改而成。/*************************************************************
FileName：c2-1.h
Function：定義線性表的動態分配順序儲存結構(動態分配的一維陣列)
** 

  
 

    

    
    【python】python資料結構（一）——線性表：順序表的實現
      
                
前言
這一系列文章將介紹基於python語言的資料結構，主要涉及線性表、字串、棧和佇列、二叉樹和樹、圖、字典和集合、排序等。
線性表及分類
線性表是一類元素序列的抽象，是某類元素的集合，記錄著元素之間的順序關係。python中的list和tuple都支援線性表的需要，只是t 

  
 

    

    
    資料結構（七）線性表（二）
      
								
								            
						
                
Status GetElem(SqList L, int i, ElemType *e)
{
    if(L.length == 0 || i < 1 || i > L.length)
 

  
 

    

    
    數據結構（二）:線性表的使用原則以及鏈表的應用-稀疏矩陣的三元組表示
      查找   triple   表的操作   結構   循環鏈表   循環   大於   ria   幫助   

上一篇博文中主要總結線性表中的鏈式存儲結構實現，比方單向鏈表、循環鏈表。還通過對照鏈表和順序表的多項式的存儲表示。說明鏈表的長處。能夠參看上篇博文http://blog.csdn.net/lg125 

  
 

    

    
    數據結構（二）線性表——鏈表
      erro   urn   找到   頭結點   tee   存在   結構   strong   函數   通常情況下，鏈接可分為單鏈表、雙向鏈表和循環鏈表三種常用類型。
一、單鏈表基本操作的實現
使用鏈式存儲結構來實現的線性表稱為鏈表。首元結點、頭結點、頭指針、空指針。
1.單鏈表的類型定義

typede 

  
 

    

    
    數據結構（二）——線性表簡介
      pen   線性   virtual   spa   多個   集合   mes   index   esp   數據結構（二）——線性表簡介
一、線性表簡介
1、線性表簡介
線性表是具有相同類型的n個數據元素的有限序列A0，A1，A2，...，An-1。Ai是表項，n是表的長度。
2、線性表的表現形式
線性 

  
 

    

    
    大話資料結構（一）——線性表順序儲存結構的java實現
       
  
  
  
   
       在看《大話資料結構》的時候，裡面詼諧的語言和講解吸引了我，但是這本書是用C來實現的，但是作為一個手擼java的人就想著用java來實現一下這些資料結構，於是就有了這些大話資料結構之java實現。哈哈，感覺這樣會讓自己的理解加深不少。 
   &n 

  
 

    

    
    資料結構之查詢-基於線性表的查詢法
      基於線性表的查詢法 
順序查詢 
演算法思想 
用所給的元素與列表的中的各個元素進行比較，若相等返回索引，否則返回錯誤資訊。 
假設列表長度為$n$那麼查詢第$i$個元素時需進行$n-i+1$次比較，即$C_i=n-i+1$,又假設查詢每個資料元素的概率相等，即$P_i =1/n$,則順序查詢成功的平均查詢長 

  
 

    

    
    【資料結構】1-1 線性表
       
 //單鏈表.cpp
#include"LinkList.h"
#include<iostream>
template<class T>
LinkList<T>::LinkList()
{
    head = new Node<T>;
    head-& 

  
 

    

    
    C++資料結構實驗報告：順序表實現
       
 
  
  一，順序表的作用 
   
 線性結構的基本特徵為:   1．集合中必存在唯一的一個“第一元素”2．集合中必存在唯一的一個 “最後元素”3．除最後一個元素之外，均有 唯一的後繼(後件)  4．除第一個元素之外，均有 唯一的前驅(前件)  由n(n≥0)個數據元素(結點)a1,a2,…,an組 

  
 

    

    
    【資料結構與演算法】線性表——刪除重複元素
       
 
 線性表是一種隨機存取的結構，和連結串列不同，連結串列順序存取的結構。但是，線性表是一種順序儲存的結構，而連結串列是鏈式儲存結構。兩者都是線性的，但區別不同。 
   
 進入主題： 
 1.假如有一串資料元素，要求刪除其中的重複元素。 
 首先想到的是用兩層迴圈，第一層從第一個元素開始，第 

  
 

    

    
    資料結構實驗一：順序表的驗證實驗
       
 
 
 
  #ifndef SeqList_H
#define SeqList_H
const int MaxSize=10;
class SeqList
{
public:
	SeqList(){length=0;}
	SeqList(int a[],int n);
	~SeqList(){}
	v 

  
 

    

    
    資料結構（概述、線性表）
      
							
							
							資料結構

本文大部分內容整理自程傑老師的《大話資料結構》



一、資料結構概述

分類： 
①邏輯結構：面向問題的結構，主要是思維上的認知 
1.集合結構   唯一的關係是大家都在一個集合內 
2.線性結構   一對一  
3.樹形結構   一對多 
4.圖 

  
 

    

    
    資料結構那點事--線性表（連結串列）
      
							
							
							#include<iostream>
#include<stdlib.h>
using namespace std;
//鏈式線性表的儲存結構
#define OK 1
#define ERROR 0
#define TRUE 1
#de 

  
 

    

    
    PTA-資料結構 求鏈式線性表的倒數第K項
      
                7-24 求鏈式線性表的倒數第K項 （20 分）

給定一系列正整數，請設計一個儘可能高效的演算法，查詢倒數第K個位置上的數字。

輸入格式:

輸入首先給出一個正整數K，隨後是若干正整數，最後以一個負整數表示結尾（該負數不算在序列內，不要處理）。

輸出格式:

輸出倒數第 

  
 

    

    
    資料結構那點事--線性表（迴圈列表）
      
							
							
							#include<iostream>
using namespace std;
typedef struct DulNode
{
	ElemType data;
	struct DuLNode *prior;//直接前驅結點
	struct DuLN