精华内容
下载资源
问答
  • c++链表的实现

    2016-11-26 12:18:25
    c++链表的实现
  • C++链表的实现

    2019-01-21 12:20:22
    C++的链表与Java链表不太一样,后者有垃圾回收机制,C++需要自己delete节点,以防内存泄露。       头文件 :chain.h #pragma once #include<iostream> using namespace std; template&...

    C++的链表与Java链表不太一样,后者有垃圾回收机制,C++需要自己delete节点,以防内存泄露。
     

     

     

    头文件 :chain.h

    #pragma once
    
    #include<iostream>
    using namespace std;
    template<class  T>
    struct chainNode
    {
    	T element;
    	chainNode<T> *next;
    	chainNode() {};
    	chainNode(const T &element)
    	{
    		this->element = element;
    		this->next = NULL;
    	}
    	chainNode(const T &element, chainNode<T> *next)
    	{
    		this->element = element;
    		this->next = next;
    	}
    };
    
    
    template<class T>
    class chain
    {
    public:
    	chain();
    	~chain();
    	bool empty()const { return listsize == 0; }
    	void insert(int index, const T element);
    
    	void get();
    	void delete_data(T data);
    	void clear();
    	void delete_node_position(int position);
    	int getSize() { return listsize; }
    	void push_back(const T & element);
    protected :
    	int listsize;
    	chainNode<T>  *firstNode;
    private:
    
    };
    template<class T>
    chain<T>::chain()
    {
    	firstNode = NULL;
    	listsize = 0;
    }
    template<class T>
    chain<T>::~chain()
    {
    }
    
    template<class T>
     void chain<T>::insert(const int index,const T element)
    {
    	 if (index > listsize)
    		 cout << "超出范围" << endl;
    	 else
    	 {
    		 if (index == 1)
    		 {
    			 chainNode<T> *p = new chainNode<T>(element, firstNode);
    			 firstNode = p;
    		 }
    		 else {
    			 chainNode<T> *temp = firstNode;
    			 for (int i =1; i < index-1; i++)
    			 {
    				 temp = temp->next;
    			 }
    			 chainNode<T> * target = new chainNode<T>(element, temp->next);
    			 temp->next = target;
    
    		 }
    
    		 listsize++;
    	 }
    }
     template<class T>
     void chain<T> ::delete_data(const T data)
     {
    	 chainNode<T> *temp = firstNode;
    	 if (firstNode->element == data)
    	 {
    		 temp = temp->next;
    		 delete firstNode;
    		 firstNode = temp;
    		 listsize--;
    	 }
    	 while (temp!=NULL)
    	 {
    		 if (temp->next!=NULL&& temp->next->element == data)
    		 {
    			 chainNode<T> *a = temp->next;
    			 temp->next = a->next;
    			 delete a;
    			 listsize--;
    		 }
    		 temp = temp->next;
    		
    	 }
     }
    
    
     template<class  T>
     void chain<T>::delete_node_position (const int position)
     {
    	 chainNode<T> *temp = firstNode;
    	 if (position == 1)
    	 {
    		 temp = firstNode->next;
    		 delete firstNode;
    		 firstNode = temp;
    	 }
    	 else
    	 {
    		  for (int i = 1; i <position-1; i++)
    		 {
    			 temp = temp->next;
    		 }
    		 chainNode<T>* u = temp->next;
    		 temp->next = temp->next->next;
    		 delete u;//一个数组,如果又有一个指针指向他,随后释放,那么数组还存在吗?
    	 }	
     }
    
     template<class  T>
     void chain<T>::clear()
     {
    	 //从头向尾删除链表的所有节点
    	 while (firstNode!=NULL)
    	 {
    		 chainNode<T> *temp = firstNode->next;//终有一次,temp会指向firstNode的后面,NULL
    		 delete firstNode;
    		 firstNode = temp;
    	 }
    	 listsize = 0;
     }
    
    
     template<class T>
     void chain<T>::push_back(const T &element)
     {
    	 chainNode<T> *p = new chainNode<T>(element);
    	 chainNode<T> *current = firstNode;
    	 if (firstNode == NULL)
    	 {
    		 firstNode = p;
    	 }
    	 else
    	 {
    		 while (current ->next!= NULL)
    		 {
    			 current = current->next;
    		 }
    		 current->next = p;
    
    	 }
    	 listsize++;
    
     }
    
     template<class T>
     void chain<T>::get()
     {
    	 chainNode<T> *p = firstNode;
    	 while (p != NULL)
    	 {
    		 cout << p->element << " ";
    		 p = p->next;
    	 }
    	 cout << endl;
     }

     

    main函数

    #include<iostream>
    #include "chain.h"
    using namespace std;
    
    void show() {
    	cout << "链表实验 " << endl;
    	cout << "1.向后插入数据" << endl;
    	cout << "2.在指定位置插入数据" << endl;
    	cout << "3.删除某一位置的数据" << endl;
    	cout << "4.删除指定数据" << endl;
    	cout << "5.显式链表的容量" << endl;
    	cout << "6.删除此链表" << endl;
    	cout << "7.打印此链表" << endl;
    	cout << "8.退出程序" << endl;
    
    }
    void back()
    {
    	string  a;
    	cout << "按确认键返回" << endl;
    	cin.get();
    	cin.get();
    	system("cls");
    	show();
    }
    
    int main()
    {
    	chain<int> curr;
    	int index;
    	show();
    	while (true)
    	{
    		  cout << "请输入操作数";
    		  cin >> index;
    		  switch (index)
    		  {
    			case 1:
    			int nums;
    			cout << "请输入要插入的数据" << endl;
    			cin >> nums;
    			curr.push_back(nums);
    			back();
    			break;
    			case 2:
    				//在指定位置插入数据
    				int  position;
    				cout << "请输入要插入的位置和要插入的数据" << endl;
    				cin >> position >> nums;
    				curr.insert(position, nums);
    				back();
    				break;
    			case 3:
    				//删除某一位置的数据
    				cout << "请输入要删除的位置" << endl;
    				cin >> position;
    				curr.delete_node_position(position);
    				back();
    					
    				break;
    			case 4:
    				//删除指定数据
    				cout << "请输入要删除的数据" << endl;
    				cin >> nums;
    				curr.delete_data(nums);
    				back();
    				
    				break;
    			case 5:
    				//显式链表的容量
    				cout << curr.getSize() << endl;
    				break;
    			case 6:
    				curr.clear();
    				back();
    				//删除这个链表
    				break;
    			case 7:
    				//打印链表
    				curr.get();
    				back();
    				break;
    			case 8:
    				//返回
    				return 0;
    				break;
    		  }	
    	}
    	
    	system("pause");
    }

    这个链表是最简单的一种链表,介绍一下其他的链表:

    ①循环链表:在链表的头部加一个头结点,链表的尾巴连接着头结点。空链表中,只有这么一个空链表。  循环链表的优秀在于查询。直接将数据赋给头结点,从第一个节点开始查询时,如果最终在头结点中查到,那么说明链表中不存在target

    ②双向链表:节点有两个指针,一个指向前方节点,另一个指向后方节点。

    展开全文
  • C++ 链表的实现

    2020-04-04 13:08:03
    public: MyListForward():head(nullptr){} //获得链表中第index个节点值 int get(int index){ int i=0; ListNode *p=head; while(p&&inext; i++; } if(p)return p->val; else return -1; } //在链表头部插一个值...

    #include
    using namespace std;

    class MyListForward
    {
    private:
    struct ListNode
    {
    int val;
    ListNode next;
    ListNode(int x):val(x),next(nullptr){}
    };
    ListNode
    head;
    public:
    MyListForward():head(nullptr){}

    //获得链表中第index个节点的值
    int get(int index){
        int i=0;
        ListNode *p=head;
        while(p&&i<index){
            p=p->next;
            i++;
        }
        if(p)return p->val;
        else return -1;
    }
    
    //在链表头部插一个值为val的节点
    void addAtHead(int val){
        ListNode *p=new ListNode(val);
        p->next=head;
        head=p;//更换头节点
    }
    
    //在链表尾部添加一个值为val的节点
    void addAtTail(int val){
        ListNode *p=new ListNode(val);
        //链表为空,直接将新节点作为头节点
        if(head==nullptr){
            head=p;
            return;
        }
        ListNode *q=head;
        //遍历直到q的next节点为空
        while(q->next){
            q=q->next;
        }
        q->next=p;
    }
    
    //在索引为index的节点之前添加值为val的节点
    void addAtIndex(int index,int val){
        ListNode *node=new ListNode(val);
        //1、index小于等于0,直接在头部插入节点
        if(index<=0)
        {//若index小于等于0,我们仅需要在头节点前面插入新节点就行了
        //注意这里不能使用指针p,因为p=node时,p所指向的地址发生了变化,head指向的地址没有变化,所以我们这里要使用指针head
            node->next=head;
            head=node;
            return;
        }
        int i=0;
        ListNode *p=head;
        //在索引为index的节点之前插入新节点,我们需要找到它的前驱节点,然后插入在它的前驱节点后面
        while(p&&i<index-1)
        {
            p=p->next;
            ++i;
        }
        //2、p为索引节点的前驱节点
        if(p)
        {
            node->next=p->next;
            p->next=node;
        }
    }
    
    //删除索引为index的节点
    void deleteAtIndex(int index){
        //1、index为0,我们直接删除head节点
        if(index==0&&head!=nullptr)
        {
            ListNode *del=head;
            head=head->next;
            delete del;
            return;
        }
        int i=0;
        ListNode* p=head;
        //删除索引为index的节点,我们需要找到它的前驱节点p,p->next为需要删除节点
        while(p&&i<index-1)
        {
            p=p->next;
            i++;
        }
        //2、index超过链表范围,删除失败
        if(!p)return;
        //3、index的位置合法,我们找到需要删除的p->next节点
        if(p->next)
        {
            ListNode *del=p->next;
            p->next=del->next;
            delete del;
        }
    }
    
    int length(){
        int i=0;
        ListNode *p=head;
        while(p){
            i++;
            p=p->next;
        }
        return i;
    }
    

    };

    int main()
    {
    MyListForward mlf;
    mlf.addAtIndex(0,10);
    mlf.addAtIndex(0,20);
    mlf.addAtIndex(1,30);
    for(int i=0;i<mlf.length();++i){
    cout<<mlf.get(i)<<" ";
    }
    cout<<endl;
    system(“pause”);
    }

    展开全文
  • 队列C++链表的实现方式(队列–数据结构) 1.队列的结构 struct Node { ElementType Data; struct Node *Next; }; struct QNode { Node *rear; Node *front; }; typedef struct QNode *Queue; Queue PtrQ; 2.出...

    队列C++链表的实现方式(队列–数据结构)

    1.队列的结构

    struct Node
    {
        ElementType Data;
        struct Node *Next;
    };
    struct QNode
    {
        Node *rear;
        Node *front;
    };
    typedef struct QNode *Queue;
    Queue PtrQ;

    2.出队操作

    ElementType DeleteQ(Queue PtrQ)
    {
        struct Node *FrontCell;
        ElementType FrontElem;
    
        if(PtrQ->front == NULL)
        {
           printf("队列空")return ERROR;
        }
        FrontCell = PtrQ->front;
        if(PtrQ->front == PtrQ->rear )
        {
            PtrQ->front = PtrQ->rear = NULL;
        }
        else
        {
            PtrQ->front = PtrQ->front->Next;
        }
        FrontElem = FrontCell->Data;
        free(FrontCell);
        return FrontElem;
    }

    3.出队操作

    void AddQ(ElementType value)
    {
        struct Node *RearCell;
        RearCell->Data = value;
        PtrQ->rear->next=RearCell;
        PtrQ->rear=RearCell;
    }
    展开全文
  • C++ 链表的实现模板

    2018-12-06 23:41:34
    下面是C++用类实现链表的简单模板,比较简单 #include&lt;iostream&gt; using namespace std; struct Node { int data; struct Node *next; }; class List { public: List(); ~List(); void ...

    下面是C++用类实现链表的简单模板,比较简单

    #include<iostream>
    using namespace std;
    
    struct Node
    {
    	int data;
    	struct Node *next;
    };
    
    class List
    {
    public:
    	List();
    	~List();
    	void inserList(int d);
    	void traverseList();
    	
    private:
    	Node *head;
    };
    
    List::List()
    {
    	head = new Node;
    	head->next = NULL;
    }
    
    List::~List()
    {
    	Node *t = head;
    	while (head)
    	{
    		head = head->next;
    		delete t;
    		t = head;
    	}
    }

     

    展开全文
  • C++链表的实现以及操作

    千次阅读 2018-07-27 16:02:20
    链表的声明: typedef struct node{ int data; node* next; }Node,*PNode;  注意:(1).next是指针域,存放下一个节点的存储位置 (2).使用*PNode可以直接使用PNode p定义指针,不需要每一次都Node*p 链表创建:...
  • c/c++链表的实现

    2019-09-22 14:10:52
    1 #include 2 #include< string ...链表是非常重要的 我们经常会用到,所以...链表的节点数据部分可以是变量,数组,结构体,容器等。   转载于:https://www.cnblogs.com/spring-hailong/p/6183818.html
  • 自己实现链表常见操作,用作记录,以备以后查看#include &lt;iostream&gt; #include &lt;string.h&gt; using namespace std; //定义节点 class Node { public: int m_data; Node *m_next; ...
  • c++链表的实现及栈队列

    千次阅读 2013-12-01 10:51:44
    链表的源代码实现: typedef int T; class List { private: struct Node  {  T data;  Node* next;  Node(const T& t=T()):data(t)  {  next=NULL;  } }; //头节点 Node* head; public: L
  • C++链表倒序实现方法

    2020-09-04 06:18:43
    主要介绍了C++链表倒序实现方法,是一个很经典的C++链表操作实例,需要朋友可以参考下
  • C++链表实现

    2012-10-24 14:22:02
    C++实现的链表 包括 结点类 链表
  • C++链表的高级实现

    2021-02-05 16:34:15
    链表的最大作用是他是一个局部化的结构,一个结构体只需要持有链表中的其中一个节点,就可以对这个节点本身进行插入,删除等操作,新增的结构体也同样只持有新增的节点,便可以进行链表的操作,而不需要持有整个链表...
  • c++链表的实现

    2019-04-10 19:06:16
    c++链表的基本操作(类) 基本功能列表 void InitList(); //初始化 void CreatList(Elemtype a[],int n); //创建 void DestroyList();//销毁 bool ListEmpty();//是否为空 int ListLength(); //长度 bool ...
  • 主要为大家详细介绍了C++链表实现通讯录管理系统,文中示例代码介绍非常详细,具有一定参考价值,感兴趣小伙伴们可以参考一下
  • 回想起大一刚学数据结构的时候确实很害怕去敲代码实现一些操作~于是又重新把一些代码敲了一遍,颇有一些心得体会,写出来和大家分享一下~~这是链表的一些操作的实现C++),包括插入、删除、修改、查找、获取长度、...
  • 废话不多说,本文利用C/C++实现单链表定义及基本操作,如有问题,欢迎指出。链表,顾名思义,就是拿“链子”把数据串联在一起,但与顺序表不同,串联起来数据不必是连续物理地址,而是利用指针进行相连。 例如...
  • C++ 链表实现

    2016-10-11 22:10:00
    #include #include //#include using namespace std; typedef int DataType; typedef struct node ...//链表初始化 .../**初始化链表头部指针需要用二级指针或者一级指针引用**/ voi
  • C++链表实现归并排序

    2019-09-23 23:02:02
    C++ 链表实现的归并排序 首先是定义和创建两个链表用来排序 typedef int ElemType; typedef struct LNode { ElemType data; struct LNode * next; }LinkNode; void CreateListF(LinkNode * &L, ...
  • c++ 链表实现 以及一个很简单学生管理系统实现增删查学生信息作为例子,怎样运用链表
  • C++链表基于类实现多项式加法和乘法; C ++ list class-based polynomial addition and multiplication.
  • 主要介绍了C++ 数据结构链表的实现代码的相关资料,需要的朋友可以参考下
  • c++双向链表的实现

    2010-12-19 18:16:52
    自己写的实现c++双向链表的功能,包括InsertAtHead,Append,RemoveHead,RemoveTail,InsertAfter, DeleteAt,Reset,GetPre,GetNext等函数 压缩包里包含CMyList.h和CMyList.cpp两个文件
  • 虽然现在高级语言在日常开发中可能用不到数据结构,因为语言本身给大家提供了丰富数据存储类型,比如说C#List、Array、Dictionary、Queue等,又比如C++的STL,但是这并不代表我们就不需要去学习数据结构了,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,515
精华内容 2,606
关键字:

c++链表的实现

c++ 订阅