精华内容
下载资源
问答
  • C++链表创建模板

    2019-09-22 10:37:36
    c++ 链表 创建模板

    链表的基本操作要不经大脑思考直接写出

    #include<bits/stdc++.h>
    using namespace std;
    
    typedef struct Node {
    	int data;
    	Node *next;
    }*LinkList;
    
    void creatList(LinkList l1, int length);
    
    int main() {
    	LinkList l1 = new Node;
    	LinkList n=l1;
    	l1->data = -1;
    	l1->next = NULL;//头节点
    	creatList(l1, 4);//创建链表
    	while (n->next) {
    		n = n->next;
    		cout<<n->data<<endl;
    	
    	}
    	delete l1;
    	return 0;
    }
    //创建链表
    void creatList(LinkList l1, int length) {
    	int i = 0;//记录链表长度
    	LinkList p1, p2;
    	p1 = p2 = l1;
    	while (i < length) {
    		p1 = new Node;//创建一个节点
    		p1->data = i+1;
    		p2->next = p1;//节点的移动
    		p2 = p1;
    		i++;
    	}
    	p2->next = NULL;
    }
    
    展开全文
  • c++链表创建与操作

    千次阅读 2015-07-03 08:25:02
    C++ 链表创建与操作   我们知道,数组式计算机根据事先定义好的数组类型长度自动为其分配一连续的存储单

    http://wenku.baidu.com/link?url=c-M72Usj0J_O2CnrFe-bakx4v3FC9ktXlqbUIdSAqLi-wi69bmyABRK65q1RgCrW0isky73HhZnmd3tBrj0ZgrvY_azUnCfNINGx4bvuoI3

    C++

    链表的创建与操作

     

    我们知道,数组式计算机根据事先定义好的数组类型与长度自动为其分配一连续的存储单元,相同数组的

    位置和距离都是固定的,也就是说,任何一个数组元素的地址都可一个简单的公式计算出来,因此这种结

    构可以有效的对数组元素进行随机访问。

    但若对数组元素进行插入和删除操作,

    则会引起大量数据的移动,

    从而使简单的数据处理变得非常复杂,低效。

     

    为了能有效地解决这些问题,一种称为“链表”的数据结构得到了广泛应用。


    C++

    链表的创建与操作

     

    我们知道,数组式计算机根据事先定义好的数组类型与长度自动为其分配一连续的存储单元,相同数组的

    位置和距离都是固定的,也就是说,任何一个数组元素的地址都可一个简单的公式计算出来,因此这种结

    构可以有效的对数组元素进行随机访问。

    但若对数组元素进行插入和删除操作,

    则会引起大量数据的移动,

    从而使简单的数据处理变得非常复杂,低效。

     

    为了能有效地解决这些问题,一种称为“链表”的数据结构得到了广泛应用。


    C++

    链表的创建与操作

     

    我们知道,数组式计算机根据事先定义好的数组类型与长度自动为其分配一连续的存储单元,相同数组的

    位置和距离都是固定的,也就是说,任何一个数组元素的地址都可一个简单的公式计算出来,因此这种结

    构可以有效的对数组元素进行随机访问。

    但若对数组元素进行插入和删除操作,

    则会引起大量数据的移动,

    从而使简单的数据处理变得非常复杂,低效。

     

    为了能有效地解决这些问题,一种称为“链表”的数据结构得到了广泛应用。


    C++链表的创建与操作 
    我们知道,数组式计算机根据事先定义好的数组类型与长度自动为其分配一连续的存储单元,相同数组的位置和距离都是固定的,也就是说,任何一个数组元素的地址都可一个简单的公式计算出来,因此这种结构可以有效的对数组元素进行随机访问。但若对数组元素进行插入和删除操作,则会引起大量数据的移动,从而使简单的数据处理变得非常复杂,低效。 
    为了能有效地解决这些问题,一种称为“链表”的数据结构得到了广泛应用。

    1. 链表概述 
    链表是一种动态数据结构,他的特点是用一组任意的存储单元(可以是连续的,也可以是不连续的)存放数据元素。 
    链表中每一个元素成为“结点”,每一个结点都是由数据域和指针域组成的,每个结点中的指针域指向下一个结点。Head是“头指针”,表示链表的开始,用来指向第一个结点,而最后一个指针的指针域为NULL(空地址),表示链表的结束。 
    可以看出链表结构必须利用指针才能实现,即一个结点中必须包含一个指针变量,用来存放下一个结点的地址。 
    实际上,链表中的每个结点可以用若干个数据和若干个指针。结点中只有一个指针的链表称为单链表,这是最简单的链表结构。

    再c++中实现一个单链表结构比较简单。例如,可定义单链表结构的最简单形式如下


    struct Node
    { 
    <span style="white-space:pre">	</span>int Data;
            Node *next; 
    }; 

    这里用到了结构体类型。其中,

    *next

    是指针域,用来指向该结点的下一个结点;

    Data

    是一个整形变量,用

    来存放结点中的数据。当然,

    Data

    可以是任何数据类型,包括结构体类型或类类型。

     

    在此基础上,我们在定义一个链表类

    list

    ,其中包含链表结点的插入,删除,输出等功能的成员函数。

    这里用到了结构体类型。其中,

    *next

    是指针域,用来指向该结点的下一个结点;

    Data

    是一个整形变量,用

    来存放结点中的数据。当然,

    Data

    可以是任何数据类型,包括结构体类型或类类型。

     

    在此基础上,我们在定义一个链表类

    list

    ,其中包含链表结点的插入,删除,输出等功能的成员函数。


    这里用到了结构体类型。其中,*next是指针域,用来指向该结点的下一个结点;Data是一个整形变量,用来存放结点中的数据。当然,Data可以是任何数据类型,包括结构体类型或类类型。 
    在此基础上,我们在定义一个链表类list,其中包含链表结点的插入,删除,输出等功能的成员函数

    lass list
    { 
    <span style="white-space:pre">	</span>Node *head; public: 
    <span style="white-space:pre">	</span>list(){head=NULL;} 
    <span style="white-space:pre">	</span>void insertlist(int aDate,int bDate); //链表结点的插入
    <span style="white-space:pre">	</span>void Deletelist(int aDate); //链表结点的删除 
    <span style="white-space:pre">	</span>void Outputlist(); //链表结点的输出 
    <span style="white-space:pre">	</span>Node*Gethead(){return head;} 
    }; 
    2.链表结点的访问 
    由于链表中的各个结点是由指针链接在一起的,其存储单元文笔是连续的,因此,对其中任意结点的地址无法向数组一样,用一个简单的公式计算出来,进行随机访问。只能从链表的头指针(即head)开始,用一个指针p先指向第一个结点,然后根据结点p找到下一个结点。

    以此类推,直至找到所要访问的结点或到最后一个结点(指针为空)为止。 下面我们给出上述链表的输出函数;

    void list::Outputlist()
    { 
    <span style="white-space:pre">	</span>Node *current = head; 
    <span style="white-space: pre;">	</span>while(current != NULL)
    <span style="white-space:pre">	</span>{ 
    <span style="white-space:pre">		</span>cout << current->Data << " "; 
    <span style="white-space:pre">		</span>current = current->next; 
    <span style="white-space:pre">	</span>} 
    <span style="white-space:pre">	</span>cout<<endl;
    }
    3.链表结点的插入 
    如果要在链表中的结点a之前插入结点b,则需要考虑下面几点情况。 

    (1) 插入前链表是一个空表,这时插入新结点b后。 
    (2) 若a是链表的第一个结点,则插入后,结点b为第一个结点。 
    (3) 若链表中存在a,且不是第一个结点,则首先要找出a的上一个结点a_k,然后使a_k的指针域指向b,在令b的指针域指向a,即可完成插入。 
    (4) 如链表中不存在a,则插在最后。先找到链表的最后一个结点a_n,然后使a_n的指针域指向结点b,而b指针的指针为空。
    以下是链表类的结点插入函数,显然其也具有建立链表的功能。

    void list::insertlist(int aDate,int bDate) //设aDate是结点a中的数据,bDate是结点b中的数据 
    { 
    <span style="white-space:pre">	</span>Node *p,*q,*s; //p指向结点a,q指向结点a_k,s指向结点b 
    <span style="white-space:pre">	</span>s=(Node*)new(Node); //动态分配一个新结点
    <span style="white-space:pre">	</span>s->Data=bDate; //设b为此结点
      <span style="white-space:pre">	</span>p=head; 
    <span style="white-space:pre">	</span>if(head==NULL) 
    <span style="white-space:pre">	</span>{//若是空表,使b作为第一个结点 
    <span style="white-space:pre">		</span>head=s; 
    <span style="white-space:pre">		</span>s->next=NULL; 
    <span style="white-space:pre">	</span>} 
    <span style="white-space:pre">	</span>else
    <span style="white-space:pre">	</span>{ 
    <span style="white-space:pre">		</span>if(p->Data==aDate)
    <span style="white-space:pre">		</span>{ //若a是第一个结点 
    <span style="white-space:pre">			</span>s->next = p; 
    <span style="white-space:pre">			</span>head = s; 
    <span style="white-space:pre">		</span>}
    <span style="white-space:pre">		</span>else
    <span style="white-space:pre">		</span>{ 
    <span style="white-space:pre">			</span>while(p->Data != aDate && p->next != NULL) 
    <span style="white-space:pre">			</span>{//查找结点a 
    <span style="white-space:pre">				</span>q=p; p=p->next; 
    <span style="white-space:pre">			</span>} 
    <span style="white-space:pre">			</span>if(p->Data == aDate) 
    <span style="white-space:pre">			</span>{//若有结点a 
    <span style="white-space:pre">				</span>q->next = s; 
    <span style="white-space:pre">				</span>s->next=p;  
    <span style="white-space:pre">			</span>} 
    <span style="white-space:pre">			</span>else
    <span style="white-space:pre">			</span>{ //若没有结点a 
    <span style="white-space:pre">				</span>p->next = s; 
    <span style="white-space:pre">				</span>s->next = NULL; 
    <span style="white-space:pre">			</span>} 
    <span style="white-space:pre">		</span>} 
    <span style="white-space:pre">	</span>} 

    4.链表结点的删除 
    如果要在链表中删除结点a并释放被删除的结点所占的存储空间,则需要考虑下列几种情况。 

    (1) 若要删除的结点a是第一个结点,则把head指向a的下一个结点。 
    (2) 若要删除的结点a存在于链表中,但不是第一个结点,则应使a得上一个结点a_k-1的指针域指向a的下一个结点a_k+1。

    void list::deletelist(int aDate) 
    {//设aDate是要删除的结点a中的数据成员 
    <span style="white-space:pre">	</span>Node *p,*q; //p用于指向结点a,q用于指向结a的前一个结点 
    <span style="white-space:pre">	</span>p = head; 
    <span style="white-space:pre">	</span>if(p==NULL) 
    <span style="white-space:pre">	</span>{ //若是空表 
    <span style="white-space:pre">		</span>return; 
    <span style="white-space:pre">	</span>} 
    <span style="white-space:pre">	</span>if(p->Data==aDate) 
    <span style="white-space:pre">	</span>{ //若a是第一个结点 
    <span style="white-space:pre">		</span>head = p->next; 
    <span style="white-space:pre">		</span>delete p; 
    <span style="white-space:pre">	</span>}
    <span style="white-space:pre">	</span>else
    <span style="white-space:pre">	</span>{ 
    <span style="white-space:pre">		</span>while( p->Data != aDate && p->next != NULL) 
    <span style="white-space:pre">		</span>{ //查找结点a 
    <span style="white-space:pre">			</span>q = p; 
    <span style="white-space:pre">			</span>p = p->next; 
    <span style="white-space:pre">		</span>} 
    <span style="white-space:pre">		</span>if(p->Data == aDate) 
    <span style="white-space:pre">		</span>{ //若有结点a 
    <span style="white-space:pre">			</span>q->next=p->next; delete p; 
    <span style="white-space:pre">		</span>} 
    <span style="white-space:pre">	</span>} 

    例题:利用以上三个链表操作成员函数insertlist,deletelist,outputlist可形成以下的简单链表操作程序。

    #include"iostream.h" 
    struct Node
    {<span style="font-family: Arial, Helvetica, sans-serif;"> </span>
    <span style="white-space:pre">	</span>int Data; 
    <span style="white-space:pre">	</span>Node<span style="white-space:pre">	</span>*next; 
    }; 
    class list
    { 
    <span style="white-space:pre">	</span>Node<span style="white-space:pre">	</span>*head; 
    public: 
    <span style="white-space:pre">	</span>list(){<span style="white-space:pre">	</span>head=NULL;} 
    <span style="white-space:pre">	</span>void insertlist(int aData,int bData); 
    <span style="white-space:pre">	</span>void deletelist(int aData); 
    <span style="white-space:pre">	</span>void outputlist(); 
    <span style="white-space:pre">	</span>Node*gethead(){return head;} 
    };

    void list::insertlist(int aData,int bData) 
    {//设aData是结点a中的数据,bData是结点b中的数据 
    <span style="white-space:pre">	</span>Node *p,*q,*s;<span style="white-space:pre">		</span> //p指向结点a,q指向结点a_k,s指向结点b 
    <span style="white-space:pre">	</span>s=(Node*)new(Node);<span style="white-space:pre">	</span> <span style="font-family: Arial, Helvetica, sans-serif;">//动态分配一个新结点</span>
    <span style="font-family: Arial, Helvetica, sans-serif;"><span style="white-space:pre">		</span> s->Data=bData; <span style="white-space:pre">			</span>//设b为此结点 p=head; </span>
    <span style="white-space:pre">	</span>if(head==NULL) 
    <span style="white-space:pre">	</span>{ //若是空表,使b作为第一个结点
    <span style="white-space:pre">		</span>head=s; s->next=NULL; 
    <span style="white-space:pre">	</span>}
    <span style="white-space:pre">	</span>else{ 
    <span style="white-space:pre">		</span>if(p->Data==aData) 
    <span style="white-space:pre">		</span>{ //若a是第一个结点 
    <span style="white-space:pre">			</span>s->next=p; head=s; 
    <span style="white-space:pre">		</span>}
    <span style="white-space:pre">		</span>else
    <span style="white-space:pre">		</span>{ 
    <span style="white-space:pre">			</span>while(p->Data!=aData && p->next!=NULL) 
    <span style="white-space:pre">			</span>{//查找结点a 
    <span style="white-space:pre">				</span>q=p; p=p->next; 
    <span style="white-space:pre">			</span>} 
    <span style="white-space:pre">			</span>if(p->Data==aData) 
    <span style="white-space:pre">			</span>{//若有结点a 
    <span style="white-space:pre">				</span>q->next=s; s->next=p; 
    <span style="white-space:pre">			</span>}
    <span style="white-space:pre">			</span>else
    <span style="white-space:pre">			</span>{ //若没有结点a; 
    <span style="white-space:pre">				</span>p->next=s; 
    <span style="white-space:pre">				</span>s->next=NULL; 
    <span style="white-space:pre">			</span>} 
    <span style="white-space:pre">		</span>} 
    <span style="white-space:pre">	</span>} 
    }
    
    void list::deletelist(int aData) 
    { //设aData是要删除的结点a中的数据成员 <span style="white-space:pre">	</span>
    <span style="white-space:pre">	</span>Node<span style="white-space:pre">	</span>*p,*q; //p用于指向结点a,q用于指向结a的前一个结点 
    <span style="white-space:pre">	</span>p=head; 
    <span style="white-space:pre">	</span>if(p==NULL) //若是空表 
    <span style="white-space:pre">		</span>return; 
    <span style="white-space:pre">	</span>if(p->Data==aData) 
    <span style="white-space:pre">	</span>{//若a是第一个结点 
    <span style="white-space:pre">		</span>head=p->next; delete p; 
    <span style="white-space:pre">	</span>}
    <span style="white-space:pre">	</span>else
    <span style="white-space:pre">	</span>{ 
    <span style="white-space:pre">		</span>while(p->Data != aData && p->next != NULL) 
    <span style="white-space:pre">		</span>{//查找结点a 
    <span style="white-space:pre">			</span>q=p; p=p->next; 
    <span style="white-space:pre">		</span>} 
    <span style="white-space:pre">		</span>if(p->Data==aData) 
    <span style="white-space:pre">		</span>{//若有结点a 
    <span style="white-space:pre">			</span>q->next=p->next; delete p; 
    <span style="white-space:pre">		</span>} 
    <span style="white-space:pre">	</span>} 
    } 
    

    void list::outputlist()
    { 
    <span style="white-space:pre">	</span>Node<span style="white-space:pre">	</span>*current=head; 
    <span style="white-space:pre">	</span>while(current!=NULL)
    <span style="white-space:pre">	</span>{ 
    <span style="white-space:pre">		</span>cout<<current->Data<<" "; 
    
    <span style="white-space:pre">		</span>current=current->next; 
    <span style="white-space:pre">	</span>} 
    <span style="white-space:pre">	</span>cout<<endl; 
    }
    

    void main()
    { 
    <span style="white-space:pre">	</span>list A, B; 
    <span style="white-space:pre">	</span>int Data[10]={25,41,16,98,5,67,9,55,1,121}; 
    <span style="white-space:pre">	</span>A.insertlist(0,Data[0]); //建立链表A首结点 
    <span style="white-space:pre">	</span>for(int i=1;i<10;i++)
    <span style="white-space:pre">	</span>{ 
    <span style="white-space:pre">		</span>A.insertlist(0,Data[i]); //顺序向后插入 
    <span style="white-space:pre">	</span>} 
    <span style="white-space:pre">	</span>cout<<"/n链表A:"; 
    <span style="white-space:pre">	</span>A.outputlist(); 
    <span style="white-space:pre">	</span>A.deletelist(Data[7]); 
    <span style="white-space:pre">	</span>cout<<"删除元素Data[7]后"; 
    <span style="white-space:pre">	</span>A.outputlist(); 
    <span style="white-space:pre">	</span>B.insertlist(0,Data[0]); //建立链表B首结点 
    <span style="white-space:pre">	</span>for(i=0;i<10;i++)
    <span style="white-space:pre">	</span>{ 
    <span style="white-space:pre">		</span>B.insertlist(B.gethead()->Data,Data[i]); //在首结点处顺序向后插入 
    <span style="white-space:pre">	</span>} 
    <span style="white-space:pre">	</span>cout<<"/n链表B:"; 
    <span style="white-space:pre">	</span>B.outputlist(); 
    <span style="white-space:pre">	</span>B.deletelist(67); 
    <span style="white-space:pre">	</span>cout<<"删除元素67后"; 
    <span style="white-space:pre">	</span>B.outputlist(); 
    }
    程序运行结果为 
    链表A:25,41,16,98,5,67,9,55,1,121 删除元素Data[7]后; 
    25,41,16,98,5,67,9,1,121 
    链表B;121,1,55,9,67,5,98,16,41,25, 删除元素67后; 
    121,1,55,9,5,98,16,41,25,








    展开全文
  • C++链表创建与操作

    千次阅读 2014-05-26 23:32:39
    数组式计算机根据事先定义好的数组类型长度自动为其分配一连续的存储单元,相同数组的位置和距离都是固定的,也就是说,任何一个数组元素的地址都可一个简单的公式计算出来,因此这种结构可以有效的对数组元素进行...

    数组式计算机根据事先定义好的数组类型与长度自动为其分配一连续的存储单元,相同数组的位置和距离都是固定的,也就是说,任何一个数组元素的地址都可一个简单的公式计算出来,因此这种结构可以有效的对数组元素进行随机访问。但若对数组元素进行插入和删除操作,则会引起大量数据的移动,从而使简单的数据处理变得非常复杂,低效。
    为了能有效地解决这些问题,一种称为链表的数据结构得到了广泛应用。

    1. 链表概述

    链表是一种动态数据结构,他的特点是用一组任意的存储单元(可以是连续的,也可以是不连续的)存放数据元素。
    链表中每一个元素成为结点,每一个结点都是由数据域和指针域组成的,每个结点中的指针域指向下一个结点。Head头指针,表示链表的开始,用来指向第一个结点,而最后一个指针的指针域为NULL(空地址),表示链表的结束。
    可以看出链表结构必须利用指针才能实现,即一个结点中必须包含一个指针变量,用来存放下一个结点的地址。
    实际上,链表中的每个结点可以用若干个数据和若干个指针。结点中只有一个指针的链表称为单链表,这是最简单的链表结构。
    c++中实现一个单链表结构比较简单。例如,可定义单链表结构的最简单形式如下
    struct Node
    {
    int Data;
    Node*next;
    };
    这里用到了结构体类型。其中,*next是指针域,用来指向该结点的下一个结点;Data是一个整形变量,用来存放结点中的数据。当然,Data可以是任何数据类型,包括结构体类型或类类型。
    在此基础上,我们在定义一个链表类list,其中包含链表结点的插入,删除,输出等功能的成员函数。
    class list
    {
    Node*head;
    public:
    list(){head=NULL;}
    void insertlist(int aDate,int bDate);//链表结点的插入
    void Deletelist(int aDate);//链表结点的删除
    void Outputlist();//链表结点的输出
    Node*Gethead(){return head;}
    };

    2. 链表结点的访问

    由于链表中的各个结点是由指针链接在一起的,其存储单元是连续的,因此,对其中任意结点的地址无法向数组一样,用一个简单的公式计算出来,进行随机访问。只能从链表的头指针(即head)开始,用一个指针p先指向第一个结点,然后根据结点p找到下一个结点。以此类推,直至找到所要访问的结点或到最后一个结点(指针为空)为止。
    下面我们给出上述链表的输出函数;
    void list::outputlist()
    {
    Node*current=head;
    while(current!=NULL)
    {
    cout<<current->Data<<" ";
    current=current->next;
    }
    cout<<endl;
    }

    3. 链表结点的插入

    如果要在链表中的结点a之前插入结点b,则需要考虑下面几点情况。
    1) 插入前链表是一个空表,这时插入新结点b后。
    2) 若a是链表的第一个结点,则插入后,结点b为第一个结点。
    3) 若链表中存在a,且不是第一个结点,则首先要找出a的上一个结点a_k,然后使a_k的指针域指向b,在令b的指针域指向a,即可完成插入。
    4) 如链表中不存在a,则插在最后。先找到链表的最后一个结点a_n,然后使a_n的指针域指向结点b,而b指针的指针为空。
    以下是链表类的结点插入函数,显然其也具有建立链表的功能。
    void list::insertlist(int aDate,int bDate) //设aDate是结点a中的数据,bDate是结点b中的数据
    {
           Node*p,*q,*s; //p指向结点a,q指向结点a_k,s指向结点b
           s=(Node*)new(Node); //动态分配一个新结点
           s->Data=bDate; //设b为此结点 
           p=head;
          if(head==NULL) //若是空表,使b作为第一个结点
            {
                head=s;
                s->next=NULL; 
             }
           else
                if(p->Data==aDate) //若a是第一个结点
                   {
                      s->next=p;
                      head=s; 
                   }
                else
                  {
                      while(p->Data!=aDate&&p->next!=NULL)//查找结点a
                        {
                                q=p;
                                 p=p->next;
                         }
                       if(p->Data==aDate) ///若有结点a
                        {
                              q->next=s;
                               s->next=p; 
                         } 
                         else //若没有结点a;
                       {
                              p->next=s;
                               s->next=NULL; 
                        }
                 }
    }

    4. 链表结点的删除

    如果要在链表中删除结点a并释放被删除的结点所占的存储空间,则需要考虑下列几种情况。
    1) 若要删除的结点a是第一个结点,则把head指向a的下一个结点。
    2) 若要删除的结点a存在于链表中,但不是第一个结点,则应使a得上一个结点a_k-1的指针域指向a的下一个结点a_k+1
    3) 空表或要删除的结点a不存在,则不做任何改变。
    以下是链表类的结点删除函数。
    void list::deletelist(int aDate) //设aDate是要删除的结点a中的数据成员
    {
    Node*p,*q; //p用于指向结点a,q用于指向结a的前一个结点
    p=head;
    if(p==NULL) //若是空表
    return;
    if(p->Data==aDate) //若a是第一个结点
    {
    head=p->next;
    delete p;
    }
    else
    {
    while(p->Data!=aDate&&p->next!=NULL) //查找结点a
    {
    q=p;
    p=p->next;
    }
    if(p->Data==aDate) //若有结点a
    {
    q->next=p->next;
    delete p;
    }
    }
    }



    展开全文
  • C++链表创建与操作 我们知道,数组式计算机根据事先定义好的数组类型长度自动为其分配一连续的存储单元,相同数组的位置和距离都是固定的,也就是说,任何一个数组元素的地址都可一个简单的公式计算出来,因此...

    C++链表的创建与操作

    我们知道,数组式计算机根据事先定义好的数组类型与长度自动为其分配一连续的存储单元,相同数组的位置和距离都是固定的,也就是说,任何一个数组元素的地址都可一个简单的公式计算出来,因此这种结构可以有效的对数组元素进行随机访问。但若对数组元素进行插入和删除操作,则会引起大量数据的移动,从而使简单的数据处理变得非常复杂,低效。

    为了能有效地解决这些问题,一种称为“链表”的数据结构得到了广泛应用。

    链表概述

    链表是一种动态数据结构,他的特点是用一组任意的存储单元(可以是连续的,也可以是不连续的)存放数据元素。

    链表中每一个元素成为“结点”,每一个结点都是由数据域和指针域组成的,每个结点中的指针域指向下一个结点。Head是“头指针”,表示链表的开始,用来指向第一个结点,而最后一个指针的指针域为NULL(空地址),表示链表的结束。

    可以看出链表结构必须利用指针才能实现,即一个结点中必须包含一个指针变量,用来存放下一个结点的地址。

    实际上,链表中的每个结点可以用若干个数据和若干个指针。结点中只有一个指针的链表称为单链表,这是最简单的链表结构。

    再c++中实现一个单链表结构比较简单。例如,可定义单链表结构的最简单形式如下

    structNode{
    int Data;
    Node *next;
    };


    这里用到了结构体类型。其中,*next是指针域,用来指向该结点的下一个结点;Data是一个整形变量,用来存放结点中的数据。当然,Data可以是任何数据类型,包括结构体类型或类类型。

    在此基础上,我们在定义一个链表类list,其中包含链表结点的插入,删除,输出等功能的成员函数。

    classlist{
    Node *head;
    public:
    list(){head=NULL;}
    void insertlist(int aDate,int bDate); //链表结点的插入
    void Deletelist(int aDate); //链表结点的删除
    void Outputlist(); //链表结点的输出
    Node*Gethead(){return head;}
    };


    链表结点的访问

    由于链表中的各个结点是由指针链接在一起的,其存储单元文笔是连续的,因此,对其中任意结点的地址无法向数组一样,用一个简单的公式计算出来,进行随机访问。只能从链表的头指针(即head)开始,用一个指针p先指向第一个结点,然后根据结点p找到下一个结点。以此类推,直至找到所要访问的结点或到最后一个结点(指针为空)为止。

    下面我们给出上述链表的输出函数;

    voidlist::Outputlist(){
    Node *current = head;
    while(current != NULL){
    cout << current->Data <<" ";
    current = current->next;
    }
    cout<<endl;
    }


    链表节点的插入

    如果要在链表中的结点a之前插入结点b,则需要考虑下面几点情况。

    (1) 插入前链表是一个空表,这时插入新结点b后。

    (2) 若a是链表的第一个结点,则插入后,结点b为第一个结点。

    (3) 若链表中存在a,且不是第一个结点,则首先要找出a的上一个结点a_k,然后使a_k的指针域指向b,在令b的指针域指向a,即可完成插入。

    (4) 如链表中不存在a,则插在最后。先找到链表的最后一个结点a_n,然后使a_n的指针域指向结点b,而b指针的指针为空。

    以下是链表类的结点插入函数,显然其也具有建立链表的功能。

    voidlist::insertlist(int aDate,int bDate) //设aDate是结点a中的数据,bDate是结点b中的数据
    {
    Node *p,*q,*s; //p指向结点a,q指向结点a_k,s指向结点b
    s=(Node*)new(Node); //动态分配一个新结点
    s->Data=bDate; //设b为此结点
    p=head;
    if(head==NULL) {//若是空表,使b作为第一个结点
    head=s;
    s->next=NULL;
    } else{
    if(p->Data==aDate){ //若a是第一个结点
    s->next = p;
    head = s;
    }else{
    while(p->Data != aDate &&p->next != NULL) {//查找结点a
    q=p;
    p=p->next;
    }
    if(p->Data == aDate) {//若有结点a
    q->next = s;
    s->next=p;
    } else{ //若没有结点a
    p->next = s;
    s->next = NULL;
    }
    }
    }
    }

    链表节点的删除

    如果要在链表中删除结点a并释放被删除的结点所占的存储空间,则需要考虑下列几种情况。

    (1) 若要删除的结点a是第一个结点,则把head指向a的下一个结点。

    (2) 若要删除的结点a存在于链表中,但不是第一个结点,则应使a得上一个结点a_k-1的指针域指向a的下一个结点a_k+1。

    (3) 空表或要删除的结点a不存在,则不做任何改变。

    以下是链表类的结点删除函数。

    voidlist::deletelist(int aDate) {//设aDate是要删除的结点a中的数据成员
    Node *p,*q; //p用于指向结点a,q用于指向结a的前一个结点
    p = head;
    if(p==NULL) { //若是空表
    return;
    }
    if(p->Data==aDate) { //若a是第一个结点
    head = p->next;
    delete p;
    }else{
    while( p->Data != aDate &&p->next != NULL) { //查找结点a
    q = p;
    p = p->next;
    }
    if(p->Data == aDate) { //若有结点a
    q->next=p->next;
    delete p;
    }
    }
    }

    voidlist::deletelist(int aDate) {//aDate是要删除的结点a中的数据成员

    Node *p,*q; //p用于指向结点a,q用于指向结a的前一个结点

    p = head;

    if(p==NULL) { //若是空表

    return;

    }

    if(p->Data==aDate) { //a是第一个结点

    head = p->next;

    delete p;

    }else{

    while( p->Data != aDate &&p->next != NULL) { //查找结点a

    q = p;

    p = p->next;

    }

    if(p->Data == aDate) { //若有结点a

    q->next=p->next;

    delete p;

    }

    }

    }

    例题:利用以上三个链表操作成员函数insertlist,deletelist,outputlist可形成以下的简单链表操作程序。

    #include"iostream.h"
    structNode{
    int Data;
    Node*next;
    };
    classlist{
    Node*head;
    public:
    list(){head=NULL;}
    void insertlist(int aData,int bData);
    void deletelist(int aData);
    void outputlist();
    Node*gethead(){return head;}
    };
    voidlist::insertlist(int aData,int bData) {//设aData是结点a中的数据,bData是结点b中的数据
    Node *p,*q,*s; //p指向结点a,q指向结点a_k,s指向结点b
    s=(Node*)new(Node); //动态分配一个新结点
    s->Data=bData; //设b为此结点
    p=head;
    if(head==NULL) { //若是空表,使b作为第一个结点
    head=s;
    s->next=NULL;
    }else{
    if(p->Data==aData) { //若a是第一个结点
    s->next=p;
    head=s;
    }else{
    while(p->Data!=aData &&p->next!=NULL) {//查找结点a
    q=p;
    p=p->next;
    }
    if(p->Data==aData) {//若有结点a
    q->next=s;
    s->next=p;
    }else{ //若没有结点a;
    p->next=s;
    s->next=NULL;
    }
    }
    }
    }
    voidlist::deletelist(int aData) { //设aData是要删除的结点a中的数据成员
    Node*p,*q; //p用于指向结点a,q用于指向结a的前一个结点
    p=head;
    if(p==NULL) //若是空表
    return;
    if(p->Data==aData) {//若a是第一个结点
    head=p->next;
    delete p;
    }else{
    while(p->Data!=aData&&p->next!=NULL){//查找结点a
    q=p;
    p=p->next;
    }
    if(p->Data==aData) {//若有结点a
    q->next=p->next;
    delete p;
    }
    }
    }
    voidlist::outputlist(){
    Node*current=head;
    while(current!=NULL){
    cout<<current->Data<<"";
    current=current->next;
    }
    cout<<endl;
    }
    voidmain(){
    list A, B;
    int Data[10]={25,41,16,98,5,67,9,55,1,121};
    A.insertlist(0,Data[0]); //建立链表A首结点
    for(int i=1;i<10;i++){
    A.insertlist(0,Data[i]); //顺序向后插入
    }
    cout<<"/n链表A:";
    A.outputlist();
    A.deletelist(Data[7]);
    cout<<"删除元素Data[7]后";
    A.outputlist();
    B.insertlist(0,Data[0]); //建立链表B首结点
    for(i=0;i<10;i++){
    B.insertlist(B.gethead()->Data,Data[i]);//在首结点处顺序向后插入
    }
    cout<<"/n链表B:";
    B.outputlist();
    B.deletelist(67);
    cout<<"删除元素67后";
    B.outputlist();
    }

    程序运行结果为

    链表A:25,41,16,98,5,67,9,55,1,121

    删除元素Data[7]后;

    25,41,16,98,5,67,9,1,121

    链表B;121,1,55,9,67,5,98,16,41,25,

    删除元素67后;

    121,1,55,9,5,98,16,41,25,

     

    下面是杨辉三角的代码:

    #include<iostream>
    #include<iomanip>
    using namespacestd;
    int main(){
    const int n=11;
    int i,j,a[n][n];
    for(i=1;i<n;i++){
    a[i][i]=1;
    a[i][1]=1;
    }
    for(i=3;i<n;i++){
    for(j=2;j<=i-1;j++)
    a[i][j]=a[i-1][j-1]+a[i-1][j];
    }
    for(i=1;i<n;i++){
    for(j=1;j<=i;j++)
    cout<<setw(5)<<a[i][j]<<"";
    cout<<endl;
    }
    cout<<endl;
    return 0;
    }


    展开全文
  • c++链表的基本操作

    2014-03-12 22:14:32
    C++链表的基本操作,实现带头节点创建,插入,显示等功能
  • C++ 链表类 基本操作

    2016-11-25 02:28:03
    C++构建链表类,并实现基本操作:删除,创建,显示全部,插入。。。
  • C++ 链表的基本操作

    2019-03-08 16:51:02
    本文介绍C++链表的基本操作,包括:链表创建、显示、查询、插入、删除。 #include "stdafx.h" #include "iostream"; using namespace std; struct node { char data; node *next; }; ...
  • C++ 链表操作大全

    2011-03-30 17:35:15
    C++链表操作大全:如何创建链表,删除节点,添加节点等
  • c++创建链表

    2014-11-17 20:16:38
    创建链表基本操作,c++中的链表的基本操作均有涉及,是初学者的最佳参考
  • 学习数据结构重要的知识,链表创建操作,简单易学。
  • c++ 链表创建 代码及详细解释

    千次阅读 多人点赞 2020-05-06 12:36:32
    c++链表(详解版) c++链表 首先我们得明白几个概念: 指针 int num = 7; int* p=&num ;//假设地址为0x123456 cout << p << endl; cout << *p << endl; 输出: 123456 7 使用时 ...
  • C++链表基本操作大全

    2010-03-23 05:45:41
    C++链表基本(创建、插入、删除、释放)
  • C++链表基本操作

    千次阅读 2010-10-13 13:29:00
    C++链表基本操作
  • c++链表(详解版)

    万次阅读 多人点赞 2019-06-13 16:27:57
    在自学C++的时候,看到好多人都在提链表,于是就自学了一下,看了很多别人的文章,加入了一些自己的理解,做了一下总结
  • C++链表创建操作 #include <iostream> #include <vector> using namespace std; struct ListNode { int val; struct ListNode *next; ListNode(int x) :val(x), next(NULL) {} }; vector<int...
  • c++链表基本操作

    2018-11-18 20:16:26
    这篇博客主要讲述了用c++实现单链表的一些基本操作,主要实现了包括单链表的创建,打印链表,获取链表长度,在链表的第i个节点处插入值为e的节点,删除第i个节点,获取第i个节点的数据,在链表中搜索数据的功能。...
  • C++实现链表基本操作

    万次阅读 多人点赞 2016-01-10 21:56:57
    前几天找实习的时候,一个面试官给我留了一个题,做一个链表demo,要求实现创建、插入、删除等操作链表是一种常见的数据结构,它是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中...
  • #include <iostream> using namespace std;...//链表结点 class node { public: int data; node *next; //指向同类型的指针 }; void create(node *phead) { node *p = phead; for (int i = 1; i &...
  • c++链表操作

    千次阅读 2012-04-08 15:30:29
    //创建链表 boolEmpty()const; //判断链表是否为空 voidInsertLast(constT e); //从尾部插入一个元素 voidInsertFirst(constT e); //从头部插入一个元素 voidDeleteFirst(); //从头删除一个元素 voidDeleteLast(); ...
  • C++链表操作总结和常见链表操作

    千次阅读 多人点赞 2017-02-26 21:13:34
    链表是一种动态数据结构,他的特点是用一组任意的存储单元(可以是连续的,也可以是不连续的)存放数据元素。链表中每一个元素成为“结点”,每一个结点都是由数据域和指针域组成的,每个结点中的指针域指向下一个...
  • 下面是LinkList.h文件,包含链表的基本函数#include #include"malloc.h" #include"Node.h" #include #include using namespace std;template class LinkList { friend ostream& oper
  • c++链表创建使用

    万次阅读 多人点赞 2016-08-15 16:46:51
    我们知道,数组式计算机根据事先定义好的数组类型长度自动为其分配一连续的存储单元,相同数组的位置和距离都是固定的,也就是说,任何一个数组元素的地址都可一个简单的公式计算出来,因此这种结构可以有效的对数...
  • C++简洁的链表创建

    2019-02-26 20:45:00
    C++创建链表和链表基本操作 简单的链表实现,包括创建打印,记录下来,防止以后忘了,往往基础的东西最重要又最易被人忽视。 https://mintlucas.github.io/2019/02/26/C-简洁的链表创建/ 注意形参传递,在create...
  • c++链表的基本入门操作和练习

    千次阅读 2020-03-13 17:43:07
    单链表的基本操作 c++提供了list容器,能够完成插入,删除...1.链表创建 2.链表的遍历 3.链表元素的查找删除 4.链表的插入 5.反转链表 6.链表的长度 #include<iostream> using namespace std; //***定义...
  • 使用C++创建链表一直是很头疼的事,创建链表为了后面的操作方便,我们需要返回头指针,有了头指针就可以做后面的操作了,比如显示列表,增删改查等等,在create函数里首先申明两个指针,一个是用来保存上一个节点的...
  • C++链表的实现以及操作

    千次阅读 2018-07-27 16:02:20
    链表的声明: typedef struct node{ int data; node* next; }Node,*PNode; ... 注意:(1).next是指针域,存放下一个节点的存储位置 ...链表创建: PNode creat(){ int len; int value; PNode PHea...
  • C++ 详解创建链表过程

    万次阅读 多人点赞 2018-07-21 13:06:14
    由于清华大学出版社《C++数据结构算法》书上并没有给出创建链表的方法,因此在网上查找相关代码,感谢此篇博客https://blog.csdn.net/chixujohnny/article/details/50900504提供相关思路。但对于其中的思想博主并...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 57,196
精华内容 22,878
关键字:

c++链表的创建与操作

c++ 订阅