数据结构练习——简单单链表

头文件1：NodeStruct.h


//为了防止重定义结构体
#ifndef _NODESTRUCT_H_
#define _NODESTRUCT_H_


#include<stdio.h>
//单向链表节点数据结构
typedef struct ListNode {
	int NodeNum;
	ListNode* next;
}Listnode, *pListnode;

#endif // !_NODESTRUCT_H

头文件2：CSingalList.h

#pragma once
#include"NodeStruct.h"
#include<iostream>

//单链表类
//这个类中有会有两条链表：一条由头插法构建，一条由尾插法构建；
//尾插法构建链表时，采用了多建了一个头监督节点方式，为了方便。

class CSingalList
{
public:
	CSingalList();
	~CSingalList();

public:

	/****************************************
	//模式1：可以直接提出当作C中的功能函数使用
	******************************************/

	//头插法加入一个节点
	pListnode HeadInsertNode(pListnode phead,int item);


	pListnode InitTailList();

	//尾插法加入一个节点
	pListnode TailInsertNode(pListnode pfoot, int item);

	//遍历输出单链表的所有节点
	void TraversalList(pListnode phead);

	//遍历删除单链表的所有节点
	void CleanList(pListnode phead);


public:

	/****************************************
	//模式2：涉及类中的成员变量，无法直接提出去使用
	******************************************/
	
	 
	//头插法加入一个节点（用到了类中的成员变量）
	void HeadInsertNodeFun( int item);

	//初始化 尾插法构造链表[主要是为了构造 一个头节点]
	void InitTailListFun();

	//尾插法加入一个节点（用到了类中的成员变量）
	void TailInsertNodeFun( int item);

	//遍历输出单链表的所有节点
	void TraversalListFun(pListnode phead);

	//遍历删除单链表的所有节点
	void CleanListFun(pListnode phead);

public:

	pListnode m_HeadListHead;//头插法构造链表的头节点[随着新插入节点而动态向后移动]

	pListnode m_TailListHead;//尾插法构造链表的头节点
	pListnode m_TailListFoot;//尾插法构造链表的尾节点 [随着新插入节点而动态向后移动]
	
};

cpp文件  CSingalList.cpp


#include "stdafx.h"
#include "CSingalList.h"


CSingalList::CSingalList()
{
	m_HeadListHead = NULL;
	m_TailListHead = NULL;
	m_TailListFoot = NULL;
}


CSingalList::~CSingalList()
{
}


pListnode CSingalList::InitTailList()
{
	pListnode temp = new Listnode();
	temp->NodeNum = -1;
	temp->next = NULL;
	return temp;
}

void CSingalList::InitTailListFun()
{
	if (m_TailListHead)
		return ;

	//为这个尾插法链表开辟一个头节点
	m_TailListHead = new Listnode;
	m_TailListHead->NodeNum = -1;
	m_TailListHead->next = NULL;
	m_TailListFoot = m_TailListHead;	
}

pListnode CSingalList::TailInsertNode(pListnode pfoot, int item)
{
	if (NULL == pfoot) {
		std::cout << "尾插法链表的头尚未初始化开辟成功" << std::endl;
		return NULL;
	}

	pListnode m_TempNode = new Listnode();
	m_TempNode->NodeNum = item;
	m_TempNode->next = NULL;	
	pfoot->next = m_TempNode;
	pfoot = m_TempNode;
	return pfoot;
}

void CSingalList::TailInsertNodeFun(int item)
{
	if (NULL == m_TailListFoot) {
		std::cout << "尾插法链表的头尚未初始化开辟成功,请先调用初始化" << std::endl;
		return ;
	}

	pListnode m_TempNode = new Listnode();
	m_TempNode->NodeNum = item;
	m_TempNode->next = NULL;
	m_TailListFoot->next = m_TempNode;
	m_TailListFoot = m_TempNode;
	
}



void CSingalList::TraversalList(pListnode phead)
{
	while (phead) {
		std::cout << phead->NodeNum << " --> ";
		phead = phead->next;
	}
	std::cout << "NULL" << std::endl;
}

void CSingalList::TraversalListFun(pListnode phead)
{
	while (phead) {
		std::cout << phead->NodeNum << " --> ";
		phead = phead->next;
	}
	std::cout << "NULL" << std::endl;
}


void CSingalList::CleanList(pListnode phead)
{
	pListnode temp = NULL;
	while (phead) {
		temp = phead;
		phead = phead->next;

		delete temp; 
		temp = NULL;
	}
}

void CSingalList::CleanListFun(pListnode phead)
{
	pListnode temp = NULL;
	while (phead) {
		temp = phead;
		phead = phead->next;

		delete temp;
		temp = NULL;
	}
}

pListnode CSingalList::HeadInsertNode(pListnode phead, int item) {
	pListnode m_TempNode = new Listnode();
	m_TempNode->NodeNum = item;
	m_TempNode->next = phead;
	phead = m_TempNode;
	return phead;
}



void CSingalList::HeadInsertNodeFun(int item)
{
	pListnode m_TempNode = new Listnode();
	m_TempNode->NodeNum = item;
	m_TempNode->next =m_HeadListHead;
	m_HeadListHead = m_TempNode;
	
}

测试程序cpp  入口


#include "stdafx.h"
#include"CSingalList.h"


int main() 
{
	//*****************************
	//模式1：C语言模式
	//通过调用一个个独立的子函数来实现每一项功能
	//区别：虽然模式1中调用的功能函数都是类中的，但并没有和类的成员变量产生交集，可以直接摘出来使用
	//****************************

	CSingalList m_SingaList;
	int i, j;

	//外部调试观看用的指针
	pListnode m_pHListhead = NULL;//头插法链表的头节点指针
	pListnode m_pTListhead = NULL;//尾插法链表的头节点指针
	pListnode m_pTListfoot = NULL;//尾插法链表的尾节点指针

	 //1.构造头插法链表

	for (i = 0; i < 3; i++) {
		m_pHListhead = m_SingaList.HeadInsertNode(m_pHListhead, i);

	}
	std::cout << "模式1构造的头插法链表如下图示：" << std::endl;
	m_SingaList.TraversalList(m_pHListhead);
	m_SingaList.CleanList(m_pHListhead);


	//2.构造尾插法链表
	m_pTListhead = m_SingaList.InitTailList();//得到刚初始化后的尾插链表的尾节点指针备份
	m_pTListfoot = m_pTListhead;//得到刚初始化后的尾插链表的头节点指针备份

	for (j = 0; j < 3; j++) {
		m_pTListfoot = m_SingaList.TailInsertNode(m_pTListfoot, j);
	}
	std::cout << std::endl << "模式1构造的尾插法链表如下图示：" << std::endl;
	m_SingaList.TraversalList(m_pTListhead);
	m_SingaList.CleanList(m_pTListhead);

	system("pause");
	return 0;
}

int main()
{
	
	//*****************************
	//模式2：C++模式
	//通过调用类中的成员函数来实现每一项功能
	//区别：成员函数中直接使用了成员指针变量，这个变量在这个类失效之前一直都存活并记录值的更改
	//****************************

	CSingalList m_SingaList;
	int i, j;

	//1.构造头插法链表
	for (i = 0; i < 3; i++) {
		m_SingaList.HeadInsertNodeFun(i);
	}
	std::cout << std::endl << "模式2构造的头插法链表如下图示：" << std::endl;
	m_SingaList.TraversalListFun(m_SingaList.m_HeadListHead);
	m_SingaList.CleanListFun(m_SingaList.m_HeadListHead);


	//2.构造尾插法链表
	m_SingaList.InitTailListFun();
	for (int j = 0; j < 3; j++) {
		 m_SingaList.TailInsertNodeFun(j);
	}
	std::cout << std::endl << "模式2构造的尾插法链表如下图示：" << std::endl;
	m_SingaList.TraversalListFun(m_SingaList.m_TailListHead);
	m_SingaList.CleanListFun(m_SingaList.m_TailListHead);


	system("pause");
    return 0;
}