链表入门问题！

天亮后说晚安 2008-03-04 03:42:32
有人可以给我写个比较规范链表入门代码吗 ？
包括链表创建 添加 删除 显示 ，最好有注释。
我可以好好研究一下。谢谢
...全文
257 18 打赏 收藏 举报
写回复
18 条回复
切换为时间正序
请发表友善的回复…
发表回复
大前置 2008-03-07
  • 打赏
  • 举报
 回复 
#include<iostream.h>

#include<string.h>



struct list

{

	int number;

	list *Next;

};



list *head;

list *LCreat();//创建

void LInsert();//插入

void LDelete();//删除

void LCompoistor();//从小到大排序

char LInput();//输入

void LOutput();//输出

void LSelect();//操作选择



void main()

{

	LSelect();

}



char LInput()

{

	char ch;

	cout<<"输入:";

	cin>>ch;

    return ch;

}

void LSelect(void)

{

	char select;

	cout<<"请选择链表操作功能:"<<endl;

	cout<<"*. 创建链表-----C"<<endl;

	cout<<"*. 显示链表-----S"<<endl;

	cout<<"*. 删除结点-----D"<<endl;

	cout<<"*. 插入结点-----I"<<endl;

	cout<<"*. 合并链表-----U"<<endl;

	cout<<"*. 排序链表-----P"<<endl;

	cout<<"*. 退出程序-----Q"<<endl;

    

	switch(LInput())

	{

	case 'c'|'C':

		LCreat();

		break;

    case 'i'|'I':

		LInsert();

		break;

	case 'd'|'D':

		LDelete();

		break;

	case 'p'|'P':

		LCompoistor();

		break;

    case 's'|'S':

		LOutput();

		break;

	case 'q'|'Q':

		cout<<endl<<"按任意键退出!"<<endl;

		return ;

		break;

    default:

		cin.get();

	}

	cout<<endl;

	LSelect();

}



list *LCreat()

{

	char ListName[80];

	list *ls,*le;

	//cout<<"请输入创建链表名称:";

	//cin>>ListName;

	head=NULL;

	ls=new list;

	cin>>ls->number;

	while(ls->number)

	{

		if(head==NULL)

		{

			head=ls;

		}

		else

		{

			le->Next=ls;

		}

		le=ls;

		ls=new list;

		cin>>ls->number;

	}

	le->Next=NULL;

	delete []ls;

	return head;

}



void LDelete()

{

	int number;

	list *dl;

	list *tempHead;

	list *point;

    

	tempHead=head;

	dl=head;



	cout<<"删除结点:";

	cin>>number;

     if(head==NULL)   //空表不能删除

	 {

		 cout<<"空表"<<endl;

		 return ;

	 }

     if(dl->number==number)  //删除的是第一个结点

	 {

		 point=head;

		 head=head->Next;

		 delete []point;

		 return ;

	 }



	while(dl->Next)   //不是第一个结点  从第二结点查找

	{

     	if(dl->Next->number==number)

		{

	    	point=dl->Next;

	    	dl->Next=point->Next;

            delete point;

			return ;

		}

		dl=dl->Next ;

	}

	head = tempHead;

}



void LInsert()

{

	list *il;

	list *sl;

	list *point;



	sl=head;

	

	il=new list;

	cout<<"插入结点:";

	cin>>il->number;

	if(head==NULL)

	{

		head=il;

		il->Next=NULL;

	}

	while((il->number>sl->number)&&sl!=NULL)  //查找插入点

	{

		point=sl;

		sl=sl->Next;

	}

	if(head->number==sl->number)

	{

		il->Next=head;

		head=il;

	}

	else

	{

		point->Next=il;

		il->Next=sl;

	}

}



void LCompoistor()

{

	list *point,*pe,*ps;

	list *sl;

     

	sl=head;

	pe=head;

	if((head==NULL)||(ps=NULL))

		return ;

	

	while(sl->Next->number<)

	{

		point=sl;

		sl=sl->Next;

	}

	point=head;

	if(point->number==head->number)

	{

		ps->Next=head;

		head=ps;

		//sl=sl->Next;sl=sl->Next;

		//pe->Next=sl;

		

		sl=sl->Next;

		sl->Next=NULL;

	//	cout<<ps->number;

	}

}



void LOutput()

{

	list *tempHead;

	tempHead=head;

	while(head)

	{

		cout<<head->number<<endl;

		head=head->Next;

	}

     head=tempHead;

}
天亮后说晚安 2008-03-06
  • 打赏
  • 举报
 回复
怎么没人写啊 ？
dskgo 2008-03-05
  • 打赏
  • 举报
 回复
我也来写一个
#include<iostream>

using namespace std;

//定义结点类型

template <class T>

struct node

{

	T data;

	node<T> *next;

};



//定义单链表类

template <class T>

class List

{

	public:

		List();

		~List();

		void append(const T& item);//向表尾添加新元素

		void remove();//删除

		void output() const;//打印显示

	private:

		node<T> *head;//链表头指针

};



template<class T>

List<T>::List()

{

	head = NULL;

}



template<class T>

List<T>::~List()

{



	node<T> *p;

	while(head != NULL)

	{

		p = head;

		head = p->next;

		delete p;

	}

}





template<class T>

void List<T>::append(const T& item)

{

	node<T> *p = new node<T>;

	p->data = item;

	p->next = NULL;

	if(head == NULL)

	{

		head = p;

		return;

	}



	node<T> *s = head;

	while(s->next != NULL)

	{

		s = s->next;

	}

	p->next = s->next;

	s->next = p;





}



template<class T>

void List<T>::remove()

{

	node<T> *p;

	while(head != NULL)

	{

		p = head;

		head = p->next;

		delete p;

	}

}



template<class T>

void List<T>:: output() const

{

	node<T> *p = head;

	while(p != NULL)

	{

		cout<<p->data<<endl;

		p = p->next;

	}

}



int main()

{

	List<int> student;//定义单链表

	student.append(1);//添加

	student.append(2);

	student.output();//打印

	student.remove();//删除

	return 0;

}
风之子鸣 2008-03-05
  • 打赏
  • 举报
 回复
MARK
tianjiao85 2008-03-04
  • 打赏
  • 举报
 回复
忘了，是7楼的代码。
tianjiao85 2008-03-04
  • 打赏
  • 举报
 回复
请问：
public:
//构造函数
ListNode ( const T & item = T(), ListNode * ptrnext = NULL )
:data ( item ) , next ( ptrnext ){}
中的初始化：next ( ptrnext )
在ListNode中没见有这个构造函数，并且next是一个ListNode指针变量，对一个指针变量这样的初始化，依据的是什么呢？见得少，学C++不久，勿请详细说明。十分感谢！

天亮后说晚安 2008-03-04
  • 打赏
  • 举报
 回复
我希望的是自己写！的STL我还没有能够去学习，C++ MFC刚入门；
就像我上面写的一样。
天亮后说晚安 2008-03-04
  • 打赏
  • 举报
 回复
我自己写的不怎么规范，
//////////////////////////////////////////////////////////////////////
//链表
#include <iostream.h>
//---------------------------------------------------------------------
struct Student
{
long number;
float score;
Student* next;
};
//---------------------------------------------------------------------
Student *head; //链首指针
//---------------------------------------------------------------------
Student* Create()
{

head=NULL; //一开始链表为空

Student* pS; //创建的结点指针
pS=new Student; //新建一个结点，准备插入链表
cin >>pS->number >>pS->score; //给结点赋值

Student* pEnd; //链尾指针，用于在其后面插入结点
pEnd=NULL;

while(0 != pS->number)
{
if(head==NULL)
{
head=pS;//链表从头指针开始
}
else
{
pEnd->next=pS;//?
}

pEnd=pS; //s点
pS=new Student;
cin >>pS->number >>pS->score;
}
pEnd->next=NULL;

delete pS;
return(head);
}
//---------------------------------------------------------------------
void ShowList(Student* head)
{
cout <<"now the items of list are \n";

while(head)
{
cout <<head->number <<" " <<head->score <<endl;
head=head->next;
}
}
//---------------------------------------------------------------------
void Delete(Student *head, long number)
{
Student *p;
if(NULL==head)
{
cout<<"nList null !"<<endl;
return;
}

if(number==head->number)
{
p=head;
head=head->next;
delete p;
cout<<"the nList head delete"
<<endl;
return;
}

for(Student*pguard=head;pguard->next;pguard=pguard->next)
{
if(number==pguard->number)
{
p=pguard->next;
pguard->next=p->next;
delete p;
cout<<number<<" "<<"delete"<<endl;
return;
}

}
cout<<number<<" "<<"not found!"<<endl;

}
//---------------------------------------------------------------------
void main()
{
ShowList(Create());
Delete(head,1);
//Delete(head,5);
// Delete(head,12);
}
p0303230 2008-03-04
  • 打赏
  • 举报
 回复
续
 //表头插入结点

        void InsertFront ( const T & item ){

                //如果链表为空

                if( IsEmpty() )

                        GreatFront( item );

                else

                {

                        head = GetListNode( item , head );

                        size++;

                }

        }

        //表尾插入结点

        void InsertRear ( const T & item ){

                //如果链表为空

                if( IsEmpty() )

                        GreatFront( item );

                else

                {

                        ListNode * p = GetListNode( item );

                        rear->next = p;

                        //修改尾指针

                        rear = p;

                        size++;

                }

        }

        //在当前结点前插入结点

        void InsertBefore( ListNode * currptr , const T & item ){

                ListNode * temp = GetListNode ( item );

                ListNode * p = head;



                if( head == currptr )

                        InsertFront( item );

                else

                {

                        while( p != NULL && p->next != currptr )

                        p = p->next;

                        if( p == NULL )

                                throw invalid_argument ("invalid position");

                        temp->next = currptr;

                        p->next = temp;

                        size++;

                }

        }

        //在当前结点后插入结点

        void InsertAfter ( ListNode * currptr , const T & item ){

                if( currptr == NULL )

                        throw ("invalid position");

                if( currptr == rear )

                        InsertRear(item);

                else{

                        ListNode * p = GetListNode ( item );

                        p->next = currptr->next;

                        currptr->next = p;

                        size++;

                } 

        }

        //将链表反向

        void revease(){

                Node * pE = head;

                Node * pH = pE->next;

                Node * temp = pH->next;

                pE->next = 0;

                while( pH != 0 )

                {

                        pH->next = pE;

                        pE = pH;

                        pH = temp;

                        if( temp != 0 )

                                temp = temp->next;

                }

                head = pE;

        }

        //清空整个链表

        void Clear() {

                ListNode * p = head ;

                ListNode * temp = p ;

                while( p != NULL )

                {

                        p = p->next;

                        FreeListNode(temp);

                        temp = p;

                }

                head = rear = NULL ;

                size = 0; 

        }

        //顺序打印整个链表

        void Print() const {

                ListNode * currptr = head;

                while( currptr != NULL )

                {

                        std::cout<data<<' ';

                        currptr = currptr->next;

                }

                std::cout<        }

        //对链表排序

        void Sort(){

                ListNode * p = head;

                size_t n = Size();

                for ( int j = 1 ; j < n ; ++j )

                {

                        p = head ;

                        for( int i = 0 ; i < n - j ; ++i )

                        {

                                if( p->data > p->next->data )

                                {

                                        T temp = p->data;

                                        p->data = p->next->data;

                                        p->next->data = temp;

                                }

                                p = p->next;

                        }

                }

        }

        //删除当前结点

        void Delete( ListNode * currptr ){

                if( currptr != NULL ) {

                        ListNode * temp = head;

                        if( head == currptr )

                                head = head->next;

                        else{

                                ListNode * p = head;

                                while( p->next != NULL && p->next != currptr )

                                        p = p->next;

                                if( p->next == NULL )

                                        throw ("invalid position");

                                ListNode * temp = p->next;

                                p = temp->next; 

                        }

                        FreeListNode(temp);

                }else

                        throw ("invalid position");

        }

        //查看当前结点

        const T & Peek( const ListNode * currptr ) const {

                return currptr->Peek();

        }

        T & Peek( ListNode * currptr ) {

                return currptr->Peek();

        }

        //修改当前结点

        void SetData( const T & item , ListNode * currptr ) {

                currptr->SetData(item);

        }



protected:

        //表头指针和表尾指针

        ListNode * head, * rear;

        //链表中结点的个数

        size_t size;

        //生成新结点

        ListNode * GetListNode ( const T & item , ListNode * PtrNext = NULL ){

                ListNode * p = new ListNode ( item , PtrNext );

                return p;

        }

        //释放ListNode(p)所占的内存空间

        void FreeListNode ( ListNode * p ){

                delete p;

        }

        //创建头结点

        void GreatFront ( const T & item )

        {

                head = GetListNode( item );

                rear = head;

                size++;

        }

};





#endif
p0303230 2008-03-04
  • 打赏
  • 举报
 回复 
#ifndef linkedlist_h

#define linkedlist_h



#include 

#include 

#include "listnode.h"



template < class T >

class LinkedList

{

public:

        //构造函数

        LinkedList (): head ( NULL ), rear ( NULL ), size ( 0 ) {}

        //拷贝构造函数

        LinkedList ( const LinkedList & list ) 

                : head ( NULL ) , rear ( NULL ) , size ( 0 ) {

                ListNode * p = list.head;

                while( p != NULL ) {

                        InsertRear(p->data);

                        p = p->next;

                }

        }



        LinkedList & operator = ( const LinkedList & list ) {

                if( &list != this ) {

                        Clear();

                        const ListNode * p = list.Head();

                        while( p != NULL ) {

                                InsertRear(p->data);

                                p = p->next;

                        }

                }

                return *this;

        }

        //析构函数

        virtual ~LinkedList () {

                Clear();

        }



        const ListNode * Head() const {

                return head;

        }



        ListNode * Head() {

                return head;

        }



        const ListNode * Rear() const {

                return rear;

        }



        ListNode * Rear() {

                return rear;

        }



        //返回链表的个数

        size_t Size () const { 

                return size;

        }

        //判断链表是否为空

        bool IsEmpty () const { 

                return ( head == NULL ) ? true : false ;

        }





/* 插入一个data域值为item的结点 */



        //顺序插入结点

        void Insert ( const T & item ){

                //如果链表为空

                if( IsEmpty() ) {

                        head = GetListNode( item );

                        rear = head; 

                        size++;

                        return ;

                }

                if( item < head->data )

                        InsertFront(item);

                else {

                        ListNode * temp = GetListNode( item );

                        ListNode * p = head;

                        while( ( p->next != NULL ) && ( item > p->next->data ) )

                                p = p->next;

                        temp->next = p->next;

                        //如果到链尾，修改rear

                        if( p->next == 0 )

                                rear = temp;

                        p->next = temp;

                        size++;

                }

        }
southriv1 2008-03-04
  • 打赏
  • 举报
 回复
用C++ STL中的list 解决一切问题
p0303230 2008-03-04
  • 打赏
  • 举报
 回复 


#ifndef listnode_h

#define listnode_h



#include 



template < class T >

class LinkedList;



template < class T >

class ListNode

{

friend class LinkedList;

public: 

        //构造函数

        ListNode ( const T & item = T(), ListNode * ptrnext = NULL )

                :data ( item ) , next ( ptrnext ){}

        //查看结点的data值

        const T & Peek() const {

                return data;

        }

        T & Peek() {

                return data;

        }

        //修改data值

        void SetData(const T & item ) {

                data = item ;

        }

        //返回next指针

        const ListNode * Next() const {

                return next;

        }

        ListNode * Next() {

                return next;

        }

        //修改next值

        void SetNext(ListNode * p) {

                next = p;

        }

protected:

        T data;

        ListNode * next;

};



#endif


p0303230 2008-03-04
  • 打赏
  • 举报
 回复
baidu
google
Supper_Jerry 2008-03-04
  • 打赏
  • 举报
 回复
搜一下单链表出来N多代码。随便看
bsqsbylt 2008-03-04
  • 打赏
  • 举报
 回复
恩 要浪费时间
herman~~ 2008-03-04
  • 打赏
  • 举报
 回复
本身数据结构的书都会有
天亮后说晚安 2008-03-04
  • 打赏
  • 举报
 回复
我不是为了考试什么的，工作主要搞嵌入式用的是C。自学C++ 数据结构 。现在是遇到问题向大家请教。
ouyh12345 2008-03-04
  • 打赏
  • 举报
 回复
帮顶
看版规
相关推荐
starter-solving-problems-with-linked-lists
入门：解决链表问题 样本问题和解决方案，通过链表进行解决 入门 克隆此存储库。 git clone https://github.com/Thinkful-Ed/starter-solving-problems-with-linked-lists.git 导航到存储库的根目录并安装依赖项。 npm i 运行测试 npm test 解决方案 要查看样本解决方案，请检查“解决方案”分支。 问题
C语言[编程入门]链表之报数问题（环链表）
环链表报数问题（代码比较干净，注释超级清晰）
3.1链表----链表（Linked List）入门
3.1链表----链表（Linked List）入门 在分析链表之前，我们先来对之前的动态数组、栈、队列总结一下： （1）底层依托于静态数组 （2）依靠resize解决固定容量问题 （3）是一种假的的动态数据结构 1.什么是链表 可以从以下两个部分来理解什么是链表 （1）最简单的动态数据结构，是一种真正的动态数据结构； ...
【打卡】——【LeetCode学习计划】《数据结构入门-C++》第7天 链表
原文链接：【LeetCode学习计划】《数据结构入门-C++》第7天 链表_Wang_Xin_Ling的博客-CSDN博客 目录 141. 环形链表LeetCode: 141. 环形链表 分析： 方法一：哈希表 方法二： 快慢指针 21. 合并两个有序链表LeetCode 方法：递归 方法1优化就如同我们在【LeetCode学习计划】《算法-入门-C++》第8天 广度优先搜索 / 深度优先搜索中提到的问题一样，新链表的所有结点都是l1和l2的结点，如果l1或l2被释放了，那么..
基础链表问题练习1
https://leetcode-cn.com/explore/learn/card/linked-list/ 建议先学习学习 力扣链表入门
发帖
C++ 语言

6.3w+

社区成员

25.0w+

社区内容

C++ 语言相关问题讨论，技术干货分享，前沿动态等
c++ 技术论坛（原bbs）
社区管理员
  • C++ 语言社区
  • encoderlee
  • paschen
加入社区
帖子事件
创建了帖子
2008-03-04 03:42
社区公告
  1. 请不要发布与C++技术无关的贴子
  2. 请不要发布与技术无关的招聘、广告的帖子
  3. 请尽可能的描述清楚你的问题，如果涉及到代码请尽可能的格式化一下