链表

1.构造链表

2.逆序打印链表

实现方法：

a.用stack实现

b.用递归实现

测试用例：

没有节点，只有一个节点,有多个节点

3.在O(1)时间删除节点

实现方法：

复制被删除节点的下一个节点，然后删除next节点

测试用例：

null,单个节点,多个节点

4.返回链表中倒数第k个节点

实现方法：

用两个指针,间距为k找到第k个节点.

测试用例：

空链表,链表长度小于k,链表长度等于k,链表长度大于k

5.链表反转

实现方法：

三个指针，指向前一个节点，中间节点，后一个节点

测试用例：

空链表，单个元素链表，两个元素链表，多个元素链表

6.合并两个已经排序的链表

实现方法：

设置三个指针，第一个指向已合并的链表的尾部，剩下两个分别指向链表的头

测试用例：

两个空链表，一个空链表，没有空链表

7.两个链表的第一个公共节点

实现方法：

遍历两个链表长度，求出链表长度之差，将问题转化为4:寻找链表的第k个节点

测试用例：

两个空链表，一个空链表，没有公共节点，公共节点为头节点，

公共节点为尾节点，公共节点为中间节点

//list.h
#ifndef __LIST__
#define __LIST__

struct link_node{
int m_val;
link_node *next;

link_node(int val,link_node* p){
m_val =val;
next = p;
}
};

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

/**  将节点插入到链表头 **/
void head_insert_node(link_node *p);

/**  将节点插入到链表尾**/
void tail_inster_node(link_node *p);

/**  插入链表节点 **/
void normal_insert_node(link_node* p,link_node *insert_node);

/**  逆序打印链表**/
void print_list_reserve();

/**   删除链表尾节点**/
void head_delete_node();

/**   删除链表头结点**/
void tail_delete_node();

/**  删除链表中p节点**/
void normal_delete_node(link_node* p);

/**   获取第链表第k个节点**/
link_node* get_kth_node(int k);

/**   创建链表节点**/
link_node* create_link_node(int val);

/**  反转链表 **/
void reserve_list();

/**  合并两个已排好序(非递增)的链表 **/
void merge_list(link_list *head);

/** 打印链表节点**/
void print_list();

private:
link_node *phead;

private:
/** 逆序打印链表--内部递归函数 **/
void print_list_reserve(link_node *);
};
#endif

//list.cpp
#include <iostream>
#include "list.h"

/** 函数名：    link_list
*    功能描述：   构造函数
*    参数列表：   无
*    返回值  ：
*/
link_list::link_list ()
:phead(NULL)
{
std::cout<<"构造函数"<<std::endl;
}

/** 函数名：    ~link_list
*    功能描述：   析构函数
*    参数列表：   无
*    返回值  ：
*/
link_list::~link_list()
{
std::cout<<"析构函数"<<std::endl;
while ( phead  ){
head_delete_node();
}
}

/** 函数名：    ~head_insert_node
*    功能描述：   将节点插入到链表头
*    参数列表：   待插入节点
*    返回值  ：
*/
void link_list::head_insert_node(link_node *p)
{
std::cout<<"将节点插入到链表头"<<std::endl;
if ( p ){
p->next = phead;
phead   = p;
}
}

/** 函数名：    tail_inster_node
*    功能描述：   将节点插入到链表尾
*    参数列表：   待插入节点
*    返回值  ：
*/
void link_list::tail_inster_node(link_node *p)
{
std::cout<<"将节点插入到链表尾"<<std::endl;
if ( p ){
if ( phead ){
link_node *ptail = phead;
while ( ptail->next ){
ptail = ptail->next;
}
ptail->next = p;
p->next = NULL;
} else {
phead = p;
p->next = NULL;
}
}
}

/**  插入链表节点 **/
/** 函数名：    normal_insert_node
*    功能描述：   插入链表节点
*    参数列表：   查找链表中节点p，在节点p后面插入节点insert_node
若链表中存在p,则插入其后，否则do nothing
*    返回值  ：   无
*/

void link_list::normal_insert_node(link_node* p,link_node *insert_node)
{
std::cout<<"插入链表节点"<<std::endl;
if ( phead && insert_node && p ){
link_node *curr_node = phead;
while ( curr_node && curr_node!=p){
curr_node = curr_node->next;
}
if ( curr_node ){
insert_node->next  = curr_node->next;
curr_node->next    = insert_node;
}
}
}

/**  逆序打印链表**/
/** 函数名：    print_list_reserve
*    功能描述：   逆序打印链表
*    参数列表：   无
*    返回值  ：
*/
void link_list::print_list_reserve()
{
std::cout<<"逆序打印链表"<<std::endl;
if ( phead ){
link_node *p = phead;
print_list_reserve(p);
std::cout<<std::endl;
} else {
std::cout<<"链表为空."<<std::endl;
}

}

/**  逆序打印链表**/
/** 函数名：    print_list_reserve
*    功能描述：   逆序打印链表--内部递归函数
*    参数列表：   当前链表节点
*    返回值  ：
*/
void link_list::print_list_reserve(link_node *p)
{
if ( p->next ){
print_list_reserve(p->next);
}
std::cout<<p->m_val<<" ";
}

/**   打印链表**/
/** 函数名：    head_delete_node
*    功能描述：   打印链表
*    参数列表：   无
*    返回值  ：
*/
void link_list::print_list()
{
std::cout<<"正序打印链表节点"<<std::endl;
link_node* p =phead;
while ( p ){
std::cout<<p->m_val<<" ";
p = p->next;
}
std::cout<<std::endl;
}
/**   删除链表头节点**/
/** 函数名：    head_delete_node
*    功能描述：   删除链表头节点
*    参数列表：   无
*    返回值  ：
*/
void link_list::head_delete_node()
{
std::cout<<"删除链表头节点"<<std::endl;
if ( phead ){
link_node *p =phead->next;
delete phead;
phead = p;
}
}

/**   删除链表尾结点**/
/** 函数名：    tail_delete_node
*    功能描述：   删除链表尾结点
*    参数列表：   无
*    返回值  ：
*/
void link_list::tail_delete_node()
{
std::cout<<"删除链表尾结点"<<std::endl;
if ( phead ){
if ( phead->next ){
link_node *p = phead;
while ( p->next->next ){
p = p->next;
}
delete p->next;
p->next = NULL;
} else {
delete phead;
phead = NULL;
}
}
}

/**  删除链表中p节点**/
/** 函数名：    normal_delete_node
*    功能描述：   删除链表中p节点
*    参数列表：   无
*    返回值  ：
*/
void link_list::normal_delete_node(link_node* p)
{
std::cout<<"删除链表中p节点"<<std::endl;

if ( phead && p ){
link_node* curr = phead;
if ( phead == p ){
curr = curr->next;
delete phead;
phead = curr;
}else if ( p->next ){
curr = p->next;
p->m_val = p->next->m_val;
p->next = p->next->next;
delete curr;
} else {
while ( curr->next && curr->next!=p ){
curr = curr->next;
}
if ( curr->next == p ){
curr->next = curr->next->next;
delete p;
}
}
}
}

/** 函数名：    get_kth_node
*    功能描述：   获取第链表第k个节点
*    参数列表：   第k个节点
*    返回值  ：
*/
link_node* link_list::get_kth_node(int k)
{
std::cout<<"获取第链表第k个节点"<<std::endl;
link_node *p1 = phead;
link_node *p2 = phead;
int i = 0;
while ( p1 && i<k  ){
p1 = p1->next;
i++;
}
while ( p1 ){
p1 = p1->next;
p2 = p2->next;
}
return i == k ? p2:NULL;
}

/**   创建链表节点**/
/** 函数名：    create_link_node
*    功能描述：   创建链表节点
*    参数列表：   节点的值
*    返回值  ：
*/
link_node* link_list::create_link_node(int val)
{
std::cout<<"创建链表节点"<<std::endl;
link_node * p = new link_node(val,NULL);
return p;
}

/**  反转链表 **/
/** 函数名：    reserve_list
*    功能描述：   反转链表
*    参数列表：   无
*    返回值  ：
*/
void link_list::reserve_list()
{
std::cout<<"反转链表"<<std::endl;
link_node *pre = NULL;
link_node *curr = phead;
link_node *last = NULL;

while ( curr ){
last          = curr->next;
curr->next    = pre ;
pre           = curr;
curr          = last ;
}
phead = pre ;
}

/**  合并两个已排好序的链表 **/
/** 函数名：    merge_list
*    功能描述：   合并两个已排好序的链表
*    参数列表：   无
*    返回值  ：
*/
void link_list::merge_list(link_list *list)
{
std::cout<<"合并两个已排好序的链表"<<std::endl;
if ( list ){
link_node *phead1   = phead;
link_node *phead2  = list->phead;
link_node *tail_node    = NULL;
if ( phead1 == NULL ){
phead = phead2;
}
if ( phead1 && phead2 ){
if (  phead1->m_val > phead2->m_val ){
phead = phead1;
phead1 = phead1->next;
} else {
phead = phead2;
phead2 = phead2->next;
}
tail_node = phead;
}

while ( phead1 && phead2 ){
if (  phead1->m_val > phead2->m_val ){
tail_node->next = phead1;
phead1 = phead1->next;
} else {
tail_node->next = phead2;
phead2 = phead2->next;
}
tail_node = tail_node->next;
}
if ( tail_node ){
tail_node->next = phead1->next == NULL
? phead2 : phead1;
}
list->phead = NULL;
}

}

//main
#include <iostream>
#include "list.h"

using namespace std;

int main()
{

link_list myList ;

//测试空链表的删除
myList.get_kth_node(7);

//测试空链表反转
myList.reserve_list();

myList.head_insert_node(myList.create_link_node(1));
myList.print_list();

myList.get_kth_node(7);

//测试链表反转
myList.reserve_list();
myList.print_list();

link_list listTemp ;
for ( int i=0 ; i<10; i++ ){
myList.head_insert_node(myList.create_link_node(i));
}
//myList.reserve_list();
myList.tail_delete_node();
myList.print_list();

for ( int i=0 ; i<10; i++ ){
listTemp.tail_inster_node(listTemp.create_link_node(i));
}
listTemp.reserve_list();
listTemp.print_list();
listTemp.merge_list(&myList);

listTemp.print_list();
return 0;
}