c++实现链表

之前在学c的时候以c的版本谢了有关链表的最基础的几个函数，最近在学习C++，所以，，，哈哈就用另一种版本再次呈现给大家；

感觉c++好像写起来比较简单一些。因为它有结构体，所以没有那么繁琐；

cpp.h

#pragma once

#include<iostream>

using namespace std;

typedef int DataType;

struct Node

{

DataType _data;

struct Node * _next;

Node(const DataType &d)

:_data(d)

,_next(NULL)

{

}

};

class Slist

{

friend ostream & operator<<(ostream &os,Slist &s);

public:

//构造链表

Slist()

:_head(NULL)

,_tail(NULL)

{

}

~Slist()

{

if(_head==NULL)

{

return ;

}

Node *cur=_head;

while(cur!=NULL)

{

Node *del=cur;

cur=cur->_next;

delete del;

}

delete cur;

_head=NULL;

_tail=NULL;

}

Slist(const Slist &s)

:_head(NULL)

,_tail(NULL)

{

Node *cur=_head;

while(cur)

{

pushback(cur->_data);

cur=cur->_next;

}

}

public:

void pushback(const DataType &d);

void popback();

void pushfront(const DataType &d);

void popfront();

//寻找链表中某个节点

Node *Find(const DataType &d);

void Insert(Node* pos,const DataType &d);

void Reverse();

void sort();

//合并两个有序单链表。。有一点问题

Node* Merge(Slist slist1,Slist slist2);

void Remove(const DataType &d);

void RemoveAll(const DataType &d);

//删除链表中倒数第k个节点

void Delk(int k);

//在指定节点后边插入一个节点

void InsertFrontNode(Node* pos,const DataType &d);

//寻找链表的中间节点

Node* FindMidNode();

//求链表的长度

int GetlistLength();

//销毁链表

void Destory();

//判断链表是否带环

Node* Checkcycle();

//获取环的入口节点

Node* GetcycleEntryNode(Node* meetnode);

private:

Node *_head;

Node *_tail;

};

test.c

#include"Slist.h"

#include<assert.h>

//1<<输出运算符的重载

ostream& operator<<(ostream &os,Slist &s)

{

if(s._head==NULL)

{

return os;

}

Node *cur=s._head;

while(cur!=NULL)

{

os<<cur->_data<<"->";

cur=cur->_next;

}

os<<"over"<<endl;

return os;

}

//2头插法建立单链表

void Slist::pushback(const DataType &d)

{

Node * newNode=new Node(d);

if(_head==NULL)

{

_head=newNode;

_tail=_head;

}

else

{

_tail->_next=newNode;

_tail=newNode;

}

}

//3尾删除法单链表

void  Slist::popback()

{

Node *cur=_head;

//没有节点

if(_head=NULL)

{

return;

}

//有一个节点

if(_head==_tail)

{

delete _head;

_head=NULL;

_tail=NULL;

return;

}

//有好多个节点

while(cur->_next!=_tail)

{

cur=cur->_next;

}

delete _tail;

_tail=cur;

_tail->_next=NULL;

}

//3头插法建立单链表

void  Slist::pushfront(const DataType &d)

{

Node* newNode=new Node(d);

if(_head==NULL)

{

_head=newNode;

_tail=_head;

}

else

{

newNode->_next=_head;

_head=newNode;

}

}

//4头删

void  Slist::popfront()

{

//如果链表为空则直接返回

if(_head==NULL)

{

return;

}

//否则挨个删除

Node *del=_head;

_head=_head->_next;

delete del;

}

//5在单链表中查找某个数据的节点

Node*  Slist::Find(const DataType &d)

{

Node *cur=_head;

if(_head==NULL||_head->_next==NULL)

{

return _head;

}

while(cur)

{

if(cur->_data==d)

{

return cur;

}

cur=cur->_next;

}

return NULL;

}

// 6在当前节点后边插入某个数据

void  Slist::Insert(Node* pos,const DataType &d)

{

Node* newNode=new Node(d);

if(pos==_tail)

{

_tail->_next=newNode;

_tail=newNode;

}

else

{

newNode->_next=pos->_next;

pos->_next=newNode;

}

}

//7翻转单链表

void Slist::Reverse()

{

Node *th=NULL;

Node *q =NULL;

Node *p=_head;

if(_head==NULL||_head->_next==NULL)

{

return;

}

while(p)

{

q=p;

p=p->_next;

q->_next=th;

th=q;

}

_head=th;

}

//8对单链表进行排序

void Slist:: sort()

{

Node* end=NULL;

Node* cur=_head;

if(cur==NULL||cur->_next==NULL)

{

return;

}

while(cur->_next!=end)

{

while(cur!=NULL&&cur->_next!=end)

{

if(cur->_data>cur->_next->_data)

{

DataType tmp=cur->_data;

cur->_data=cur->_next->_data;

cur->_next->_data=tmp;

}

cur=cur->_next;

}

end=cur;

cur=_head;

}

}

//9合并两个有序单链表

Node* Merge(Node* _head1,Node* _head2)

{

Node *newHead=NULL;

if(_head1==_head2)

{

return _head1;

}

if(_head1==NULL&&_head2!=NULL)

{

return _head2;

}

if(_head1!=NULL&&_head2==NULL)

{

return _head1;

}

if(_head1->_data<_head2->_data)

{

newHead=_head1;

_head1=_head1->_next;

}

else

{

newHead=_head2;

_head2=_head2->_next;

}

Node* cur=newHead;

while(_head1&&_head2)

{

if(_head1->_data<_head2->_data)

{

cur->_next=_head1;

_head1=_head1->_next;

}

else

{

cur->_next=_head2;

_head2=_head2->_next;

}

cur=cur->_next;

}

if(_head1)

{

cur->_next=_head1;

}

else

{

cur->_next=_head2;

}

return newHead;

}

//10删除链表中的某个值为d的节点

void  Slist::Remove(const DataType &d)

{

Node *cur=_head;

Node * del=NULL;

Node *prve=NULL;

if(cur==NULL)

{//若链表为空则直接返回

return;

}

//若cur不为空 则一直往下走

while(cur)

{

if(cur->_data==d)

{

del=cur;

//若要找的为第一个节点

if(cur=_head)

{

_head=_head->_next;

}

else

{

prve->_next=cur->_next;

delete del;

break;

}

}

prve=cur;

cur=cur->_next;

}

}

//11删除链表中的所有值为d的节点

void  Slist::RemoveAll(const DataType &d)

{

Node *cur=_head;

Node * del=NULL;

Node *prve=NULL;

if(cur==NULL)

{//若链表为空则直接返回

return;

}

//若cur不为空 则一直往下走

while(cur)

{

if(cur->_data==d)

{

del=cur;

//若要找的为第一个节点

if(cur=_head)

{

_head=_head->_next;

cur=_head;

}

else

{

prve->_next=cur->_next;

cur=prve->_next;

delete del;

}

}

else

{

prve=cur;

cur=cur->_next;

}

}

}

//12删除链表中倒数第k个节点

void Slist::Delk(int k)

{

assert(k>1);

Node* p1=_head;

Node* p2=_head;

while(--k)

{

p1=_head->_next;

}

while(p1->_next)

{

p1=p1->_next;

p2=p2->_next;

}

Node* del=p2->_next;

p2->_data=p2->_next->_data;

p2->_next=p2->_next->_next;

delete del;

}

//13在当前链表前插入一个数据

void Slist::InsertFrontNode(Node* pos,const DataType &d)

{

Node * newNode=new Node(d);

newNode->_next=pos->_next;

pos->_next=newNode;

DataType tmp=pos->_data;

pos->_data=pos->_next->_data;

pos->_next->_data=tmp;

}

//14寻找链表的中间节点

Node* Slist:: FindMidNode()

{

Node *fast=_head;

Node *slow=_head;

if(fast==NULL)

{

return NULL;

}

if(fast!=NULL&&fast->_next!=NULL)

{

fast=fast->_next->_next;

slow=slow->_next;

}

return slow;

}

//15求链表的长度

int  Slist:: GetlistLength()

{

int count=0;

Node *cur=_head;

while(cur)

{

count++;

cur=cur->_next;

}

return count;

}

void Slist::Destory()

{

Node* cur=_head;

Node* del=NULL;

if(_head=NULL)

{

return;

}

else

{

while(cur)

{

del=cur;

cur=cur->_next;

delete del;

del=NULL;

}

}

}

Node* Slist::Checkcycle()

{

Node* fast=_head;

Node*slow=_head;

while(fast&&fast->_next)

{

fast=fast->_next->_next;

slow=slow->_next;

if(fast==slow)

{

return slow;

}

}

return NULL;

}

Node* Slist::GetcycleEntryNode(Node* meetnode)

{

Node* entry=_head;

Node* meet=meetnode;

while(entry!=meet)

{

entry=entry->_next;

meet=meet->_next;

}

return entry;

}

void test1()

{

Slist slist1;

slist1.pushback(1);

slist1.pushback(2);

slist1.pushback(3);

slist1.pushback(4);

slist1.Destory();

cout<<slist1<<endl;

}

void test2()

{

Slist slist1;

slist1.pushfront(1);

slist1.pushfront(2);

slist1.pushfront(4);

slist1.pushfront(4);

slist1.RemoveAll(4);

cout<<slist1<<endl;

}

void test3()

{

Slist slist1;

slist1.pushfront(3);

slist1.pushfront(2);

slist1.pushfront(1);

slist1.Reverse();

cout<<slist1<<endl;

}

void test4()

{

Slist slist1;

slist1.pushfront(1);

slist1.pushfront(3);

slist1.pushfront(5);

slist1.pushfront(7);

slist1.Delk(2);

cout<<slist1;

}

void test5()

{

Slist slist1;

slist1.pushfront(1);

slist1.pushfront(3);

slist1.pushfront(4);

slist1.pushfront(5);

Node* cur=slist1.Find(1);

slist1.InsertFrontNode(cur,2);

cout<<slist1;

}

void test6()

{

Slist slist1;

slist1.pushfront(1);

slist1.pushfront(2);

slist1.pushfront(3);

slist1.pushfront(4);

slist1.sort();

cout<<slist1;

}

void test8()

{

Slist slist1;

slist1.pushfront(1);

slist1.pushfront(2);

slist1.pushfront(3);

slist1.pushfront(4);

slist1.pushfront(5);

int count=slist1.GetlistLength();

cout<<count;

}

void test9()

{

int i=0;

Slist slist1;

for(i=1;i<8;i++)

{

slist1.pushfront(i);

}

Node* end=slist1.Find(8);

Node* cur=slist1.Find(2);

end->_next=cur;

cur=slist1.Checkcycle();

if(cur!=NULL)

cout<<cur;

}

int main()

{

test9();

system("pause");

return 0;

}

				


				
时间： 2024-10-13 08:19:14 

		


		


	

	
	

		


		
c++实现链表的相关文章


						

		

			

                c语言动态链表的创建
			

		

		

									

				创建动态连链表就是将一个个节点连接起来 (1)动态生成节点 (2)输入节点数据 (3)将节点链在一起 例: typedef struct Data { char num[20]; char name[10]; char sex; float english; float chinese; float math; }; typedef struct Node { struct Data data;//结构体类型//结构体嵌套 struct Node* next;//结构体指针型 }node,*Pn			

		

	

				

		

			

                算法学习——单链表快排
			

		

		

									

				/**  * 以p为轴对start-end间的节点进行快排(包括start && 不包括end):  * 思路:  * 1.将头节点作为轴节点start,从start.next开始遍历,如果节点小于轴start的值,将该节点插入到轴节点后面:  * 2.将轴节点插入合适位置,即找到最后一个小于轴的节点,将该节点与轴节点值互换,此时就链表分为两部分,小于轴节点和大于轴节点:  * 3.递归的遍历2中两部分节点.  *   * @param p  * @param start  * @para			

		

	

				

		

			

                【数据结构】之散列链表（Java语言描述）
			

		

		

									

				散列链表,在JDK中的API实现是 HashMap 类. 为什么HashMap被称为"散列链表"?这与HashMap的内部存储结构有关.下面将根据源码进行分析. 首先要说的是,HashMap中维护着的是一个数组: transient Node<K,V>[] table; ,数组中的每个元素都是一个 Node 对象.这里的Node是HashMap的一个内部类,代码如下: static class Node<K,V> implements Map.Entry<			

		

	

				

		

			

                单链表逆置
			

		

		

									

				重写单链表逆置,熟能生巧- #include <iostream> #include <cstdlib> using namespace std; typedef struct List{ int num; struct List *next; }ListNode,*pListNode; void display(ListNode *pHead) { while(pHead) { cout<<pHead->num<<"--"; pH			

		

	

				

		

			

                java-------单链表
			

		

		

									

				单链表: * 1.链表可以是一种有序或无序的列表 * 2.链表的内容通常存储在内存中分散的为止 * 3.链表由节点组成,每一个节点具有相同的结构 * 4.节点分为数据域和链域,数据域存放节点内容,链域存放下一个节点的指针 package myLinkList; public class MyLinkedList<T> { /** *Node:节点对象 * 包括数据域data和链域next(指向下一个节点对象) */ class Node { private T data; private No			

		

	

				

		

			

                数据结构之链表
			

		

		

									

				---恢复内容开始--- 1:有头节点.单向.不循环链表 对于这种有头节点的单向不循环链表插入数据如下图: 1)头部插入 2)尾部插入 代码如下 : 1 #include "stdafx.h" 2 #include<iostream> 3 4 using namespace std; 5 6 typedef int DATA; 7 typedef struct node* LIST; 8 9 struct node 10 { 11 DATA data; 12 struct			

		

	

				

		

			

                拿java写了一个有点像指针的单链表
			

		

		

									

				public class LinkList { private Node firstNode; private Integer position; public LinkList() {  super(); } public LinkList(Node firstNode) {  super();  this.firstNode = firstNode; } public Node getFirstNode() {  return firstNode; } public void setFirs			

		

	

				

		

			

                02 单链表
			

		

		

									

				线性表之链式存储---单链表 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 // 数据结构 6 typedef struct node 7 { 8 int data; 9 struct node *next; 10 }linkList; 11 12 // 创建单链表,并初始化 13 linkList *linkList_init(void) 14 { 15 linkList *l			

		

	

				

		

			

                （单链表）单链表的整体逆序和局部逆序
			

		

		

									

				题目一:将单链表翻转. 思路:有三种方式. 一:用数组存储单链表的值,然后重新逆序赋值,效率较低. 二:利用三个指针,在原来的基础上进行逆序.这种方法比较实用,效率也高. 三:从第2个节点到第N个节点,依次逐节点插入到第1个节点(head节点)之后,最后将第一个节点挪到新表的表尾.需要新建一个链表,这种方法和第二种差不多. 这里我就写出第二种方法,比较实用. 代码(方法二): struct ListNode { int val; ListNode *next; ListNode(int x) :			

		

	

				

		

			

                链表操作法则之逆向遍历与倒置算法
			

		

		

									

				一.创建链表: 对链表进行操作的所有算法的前提,就是我们首先要创建一个链表,我们可以选择正向建链和逆向建链: (一).正向建链: 首先,我们得自定义节点类型: typedef struct Node { int data;//数据域 struct Node * pNext;//指针域 }NODE,*PNODE; 通过数组进行链表数据域的赋值: int main (void) { PNODE pHead;//头指针,接收创建链表时返回的头结点地址 int a[8] = {12,37,49,65,2