c++数据结构之链表详情1(顺序链表)

长大是人必经的溃烂 ---大卫塞林格

代码是年轻人的新生！！！！！！

程序 = 数据结构 + 算法 --Niklaus EmilWirth

这篇博客在参考一些书籍和教学视频的基础上整理而来，中间夹杂了一些自己写的代码

1、List

先贴一个基础的整型顺序链表list的c++代码

List.cpp

  1 #include <iostream>
  2 #include "List.h"
  3
  4 using namespace std;
  5
  6 //创建链表
  7 List::List(int Size)
  8 {
  9     m_iSize  =Size;
 10     m_pList = new int[m_iSize];
 11     m_iLength = 0;
 12 }
 13 List::~List()
 14 {
 15     delete []m_pList;
 16     m_pList = NULL;
 17 }
 18 //清空链表
 19 void List::ClearList()
 20 {
 21     m_iLength = 0;
 22 }
 23 bool List::IsEmpty()
 24 {
 25     if (m_iLength==0)
 26     {
 27         return true;
 28     }
 29     else
 30     {
 31         return false;
 32     }
 33 }
 34 int List::GetLength()
 35 {
 36     return m_iLength;
 37 }
 38 bool List::GetElement(int i,int *e)
 39 {
 40     if (i<0||i>m_iSize)
 41     {
 42         return false;
 43     }
 44     *e = m_pList[i];
 45     return true;
 46 }
 47 int List::LocateElement(int *e)
 48 {
 49     for (int i=0;i<m_iLength;i++)
 50     {
 51         if (m_pList[i] == *e)
 52         {
 53             return i;
 54         }
 55     }
 56 }
 57 /**********************************************************
 58 获取指定元素的前驱
 59 **********************************************************/
 60 bool List::PriorElement(int *PreElement,int *CurrentElement)
 61 {
 62     int temp = LocateElement(CurrentElement);
 63     if (temp == -1)
 64     {
 65         return false;
 66     }
 67     else
 68     {
 69         if (temp == 0)
 70         {
 71             return false;
 72         }
 73         else
 74         {
 75             *PreElement = m_pList[temp-1];
 76             return true;
 77         }
 78     }
 79 }
 80 /*******************************************************
 81 获取指定元素的后继
 82 ********************************************************/
 83 bool List::NextElement(int *NeElment,int *CurrentElement)
 84 {
 85     int temp = LocateElement(CurrentElement);
 86     if (temp == -1)
 87     {
 88         return false;
 89     }
 90     else
 91     {
 92         if (temp == m_iLength)
 93         {
 94             return false;
 95         }
 96         else
 97         {
 98             *NeElment = m_pList[temp+1];
 99             return true;
100         }
101     }
102 }
103 /************************************
104 在顺序表中的指定位置插入元素
105 *************************************/
106 bool List::ListInsert(int i,int *e)
107 {
108     if(i<0||i>m_iLength)
109     {
110         return false;
111     }
112     for (int k=m_iLength-1;k>=i;k--)
113     {
114         m_pList[k+1] = m_pList[k];
115     }
116     m_pList[i] = *e;
117     m_iLength++;
118 }
119 /***********************************
120 删除顺序表指定的元素
121 ************************************/
122 bool List::ListDelete(int i,int *e)
123 {
124     *e = m_pList[i];
125     if(i<0||i>m_iLength)
126     {
127         return false;
128     }
129     for (int k=i+1;k<m_iLength;i++)
130     {
131         m_pList[k-1] = m_pList[k];
132     }
133     m_iLength--;
134 }
135 /***********************************
136 遍历顺序表中的数据
137 ************************************/
138 void List::ListTranverse()
139 {
140     for (int i=0;i<m_iLength;i++)
141     {
142         cout<<m_pList[i]<<endl;
143     }
144 }
145 //bool List::ListInsertHead(int *e)
146 //{
147 //
148 //}
149 //bool List::ListInsertTail(int *e)
150 //{
151 //
152 //}

List.h

#ifndef LIST_H
#define LIST_H

class List
{
public:
    List(int Size);
    ~List();
    void ClearList();
    bool IsEmpty();
    int GetLength();
    bool GetElement(int i,int *e);
    int LocateElement(int *e);
    bool PriorElement(int *PreElement,int *CurrentElement);
    bool NextElement(int *NeElment,int *CurrentElement);
    bool ListInsert(int i,int *e);
    bool ListInsertHead(int *e);
    bool ListInsertTail(int *e);
    bool ListDelete(int i,int *e);
    void ListTranverse();
protected:
    int *m_pList;
    int m_iSize;
    int m_iLength;
};

#endif

主函数：

#include <stdio.h>
#include <stdlib.h>
#include "List.h"

using namespace std;

int main(void)
{
    int e1 = 3;
    List *list1 = new List(10);
    list1->ListInsert(0,&e1);
    list1->ListTranverse();
    system("pause");
    return 0;
}

以上代码为整型的顺序list链表，加入一个模板(ps:由于vs中模板的定义个声明不能分开写，我的代码做了一点小小的修改)，

修改以上代码，如下所示：

List.h

 1 #ifndef LIST_H
 2 #define LIST_H
 3
 4
 5 template<typename T1>
 6 class List
 7 {
 8 public:
 9     List(int Size);
10     ~List();
11     void ClearList();
12     bool IsEmpty();
13     int GetLength();
14     bool GetElement(int i,T1 *e);
15     int LocateElement(T1 *e);
16     bool PriorElement(T1 *PreElement,T1 *CurrentElement);
17     bool NextElement(T1 *NeElment,T1 *CurrentElement);
18     bool ListInsert(int i,T1 *e);
19     bool ListInsertHead(T1 *e);
20     bool ListInsertTail(T1 *e);
21     bool ListDelete(int i,T1 *e);
22     void ListTranverse();
23 protected:
24     T1 *m_pList;
25     int m_iSize;
26     int m_iLength;
27 };
28
29 #endif

List.cpp

  1 #include <iostream>
  2 #include "List.h"
  3
  4 using namespace std;
  5
  6 //创建链表
  7 template<typename T1> List<T1>::List(int Size)
  8 {
  9     m_iSize  =Size;
 10     m_pList = new T1[m_iSize];
 11     m_iLength = 0;
 12 }
 13 template<typename T1> List<T1>::~List()
 14 {
 15     delete []m_pList;
 16     m_pList = NULL;
 17 }
 18 //清空链表
 19 template<typename T1> void List<T1>::ClearList()
 20 {
 21     m_iLength = 0;
 22 }
 23 template<typename T1> bool List<T1>::IsEmpty()
 24 {
 25     if (m_iLength==0)
 26     {
 27         return true;
 28     }
 29     else
 30     {
 31         return false;
 32     }
 33 }
 34 template<typename T1> int List<T1>::GetLength()
 35 {
 36     return m_iLength;
 37 }
 38 template<typename T1> bool List<T1>::GetElement(int i,T1 *e)
 39 {
 40     if (i<0||i>m_iSize)
 41     {
 42         return false;
 43     }
 44     *e = m_pList[i];
 45     return true;
 46 }
 47 template<typename T1> int List<T1>::LocateElement(T1 *e)
 48 {
 49     for (int i=0;i<m_iLength;i++)
 50     {
 51         if (m_pList[i] == *e)
 52         {
 53             return i;
 54         }
 55     }
 56 }
 57 /**********************************************************
 58 获取指定元素的前驱
 59 **********************************************************/
 60 template<typename T1> bool List<T1>::PriorElement(T1 *PreElement,T1 *CurrentElement)
 61 {
 62     int temp = LocateElement(CurrentElement);
 63     if (temp == -1)
 64     {
 65         return false;
 66     }
 67     else
 68     {
 69         if (temp == 0)
 70         {
 71             return false;
 72         }
 73         else
 74         {
 75             *PreElement = m_pList[temp-1];
 76             return true;
 77         }
 78     }
 79 }
 80 /*******************************************************
 81 获取指定元素的后继
 82 ********************************************************/
 83 template<typename T1> bool List<T1>::NextElement(T1 *NeElment,T1 *CurrentElement)
 84 {
 85     int temp = LocateElement(CurrentElement);
 86     if (temp == -1)
 87     {
 88         return false;
 89     }
 90     else
 91     {
 92         if (temp == m_iLength)
 93         {
 94             return false;
 95         }
 96         else
 97         {
 98             *NeElment = m_pList[temp+1];
 99             return true;
100         }
101     }
102 }
103 /************************************
104 在顺序表中的指定位置插入元素
105 *************************************/
106 template<typename T1> bool List<T1>::ListInsert(int i,T1 *e)
107 {
108     if(i<0||i>m_iLength)
109     {
110         return false;
111     }
112     for (int k=m_iLength-1;k>=i;k--)
113     {
114         m_pList[k+1] = m_pList[k];
115     }
116     m_pList[i] = *e;
117     m_iLength++;
118 }
119 /***********************************
120 删除顺序表指定的元素
121 ************************************/
122 template<typename T1> bool List<T1>::ListDelete(int i,T1 *e)
123 {
124     *e = m_pList[i];
125     if(i<0||i>m_iLength)
126     {
127         return false;
128     }
129     for (int k=i+1;k<m_iLength;i++)
130     {
131         m_pList[k-1] = m_pList[k];
132     }
133     m_iLength--;
134 }
135 /***********************************
136 遍历顺序表中的数据
137 ************************************/
138 template<typename T1> void List<T1>::ListTranverse()
139 {
140     for (int i=0;i<m_iLength;i++)
141     {
142         cout<<m_pList[i]<<endl;
143     }
144 }
145 //bool List::ListInsertHead(int *e)
146 //{
147 //
148 //}
149 //bool List::ListInsertTail(int *e)
150 //{
151 //
152 //}

main.cpp

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include "List.h"
 4 #include "List.cpp"
 5
 6 using namespace std;
 7
 8 int main(void)
 9 {
10     float e1 = 3.2;
11     List<float> *list1 = new List<float>(10);
12     list1->ListInsert(0,&e1);
13     list1->ListTranverse();
14     system("pause");
15     return 0;
16 }

好了，完整实现，以上是一个顺序链表，换句话说就是一个数组的源码。接下来继续分享链表的源码

原文地址：https://www.cnblogs.com/yiqinari/p/10017822.html

时间： 2024-10-16 22:36:05

c++数据结构之链表详情1(顺序链表)的相关文章

数据结构>>线性表【注意】-->链表求A-B（原A与B都递增，求完的A-B不改变A原来的顺序）

/*关于链表的题目 * A.B是两个递增有序的单链表,元素个数分别是m和n,求 * 集合A-B,并将结果保存在A中,且仍然保持递增有序. * converge_ab */ #include <iostream.h> using namespace std; typedef struct lnode{ int data; struct lnode * next; }lnode; int main(){ lnode * create_chain(int num,int interval,int s

java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList（带Iterator迭代器与fast-fail机制）

转载请注明出处(请尊重原创!谢谢~): http://blog.csdn.net/javazejian/article/details/53073995 出自[zejian的博客] 关联文章: java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList(带Iterator迭代器与fast-fail机制) ??这篇是数据结构与算法的第3篇,通过前两篇的介绍,对应顺序表和链表已有

数据结构之　线性表--顺序创建链表

数据结构实验之链表一:顺序建立链表 Time Limit: 1000MS Memory limit: 65536K 题目描述输入N个整数,按照输入的顺序建立单链表存储,并遍历所建立的单链表,输出这些数据. 输入第一行输入整数的个数N: 第二行依次输入每个整数. 输出输出这组整数. 示例输入 8 12 56 4 6 55 15 33 62 示例输出 12 56 4 6 55 15 33 62 写的时候,定义一个结构体变量就要为它申请空间,不然程序会运行时出问题 ! #include <ios

经典数据结构实现与分析：顺序表，单链表，

本博客在在这里重新总结了一下,当前常用的经典数据结构:这里只针对链表,顺序表,简单树和图进行总结:具体实现请参考:https://github.com/yaowenxu/codes/tree/master/数据结构; 本文章,主要讨论数据结构的性质:以及对这些数据结构的性质:主要是用来知识整理与复习: 顺序表:顺序表是指,将元素顺序地存放在一块连续的内存中:元素间的顺序关系由他们的存储顺序自然表示:c++声明一个数组:int a[10]; 即构建了10个int内存大小(40bytes)的顺序表:

顺序链表——数据结构start!

1 #include <iostream> 2 3 using namespace std; 4 //顺序链表 5 #define MAXSIZE 20 6 #define OK 1 7 #define ERROR 0 8 #define TRUE 1 9 #define FALSE 0 10 typedef int ElemType; 11 typedef int Status; 12 typedef struct 13 { 14 ElemType data[MAXSIZE]; 15 int

数据结构实验之链表五：单链表的拆分

数据结构实验之链表五:单链表的拆分 Time Limit: 1000MS Memory limit: 65536K 题目描述输入N个整数顺序建立一个单链表,将该单链表拆分成两个子链表,第一个子链表存放了所有的偶数,第二个子链表存放了所有的奇数.两个子链表中数据的相对次序与原链表一致. 输入第一行输入整数N;: 第二行依次输入N个整数. 输出第一行分别输出偶数链表与奇数链表的元素个数: 第二行依次输出偶数子链表的所有数据: 第三行依次输出奇数子链表的所有数据. 示例输入 10 1 3 22

数据结构实验之链表四：有序链表的归并

数据结构实验之链表四:有序链表的归并 Time Limit: 1000MS Memory limit: 65536K 题目描述分别输入两个有序的整数序列(分别包含M和N个数据),建立两个有序的单链表,将这两个有序单链表合并成为一个大的有序单链表,并依次输出合并后的单链表数据. 输入第一行输入M与N的值: 第二行依次输入M个有序的整数: 第三行依次输入N个有序的整数. 输出输出合并后的单链表所包含的M+N个有序的整数. 示例输入 6 5 1 23 26 45 66 99 14 21 28 5

顺序链表笔记

数据结构基础最简单的部分顺序链表实际就是个结构体数组代码如下比较简单 1 #include "stdio.h" 2 #include "string.h" 3 #define MAXSIZE 100 4 5 6 7 typedef struct 8 { 9 char key[15]; 10 char name[20]; 11 int age; 12 }DATA; 13 14 15 typedef struct 16 { 17 DATA ListData

【数据结构】用C++实现双链表的各种操作（包括头删，尾删，插入，逆序，摧毁，清空等等）

//[数据结构]用C++实现双链表的各种操作(包括头删,尾删,插入,逆序,摧毁,清空等等) //头文件 #ifndef _LIST_H #define _LIST_H #include<iostream> using namespace std; template<class Type> class DList; template<class Type> class ListNode { friend class DList<Type>; public: L