链表/反汇编的实现
单向链表实现的笔记
有无头节点的区别：https://blog.csdn.net/weixin_46273997/article/details/104335743
链表的一般类型：
这里只实现单向链表，实现代码如下：
#include "StdAfx.h"
#include<stdio.h>
#include<windows.h>
#define SUCCESS 1 // 执行成功
#define ERROR -1 // 执行失败
#define INDEX_IS_ERROR -2 // 错误的索引号
#define BUFFER_IS_EMPTY -3 // 缓冲区已空
template<class T_ELE>
class LinkedList
{
public:
LinkedList();
~LinkedList();
public:
BOOL IsEmpty(); //判断链表是否为空 空返回1 非空返回0 完成
void Clear(); //清空链表 完成
void Print(); //print
void Test();
DWORD GetElement(IN DWORD dwIndex, OUT T_ELE& Element); //根据索引获取元素
DWORD GetElementIndex(IN T_ELE& Element); //根据元素获取链表中的索引
DWORD Insert(IN T_ELE Element); //新增元素 完成
DWORD Insert(IN DWORD dwIndex, IN T_ELE Element); //根据索引新增元素
DWORD Delete(IN DWORD dwIndex); //根据索引删除元素
DWORD GetSize(); //获取链表中元素的数量 完成
private:
typedef struct _NODE{
T_ELE Data;
_NODE *pNext;
}NODE, *PNODE;
PNODE GetIndexCurrentNode(DWORD dwIndex); //获取索引为dwIndex的指针 完成
PNODE GetIndexPreviousNode(DWORD dwIndex); //获取索引为dwIndex的前一个节点指针 完成
PNODE GetIndexNextNode(DWORD dwIndex); //获取索引为dwIndex的后一个节点指针 完成
private:
PNODE m_pList; //链表头指针，指向第一个节点
DWORD m_dwLength; //元素的数量
};
//无参构造函数 初始化成员
template<class T_ELE> LinkedList<T_ELE>::LinkedList():m_pList(NULL), m_dwLength(0)
{
//这里其实不需要实现
}
//析构函数 清空元素
template<class T_ELE>
LinkedList<T_ELE>::~LinkedList()
{
Clear();
}
//判断链表是否为空，判断依据头指针是否为空 或者 是链表的数量m_dwLength是否为0
template<class T_ELE>
BOOL LinkedList<T_ELE>::IsEmpty()
{
if (this->m_pList == NULL){
return true;
}
return false;
}
//清空链表
template<class T_ELE>
void LinkedList<T_ELE>::Clear()
{
// 1. 判断链表是否为空
if (this->m_pList == NULL){
return;
}
// 2. 循环删除链表中的节点
PNODE p_temp_node_1 = new NODE();
PNODE p_temp_node_2 = new NODE();
p_temp_node_2 = this->m_pList;
while (p_temp_node_2->pNext != NULL){
p_temp_node_1 = p_temp_node_2;
p_temp_node_2 = p_temp_node_2->pNext;
delete p_temp_node_1;
}
p_temp_node_1 = NULL;
// 3. 删除最后一个节点并将链表长度置为0
delete p_temp_node_2;
this->m_dwLength = 0;
}
//根据索引获取元素
template<class T_ELE>
DWORD LinkedList<T_ELE>::GetElement(IN DWORD dwIndex, OUT T_ELE& Element)
{
// 1. 判断索引是否有效
if (dwIndex < 0 || dwIndex > this->m_dwLength){
return INDEX_IS_ERROR;
}
// 2. 取得索引指向的节点
PNODE p_temp_node;
p_temp_node = this->m_pList;
for (int i = 0; i < dwIndex; i++){
p_temp_node = p_temp_node->pNext;
}
// 3. 将索引指向节点的值复制到OUT参数
Element = p_temp_node->Data;
p_temp_node = NULL;
return SUCCESS;
}
//根据元素内容获取索引
template<class T_ELE>
DWORD LinkedList<T_ELE>::GetElementIndex(IN T_ELE& Element)
{
// 1. 判断链表是否为空
if (this->m_pList == NULL){
return ERROR;
}
// 2. 循环遍历链表，找到与Element相同的元素
PNODE p_temp_node = new NODE();
p_temp_node = this->m_pList->pNext;
for (int i = 0; i < this->m_dwLength-1; i++){
if (p_temp_node->Data == Element){
Element = p_temp_node->Data;
p_temp_node = NULL;
return SUCCESS;
}
}
}
//在链表尾部新增节点
template<class T_ELE>
DWORD LinkedList<T_ELE>::Insert(IN T_ELE Element)
{
// 1. 判断链表是否为空
if (this->m_pList == NULL){
PNODE p_new_node = new NODE();
p_new_node->Data = Element;
p_new_node->pNext = NULL;
this->m_pList = p_new_node;
this->m_dwLength += 1;
return SUCCESS;
}
PNODE p_new_node = new NODE();
memset(p_new_node,0,sizeof(NODE));
p_new_node->Data = Element;
p_new_node->pNext = 0;
// 2. 如果链表中已经有元素
PNODE p_temp_node_1 = new NODE();
PNODE p_temp_node_2 = new NODE();
p_temp_node_2 = this->m_pList;
while (p_temp_node_2->pNext != NULL){
p_temp_node_1 = p_temp_node_2;
p_temp_node_2 = p_temp_node_2->pNext; //最后p_temp_node_2的地址是最后一个节点的位置
}
p_temp_node_2->pNext = p_new_node;
this->m_dwLength += 1;
p_temp_node_1 = NULL;
p_temp_node_2 = NULL;
return SUCCESS;
}
//将节点新增到指定索引的位置 0 1 2 3 4
template<class T_ELE>
DWORD LinkedList<T_ELE>::Insert(IN DWORD dwIndex, IN T_ELE Element)
{
PNODE p_new_node = new NODE();
p_new_node->Data = Element;
p_new_node->pNext = NULL;
// 1. 判断链表是否为空
if (this->m_pList == NULL || this->m_dwLength == 0){
if(dwIndex == 0){
this->m_pList = p_new_node;
this->m_dwLength += 1;
return SUCCESS;
}
}
// 2. 判断索引值是否有效
if (dwIndex < 0 || dwIndex > this->m_dwLength){
return INDEX_IS_ERROR;
}
// 3. 如果索引为0, replace m_pList
if (dwIndex == 0){
p_new_node->pNext = this->m_pList; //2697547
this->m_pList = p_new_node;
this->m_dwLength += 1;
return SUCCESS;
}
//这里开始生成两个PNODE作为下面进行操作的需要
PNODE p_temp_node_1 = new NODE();
PNODE p_temp_node_2 = new NODE();
p_temp_node_2 = this->m_pList->pNext;
// 4. 如果索引为链表尾
if (dwIndex == this->m_dwLength){
p_temp_node_2 = this->m_pList;
while (p_temp_node_2->pNext != NULL){
p_temp_node_2 = p_temp_node_2->pNext;
}
//Element 链表尾要添加的元素
p_temp_node_2->pNext = p_new_node;
this->m_dwLength += 1;
return SUCCESS;
}
// 5. 如果索引为链表中
if (dwIndex > 0 && dwIndex < this->m_dwLength){
for (int i = 0; i < dwIndex; i++){
p_temp_node_1 = p_temp_node_2;
p_temp_node_2 = p_temp_node_2->pNext;
}
p_temp_node_1->pNext = p_new_node;
p_new_node->pNext = p_temp_node_2;
this->m_dwLength += 1;
return SUCCESS;
}
return ERROR;
}
//根据索引删除节点
template<class T_ELE>
DWORD LinkedList<T_ELE>::Delete(IN DWORD dwIndex)
{
PNODE p_new_node = new NODE();
// 1. 判断链表是否为空
if (this->m_pList == NULL){
return ERROR;
}
// 2. 判断索引值是否有效
if (dwIndex < 0 || dwIndex > this->m_dwLength){
return INDEX_IS_ERROR;
}
// 3. 如果链表中只有头节点，且要删除头节点
if (dwIndex == 0){
if(this->m_pList->pNext == NULL){
printf("链表中只有头节点，且要删除头节点!\n");
delete this->m_pList;
return SUCCESS;
}else{
p_new_node = this->m_pList->pNext;
delete this->m_pList;
this->m_pList = p_new_node;
this->m_dwLength -= 1;
return SUCCESS;
}
return ERROR;
}
//5. 如果是其他情况
PNODE p_before_new_node = new NODE();
p_new_node = this->m_pList;
//5.2 中间节点
if(dwIndex > 0 && dwIndex < this->m_dwLength){
for(int i=0;i < dwIndex -1;i++){
p_before_new_node = p_new_node;
p_new_node = p_new_node->pNext;
}
p_before_new_node->pNext = p_new_node->pNext;
delete p_new_node;
p_new_node = NULL;
this->m_dwLength -= 1;
return SUCCESS;
}else{
while(p_new_node->pNext != NULL){
p_before_new_node = p_new_node;
p_new_node = p_new_node->pNext;
}
delete p_new_node;
p_new_node = NULL;
p_before_new_node->pNext = NULL;
this->m_dwLength -= 1;
return SUCCESS;
}
return ERROR;
}
//获取链表中节点的数量
template<class T_ELE>
DWORD LinkedList<T_ELE>::GetSize()
{
return this->m_dwLength;
}
//Print
template<class T_ELE>
void LinkedList<T_ELE>::Print(){
PNODE p_new_node = new NODE();
p_new_node = this->m_pList;
for(int i=0;i<this->m_dwLength;i++){
printf("%d \n",p_new_node->Data);
p_new_node = p_new_node->pNext;
}
}
//获取dwIndex前面节点的地址
template<class T_ELE>
LinkedList<T_ELE>::PNODE LinkedList<T_ELE>::GetIndexPreviousNode(DWORD dwIndex)
{
PNODE p_new_node = new NODE();
if(dwIndex == 0){
p_new_node->Data = 0;
return p_new_node;
}
p_new_node = this->m_pList;
for (int i = 0; i < dwIndex - 1; i++){
p_new_node = p_new_node->pNext;
}
return p_new_node;
}
//获取dwIndex节点的地址
template<class T_ELE>
LinkedList<T_ELE>::PNODE LinkedList<T_ELE>::GetIndexCurrentNode(DWORD dwIndex)
{
PNODE p_new_node = new NODE();
p_new_node = this->m_pList;
for (int i = 0; i < dwIndex; i++){
p_new_node = p_new_node->pNext;
}
return p_new_node;
}
template<class T_ELE>
void LinkedList<T_ELE>::Test(){
PNODE p_new_node = new NODE();
p_new_node = this->GetIndexPreviousNode(0);
printf("%d",p_new_node->Data);
}
//获取dwIndex后面节点的地址
template<class T_ELE>
LinkedList<T_ELE>::PNODE LinkedList<T_ELE>::GetIndexNextNode(DWORD dwIndex)
{
PNODE p_new_node = new NODE();
p_new_node = this->m_pList;
for (int i = 0; i < dwIndex + 1; i++){
p_new_node = p_new_node->pNext;
}
return p_new_node;
}
int main(){
LinkedList<int>* mylinklist = new LinkedList<int>();
mylinklist->Insert(100);
mylinklist->Insert(200);
mylinklist->Insert(300);
mylinklist->Insert(600);
mylinklist->Insert(700);
//mylinklist->Test();
printf("size: %d\n",mylinklist->GetSize());
mylinklist->Print();
printf("==============================\n");
mylinklist->Delete(4);
printf("size: %d\n",mylinklist->GetSize());
mylinklist->Print();
//最后进行clear清理测试
mylinklist->Clear();
return 0;
}
浙公网安备 33010602011771号