2. 程式人生 > >資料結構複習---順序表和單鏈表

資料結構複習---順序表和單鏈表

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

1.前言:

最近比較浮躁,想學習一門新的技術卻總是淺嘗輒止,遇到不懂的地方就想跳過去,時間長了,心態就有點崩了。靜下心來,去喝了幾碗心靈雞湯。雞湯博主感動到了我:"無專注，無風景。不要太貪心，一次只做一件事，而且只做最重要的事。".於是乎,我把家裡翻了個底朝天,找到了我墊在床底下的《資料結構》這本書,覺得自己是時候靜下心來好好複習一下基礎了。今天剛看到順序表和連結串列,把我的學習心得記錄在這裡。也希望自己能堅持,老老實實的把這本書複習完。

2.資料結構的重要性:

講一門知識之前,通常流程都是要是先吹一波這個東西的重要性,資料結構和演算法雖然已經被吹上天了,我還是覺得有必要:眾所周知,資料結構是計算機專業中最重要的課程之一,可是為什麼呢?用處太多難以列舉,總結成一句話就是：可以讓你的程式跑更快

。今天主要一下順序表和單鏈表的原理和實現

3.順序表:

順序表是最簡單,最常用,最基本的資料結構

特點:1.結構中的元素存在1對1的線性關係，這種1對1的關係指的是資料元素之間的關係

　　  2.位置有先後關係,除第一個位置的元素外,其他位置的元素前面都只有一個數據元素,相反除最後一個位置的資料元素外，其他位置的資料元素後面都只有一個元素。

CLR中的實現:List<T>

 順序表儲存結構:

 

c#實現順序表(程式碼中只實現了順序表的基本功能,沒有去做健壯性處理):

  /// <summary>
    ///
 
 順序表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ListDS<T> : IListDS<T>
    {

        #region 初始化--2019年1月6日23:20:11
        /// <summary>
        ///儲存資料
        /// </summary>
        private T[] Data;
        /// <summary>   
        /// 表示儲存了多少資料
        
 
/// </summary>
        private int Count;
        /// <summary>
        /// 建構函式
        /// </summary>
        /// <param name="size">資料大小</param>
        public ListDS(int size)
        {
            Data = new T[size];
            Count = 0;
        }
        public ListDS() : this(10)
        {

        }
        #endregion

        #region 索引器--2019年1月6日23:20:06
        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T this[int index] => GetEle(index);
        #endregion

        #region 新增--2019年1月6日23:20:03
        /// <summary>
        /// 新增方法    
        /// </summary>
        /// <param name="item">新增的元素</param>
        public void Add(T item)
        {
            if (Count == Data.Length)
            {
                Console.WriteLine("當前順序表已存滿");
                return;
            }
            Data[Count] = item;
            Count++;
        }
        #endregion

        #region 清空--2019年1月6日23:19:58
        /// <summary>
        /// 清空
        /// </summary>
        public void Clear()
        {
            Count = 0;
        }
        #endregion

        #region 插入資料--2019年1月6日23:19:54
        /// <summary>
        /// 插入資料 陣列向後移動
        /// </summary>
        /// <param name="item"></param>
        /// <param name="index"></param>
        public void Insert(T item, int index)
        {
            for (int i = Count - 1; i >= index; i--)
            {
                Data[i + 1] = Data[i];
            }
            Data[index] = item;
            Count++;
        }
        #endregion

        #region 刪除--2019年1月6日23:19:51
        /// <summary>
        /// 刪除 刪除資料後 陣列從後往前移動
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T Delete(int index)
        {
            T temp = Data[index];
            for (int i =index+1 ; i < Count; i++)
            {
                Data[i - 1] = Data[i];
            }
            Count--;
            return temp;
        }
        #endregion

        #region 根據索引獲取順序表元素--2019年1月6日23:19:46
        /// <summary>
        /// 根據索引獲取順序表元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T GetEle(int index)
        {
            //判斷元素是否存在
            if (index >= 0 && index <= Count - 1)
            {
                return Data[index];
            }
            return default(T);
        }
        #endregion

        #region 獲取陣列長度--2019年1月6日23:19:43
        /// <summary>
        /// 獲取陣列長度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return Count;
        }
        #endregion

        #region 是否為空--2019年1月6日23:19:40
        /// <summary>
        /// 是否為空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return Count == 0;
        }
        #endregion

        #region 根據元素獲取索引--2019年1月6日23:19:36
        /// <summary>
        /// 根據元素獲取索引
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public int Locate(T value)
        {
            for (int i = 0; i < Count-1; i++)
            {
                if (Data[i].Equals(value))
                {
                    return i;
                }
            }
            return -1;
        }
        #endregion
    }
View Code

 

4.連結串列

順序表使用地址連續的儲存單元順序儲存線性表中的各個資料元素,邏輯上想來的資料元素在物理位置上也相鄰,因此,在順序表中查詢任何一個位置上的資料元素非常方便,這是順序表的有點,BUT，順序表插入/刪除時,需要通過移動資料元素,影響了執行效率,線性表的另外一種儲存結構--鏈式儲存（Linkend Storage）這樣的線性表叫連結串列。因此，對連結串列進行插入和刪除時,不需要移動資料元素,但同時也失去了順序表可隨機儲存的優點

CLR中的實現:LinkedList<T>

鏈式儲存結構:

 

 

 

 c#實現單鏈表節點:

 /// <summary>
    /// 單鏈表節點
    /// </summary>
    class Node<T>
    {
        #region 初始化
        public T data;//儲存資料
        public Node<T> next;//指標 指向下一個元素
        public Node(T _data)
        {
            this.data = _data;
            next = null;
        }
        public Node(T _data,Node<T> _node)
        {
            this.data = _data;
            next = _node;
        }
        public Node()
        {
            this.data = default(T);
            this.next = null;
        }
        public T Data
        {
            get { return data; }
            set { data = value; }
        }
        public Node<T> Next
        {
            get { return next; }
            set { next = value; }
        }
        #endregion
    }
View Code

 c#實現單鏈表:

  /// <summary>
    /// 單鏈表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class LinkList<T> : IListDS<T>
    {
        #region 初始化
        /// <summary>
        /// 頭節點
        /// </summary>
        private Node<T> _head;

        public LinkList()
        {
            _head = null;
        }
        #endregion

        #region 索引器
        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T this[int index] => GetEle(index);
        #endregion

        #region 新增
        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="item"></param>
        public void Add(T item)
        {
            //1.  建立一個新節點
            //2.  如果頭節點為空,賦值給頭節點 return
            //3.1 如果頭節點不為空
            //3.2 建立一個節點指向頭節點
            //3.3 迴圈找到尾節點
            //3.4 新節點放在尾部
            Node<T> newNode = new Node<T>(item);

            if (_head == null)
            {
                _head = newNode;
                return;
            }
            Node<T> temp = _head;
            while (true)
            {
                if (temp.Next != null)
                {
                    temp = temp.Next;
                }
                else
                {
                    break;
                }
            }
            temp.Next = newNode;
        }
        #endregion

        #region 清空
        /// <summary>
        /// 清空
        /// </summary>
        public void Clear()
        {
             //清空頭節點,垃圾回收器自動回收所有未引用的物件
            _head = null;
        }
        #endregion

        #region 刪除
        /// <summary>
        /// 刪除
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T Delete(int index)
        {
            //1.如果是頭節點,講指標指向下一個元素
            //2.如果不是頭節點,找到要刪除節點的前一個節點和要刪除的節點
            //3.將引用指向要刪除的節點的後一個節點

            T data = default(T);
            //刪除頭節點
            if (index == 0)
            {
                 data = _head.Data;
                _head = _head.Next;
                 return data;
            }
           
            Node<T> temp =_head;
            for (int i = 1; i < index - 1; i++)
            {
                temp = temp.Next;
            }
            Node<T> preNode = temp;//要刪除的節點的前一個節點
            Node<T> currentNode = temp.Next;//要刪除的節點
            data = currentNode.Data;
            Node<T> nextNode = temp.Next.Next;
            preNode.Next = nextNode;
            return data;
        }
        #endregion

        #region 根據索引訪問
        /// <summary>
        /// 根據索引訪問
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T GetEle(int index)
        {
            Node<T> temp = _head;
            for (int i = 1; i <=index; i++)
            {
                temp = temp.Next;
            }
            return temp.Data;
        }
        #endregion

        #region 獲取長度
        /// <summary>
        /// 獲取長度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            if (_head == null)
            {
                return 0;
            }
            int count = 1;
            Node<T> temp = _head;
            while (true)
            {
                if (temp.Next != null)
                {
                    count++;
                    temp = temp.Next;
                }
                else
                {
                    break;
                }
            }
            return count;
        }
        #endregion

        #region 插入
        /// <summary>
        /// 插入
        /// </summary>
        /// <param name="item">資料</param>
        /// <param name="index">位置</param>
        public void Insert(T item, int index)
        {
            //1.  建立一個新節點
            //2.  如果索引為0(頭節點) 賦值給頭節點 return
            //3.1 如果不是頭節點,找到要插入的節點的前一個節點和要插入的節點
            //3.2 前一個節點指向新節點
            //3.3 新節點指向前一個節點
            Node<T> newNode = new Node<T>(item);
            if (index== 0)
            {
                newNode.Next = _head;
                _head = newNode;
                return;
            }
            Node<T> temp = new Node<T>();
            for (int i = 1; i < index-1; i++)
            {
                temp = temp.Next;
            }
            Node<T> preNode = temp;//要插入的節點的前一個節點
            Node<T> curentNode = temp.Next;//要插入的節點
            preNode.next = newNode;
            newNode.Next = curentNode;
        }
        #endregion

        #region 清空
        /// <summary>
        /// 清空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return _head == null;
        }
        #endregion

        #region 根據資料訪問索引
        /// <summary>
        /// 根據資料訪問索引
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public int Locate(T value)
        {
            Node<T> temp = _head;
            if (temp.Data == null)
            {
                return -1;
            }
            int index = 0;
            while (true)
            {
                if (temp.Data.Equals(value))
                {
                    return index;
                }
                else
                {
                    if (temp.Next != null)
                    {
                        temp = temp.Next;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return -1;
        }
        #endregion
    }
View Code

 

相關推薦

資料結構複習---順序表和單鏈表

1.前言: 最近比較浮躁,想學習一門新的技術卻總是淺嘗輒止,遇到不懂的地方就想跳過去,時間長了,心態就有點崩了。靜下心來,去喝了幾碗心靈雞湯。雞湯博主感動到了我:"無專注，無風景。不要太貪心，一次只做一件事，而且只做最重要的事。".於是乎,我把家裡翻了個底朝天,找到了我墊在床底下的《資料結構》這本書,覺得自

資料結構 筆記：順序表和單鏈表的對比分析

如何判斷某個資料元素是否存在於線性表中？ find -可以為線性表（List）增加一個查詢操作 -int find(const T& e)const; ·引數： ~待查詢的資料元素 ·返回值： ~>= 0：資料元素線上性表中第一次出現的位置 ~-1：資料

考研資料結構複習——(順序表)

/** ***@Title ：考研資料結構複習 ***@Subject ：棧（順序結構） ***@Author ：lxfhahaha ***@language： C語言 ***@Time ： 2018/9/26 15:29 *****/ #incl

數據結構復習---順序表和單鏈表

刪除數據 pla 優點 數組長度 png com val type 自動 1.前言: 最近比較浮躁,想學習一門新的技術卻總是淺嘗輒止,遇到不懂的地方就想跳過去,時間長了,心態就有點崩了。靜下心來,去喝了幾碗心靈雞湯。雞湯博主感動到了我:"無專註，無風景。不要太貪心，一次只做

試分別以順序表和單鏈表作儲存結構，各寫一實現線性表就地逆置的演算法

對陣列的倒置void SeqList<DataType>::inversion() { int i = 0, j = length - 1; DataType temp;

九、順序表和單鏈表的對比分析

opera 基礎數據類型 insert 是我 public 位置 參數 amp 一次 1、如何判斷某個數據元素是否存在於線性表中？ find()操作： 可以為線性表List增加一個查找操作 int find(const T& e)const; 參數：待查找的數據

【C#資料結構-從零開始】單鏈表

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApp8 {

資料結構 - 如何找到有環單鏈表的環的入口位置（C++）

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

C語言——順序表和單鏈表的逆置

順序表的逆置 #include<stdio.h> #include<stdlib.h> #define MAX 100 typedef struct node { int num[MAX]; int length; } *Link, Node;

資料結構上機測試2-1:單鏈表操作A

#include <stdio.h> #include <string.h> #include <stdlib.h> int sum; struct node { int data; struct node *

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

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

java資料結構初學（記錄）單鏈表交換兩節點（3）可與之前寫的進行對比（程式碼優化）——如果後續徹底搞明白後將精煉此部分內容，刪除部分內容

public void swap(String number1, String number2){                  // 定義節點         StudentNode t1,t2,t3,t4;         /**          *        

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

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

「資料結構與演算法 2」| 單鏈表其實真的很簡單。

寫在之前 在程式設計裡，我們經常需要將同為某個型別的一組資料元素作為一個整體來使用，需要建立這種元素組，用變數來記錄它們或者傳入函式等等等等，「線性表」就是這樣一組元素的抽象，它是某類元素的集合並且記錄著元素之間一種順序關係，是最基本的資料結構之一，在實際程式中

資料結構作業10—陣列和廣義表以及樹的基本概念（選擇題）

2-1已知廣義表L=（（x,y,z），a，（u，t，w）），從L表中取出原子項t的運算是（）。 (2分) A.head（tail(head（tail（tail（L）））)） B.head（tail（head（tail（L）））） C.tail（head（head

資料結構系列之連結串列——單鏈表排序

冒泡，從小到大，每輪將大的排後面 node* sort(node *head){     //單鏈表從小到大排序     node *p;     p=head;     if(p==NULL&&p->next==NULL)            re

C++實現順序表和單鏈表

順序表：順序表是在計算機記憶體中以陣列的形式儲存的線性表，是指用一組地址連續的儲存單元依次儲存資料元素的線性結構。 確定了起始位置，就可通過公式計算出表中任一元素的地址：LOC（ai）=LOC（a1）+（i-1）*L 　1≤i≤n （L是元素佔用儲存單元的長度

資料結構_兩個有序單鏈表歸併C語言原始碼

#include<stdio.h> #include<stdlib.h> typedef struct LNode {   int data;   struct LNode *next;; }LNode;      void InitList(LNode *&L) {    

列表的c++實現(類模板，包含順序實現和單鏈表、雙鏈表)

#ifndef LIST_H_INCLUDED #define LIST_H_INCLUDED #include <iostream> using namespace std; template <class elemType> class List{ public:

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

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