数据结构----线性表----双向链表

 

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

 

下边的代码实现数据结构的双向链表，可以作为基本的数据结构使用。同时由于实现了一些队列和栈的操作，也可以作为栈和队列使用。

 

#pragma once

class Twowayslinklist
{
public:
Twowayslinklist(void);
Twowayslinklist(int value);
Twowayslinklist(int value[], int length);
Twowayslinklist(Twowayslinklist* linklist);
~Twowayslinklist(void);
public:
int m_value;
Twowayslinklist* m_pnext;
Twowayslinklist* m_pprior;
public:
void insertattail(int value);
void insertathead(int value);
void insertorder(int value);
bool remove(int value);
bool find(int value, Twowayslinklist** node);
void positiveoutput();
void negtiveoutput();
void destroy();
int getnodenumber();
};

#include "stdafx.h"
#include "Twowayslinklist.h"

//构造一个单节点,一般用于构造链表头
Twowayslinklist::Twowayslinklist(void)
{
m_value = 0xFFFFFFFF;
m_pnext = NULL;
m_pprior = NULL;
}

//构造一个单节点,一般用于构造链表元素节点
Twowayslinklist::Twowayslinklist(int value)
{
m_value = value;
m_pnext = NULL;
m_pprior = NULL;
}

//用数组构造一个双向链表
Twowayslinklist::Twowayslinklist(int value[], int length)
{
m_pnext = NULL;
m_pprior = NULL;
m_value = 0xFFFFFFFF;
for(int i=0; i<length; i++)
{
insertorder(value[i]);
}
}

//克隆一个双向链表
Twowayslinklist::Twowayslinklist(Twowayslinklist* linklist)
{
m_pnext = NULL;
m_pprior = NULL;
m_value = 0xFFFFFFFF;

Twowayslinklist* pafter = linklist;
while(pafter->m_pnext != NULL)
{
insertorder(pafter->m_pnext->m_value);
pafter = pafter->m_pnext;
}
}

//析构函数
Twowayslinklist::~Twowayslinklist(void)
{
printf("destroy value=%d\n", m_value);
}

//正向遍历
void Twowayslinklist::positiveoutput()
{
Twowayslinklist* pafter = this;
while(pafter->m_pnext != NULL)
{
printf("value=%d self=%08x prior=%08x next=%08x\n", pafter->m_value,pafter, pafter->m_pprior, pafter->m_pnext);
pafter = pafter->m_pnext;
}
printf("value=%d self=%08x prior=%08x next=%08x\n", pafter->m_value, pafter, pafter->m_pprior, pafter->m_pnext);
}

//反向遍历
void Twowayslinklist::negtiveoutput()
{
Twowayslinklist* pafter = this;
while(pafter->m_pnext != NULL)
{
pafter = pafter->m_pnext;
}

while(pafter->m_pprior != NULL)
{
printf("value=%d self=%08x prior=%08x next=%08x\n", pafter->m_value, pafter, pafter->m_pprior, pafter->m_pnext);
pafter = pafter->m_pprior;
}
printf("value=%d self=%08x prior=%08x next=%08x\n", pafter->m_value, pafter, pafter->m_pprior, pafter->m_pnext);
}

//按照顺序插入元素
void  Twowayslinklist::insertorder(int value)
{
Twowayslinklist* node = new Twowayslinklist(value);

Twowayslinklist* pafter = this;

while(pafter->m_pnext != NULL)
{
if(pafter->m_pnext->m_value >= value)
{
break;
}
else
{
pafter = pafter->m_pnext;
}
}

Twowayslinklist* temp = pafter->m_pnext;

pafter->m_pnext = node;
node->m_pnext = temp;

node->m_pprior = pafter;
if (temp != NULL)
{
temp->m_pprior = node;
}
}

//在双向链表的头部插入元素,可以用于栈操作
void Twowayslinklist::insertathead(int value)
{

Twowayslinklist* node = new Twowayslinklist(value);
if (m_pnext == NULL)
{
this->m_pnext = node;
node->m_pprior = this;
}
else
{
Twowayslinklist* temp = this->m_pnext;
this->m_pnext = node;
node->m_pnext = temp;
node->m_pprior = this;
temp->m_pprior = node;
}
}

//在双向链表的尾部插入元素，可以用于队列操作
void Twowayslinklist::insertattail(int value)
{

Twowayslinklist* node = new Twowayslinklist(value);

Twowayslinklist* pafter = this;

while(pafter->m_pnext != NULL)
{

pafter = pafter->m_pnext;
}

pafter->m_pnext = node;
node->m_pprior = pafter;

}

//删除一个特点节点
bool Twowayslinklist::remove(int value)
{
bool find = false;
Twowayslinklist* pafter = this;

while(pafter->m_pnext != NULL)
{
if (pafter->m_pnext->m_value == value)
{
find = true;
break;
}
pafter = pafter->m_pnext;
}

if (find)
{
Twowayslinklist* temp = pafter->m_pnext;
pafter->m_pnext = temp->m_pnext;
if (pafter->m_pnext != NULL)
{
pafter->m_pnext->m_pprior = pafter;
}
}

return find;
}

//查找一个特点节点
bool Twowayslinklist::find(int value, Twowayslinklist** node)
{
bool find = false;
Twowayslinklist* pafter = this;

while(pafter->m_pnext != NULL)
{
if (pafter->m_pnext->m_value == value)
{
find = true;
break;
}
pafter = pafter->m_pnext;
}

if (find)
{
*node = pafter->m_pnext;
}

return find;
}

//销毁一个双向链表
void Twowayslinklist::destroy()
{
Twowayslinklist* pafter = this;
while(pafter->m_pnext != NULL)
{
Twowayslinklist* temp = pafter->m_pnext;
pafter->m_pnext = temp->m_pnext;
delete temp;
temp = NULL;
}
}

int Twowayslinklist::getnodenumber()
{
int count = 0;
Twowayslinklist* pafter = this;
while(pafter->m_pnext != NULL)
{
count++;
pafter = pafter->m_pnext;
}
return count;
}

下边的内容为主函数进行测试：

 

// linklist.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "Twowayslinklist.h"

int _tmain(int argc, _TCHAR* argv[])
{

int intarr[10];
//在双向链表的尾部插入
for(int i=0; i<10; i++)
{
intarr[i] = i * 10;
}
Twowayslinklist list(intarr, 10);
list.positiveoutput();

printf("------------------------------\n");
list.negtiveoutput();

printf("size=%d\n", list.getnodenumber());

//在双向链表中有顺序的插入
/*list.insertorder(17);
list.insertorder(15);
list.insertorder(16);
list.insertorder(1);
list.insertorder(3);
list.insertorder(9);
list.insertorder(8);
list.insertorder(2);

//在双向链表的头部插入
for(int i=0; i<10; i++)
{
list.insertathead(i*10);
}*/

/*list.output();
printf("-------------------------------------\n");
list.remove(0);
list.remove(5);
list.remove(9);
list.output();

Twowayslinklist *node;
bool result = list.find(9, &node);
if(result)
{
printf("find = true value=%d\n", node->m_value);
}
else
{
printf("find = false\n");
}*/

//list.destroy();
//list.output();

getchar();
return 0;
}