链表的一些常用操作

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

#include "stdafx.h"

#include <iostream>
#include <assert.h>
using namespace std;

#define random(x) (rand()%x)

#define INVALIDVALUE -1000000000

typedef struct LNode
{
    int data;
    LNode* pnext;
    LNode(){data = INVALIDVALUE; pnext = NULL;}
}BINODE, *PBINODE;

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

private:
    CLinkList(const CLinkList &rh);
    CLinkList& operator=(const CLinkList &rh);

public:

    //
    // 函数功能：获取链表中元素个数
    int getcount();

    //
    // 函数功能：清空链表
    void clear();

    //
    // 函数功能：获取链表第nPos个位置上的结点指针
    PBINODE getnode(int nPos);

    //
    // 函数功能：获取中间结点
    // 注：这个获取的方式是通过连个指针，一个步长为1，另一个步长为2.步长为2的走到底后步长为1的正好到中间
    int getmid();

    //
    // 函数功能：获取根结点
    PBINODE getroot();

    //
    // 函数功能：在nPos位置上插入元素
    bool insertnode(PBINODE pNode, int nPos);

    //
    // 函数功能：在nPos位置上插入元素
    bool insertnode(int value, int nPos);

    //
    // 函数功能：删除第nPos位置上的元素
    bool deletenode(int nPos);

    //
    // 函数功能：打印链表
    void printnode();

    //
    // 函数功能：值为nValue元素的第n次出现的位置
    int locate(int nvalue,int n);

    //
    // 函数功能：逆置
    void reverse();

    //
    // 函数功能：排序（冒泡排序法）
    void BubbleSort();

private:
    PBINODE m_root;
    int m_nCount;
};

CLinkList::CLinkList()
{
    m_root = new LNode();
    m_nCount = 0;
    assert(m_root != NULL);
}

CLinkList::~CLinkList()
{
    clear();
}

//
// 函数功能：获取链表中元素个数
int CLinkList::getcount()
{
    return m_nCount;
}

//
// 函数功能：清空链表
void CLinkList::clear()
{
    PBINODE pNode = m_root;
    PBINODE ptmpNode = NULL;
    while(pNode != NULL)
    {
        ptmpNode = pNode->pnext;
        delete pNode;
        pNode = ptmpNode;
    }
    m_root = NULL;
}

//
// 函数功能：获取根结点
PBINODE CLinkList::getroot()
{
    return m_root;
}

//
// 函数功能：获取链表第nPos个位置上的结点指针
PBINODE CLinkList::getnode(int npos)
{
    if (m_root == NULL)
    {
        return NULL;
    }

    if (npos > getcount())
    {
        return NULL;
    }

    PBINODE pNode = m_root;
    int i = 0;
    while (i < npos)
    {
        pNode = pNode->pnext;
        i++;
    }
    return pNode;
}

//
// 函数功能：获取中间结点
// 注：这个获取的方式是通过连个指针，一个步长为1，另一个步长为2.步长为2的走到底后步长为1的正好到中间
int  CLinkList::getmid()
{
    /*
    // 方法一，通过对象本身的个数来求中间的元素
    if (getcount() <= 1)
    {
        return INVALIDVALUE;
    }

    int nMid = getcount() / 2;

    PBINODE pNode = getnode(nMid);
    assert(pNode != NULL);

    return pNode->data;
    */

    PBINODE pNode = getroot();
    PBINODE pTNode = pNode->pnext;
    while (pTNode != NULL)
    {
        pNode = pNode->pnext;
        pTNode = pTNode->pnext;
        if (pTNode != NULL)
        {
            pTNode = pTNode->pnext;
        }
    }
    assert(pNode != NULL);
    return pNode->data;
}

//
// 函数功能：在nPos位置上插入元素
bool CLinkList::insertnode(PBINODE pNode, int nPos)
{
    if (pNode == NULL || nPos <= 0 || nPos > getcount() + 1)
    {
        return false;
    }

    PBINODE pPreNode = getnode(nPos - 1);
    assert(pPreNode != 0);
    PBINODE ptmp = pPreNode->pnext;
    pPreNode->pnext = pNode;
    pNode->pnext = ptmp;
    m_nCount++;

    return true;
}

//
// 函数功能：在nPos位置上插入元素
bool CLinkList::insertnode(int value, int nPos)
{
    if (nPos <= 0 || nPos > getcount() + 1)
    {
        return false;
    }

    PBINODE pNode = new LNode();
    assert(pNode != NULL);
    pNode->data = value;

    PBINODE pPreNode = getnode(nPos - 1);
    assert(pPreNode != NULL);

    PBINODE ptmp = pPreNode->pnext;

    pPreNode->pnext = pNode;
    pNode->pnext = ptmp;

    m_nCount++;

    return true;
}

//
// 函数功能：删除第nPos位置上的元素
bool CLinkList::deletenode(int nPos)
{
    if (nPos <= 0 || nPos > getcount())
    {
        return false;
    }

    PBINODE pNode = getnode(nPos - 1);
    assert(pNode != NULL);
    PBINODE pDNode = pNode->pnext;
    assert(pDNode != NULL);
    pNode->pnext = pDNode->pnext;

    delete pDNode;
    pDNode = NULL;

    return true;
}

//
// 函数功能：打印链表
void CLinkList::printnode()
{
    PBINODE root = getroot();
    PBINODE pNode = root->pnext;
    while(pNode != NULL)
    {
        cout<< pNode->data<< " ";
        pNode = pNode->pnext;
    }
    cout<<endl;
}

//
// 函数功能：值为nValue元素的第n次出现的位置
int CLinkList::locate(int nvalue,int n)
{
    PBINODE root = getroot();
    PBINODE pNode = root->pnext;
    int i = 0;
    
    int nNum = 0;
    while (pNode != NULL /*&& pNode->data != nvalue*/)
    {
        if (pNode->data == nvalue)
        {
            nNum++;
        }
        pNode = pNode->pnext;
        i++;
        if (nNum == n)
        {
            break;
        }
    }

    if (pNode == NULL)
    {
        return 0;
    }
    else
    {
        return i;
    }

}

//
// 函数功能：逆置
void CLinkList::reverse()
{
    PBINODE root = getroot();
    assert(root != NULL);

    PBINODE prenode = root->pnext;
    assert(prenode != NULL);

    PBINODE curnode = prenode->pnext;
    prenode->pnext = NULL;
    while (curnode != NULL)
    {
        PBINODE nextnode = curnode->pnext;
        curnode->pnext = prenode;
        prenode = curnode;
        curnode = nextnode;
    }

    root->pnext = prenode;
}

//
// 函数功能：排序（冒泡排序法）
void CLinkList::BubbleSort()
{
    PBINODE root = getroot();
    assert(root != NULL);

    for (int i = 0; i < getcount(); i++)
    {
        PBINODE pNode = root->pnext;
        for (int j = 0; j < getcount() - i; j++)
        {
            PBINODE pNodeNext = pNode->pnext;
            if (pNodeNext == NULL)
            {
                break;
            }
            if (pNode->data > pNodeNext->data)
            {
                int tmp = pNode->data;
                pNode->data = pNodeNext->data;
                pNodeNext->data =  tmp;
            }
            pNode = pNode->pnext;
            if (pNode == NULL)
            {
                break;
            }
        }
    }
}

//已知指针la和lb分别指向两个链表。下列算法是从表la中删除自第i个元素起共len个元素后，将它们插入到表lb中第i个元素之前。
void DeleteAndInsertSub(CLinkList &la, CLinkList &lb, int i, int len)
{
    if (i + len - 1 > la.getcount() || i <= 0 || len < 0 || i > lb.getcount())
    {
        return;
    }

    if (la.getroot() == lb.getroot())
    {
        return;
    }

    PBINODE pLa = la.getnode(i);
    if (pLa == NULL)
    {
        return;
    }

    int nCount = 0;
    while (nCount < len && pLa != NULL)
    {
        int nvalue = pLa->data;
        lb.insertnode(nvalue, i + nCount);
        pLa = pLa->pnext;
        nCount++;
    }
}

//已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序
void Merge(CLinkList &la, CLinkList &lb)
{

}

//如何检查一个单向链表上是否有环,同样两个指针，一个步长为1，另一个步长为2，如果两个指针能相遇则有环。
bool IsCircle(const CLinkList &la)
{

}

//只给定单链表中某个结点p(并非最后一个结点，即p->next!=NULL)指针，删除该结点。将p后面那个节点的值复制到p，删除p后面的节点
void DeleteNode(int nPos)
{

}

//在p前面插入一个节点 。在p后面插入新节点，将p的值与新建的节点值互换。
void InsertNode(int nPos)
{

}

//给定单链表头结点，删除链表中倒数第k个结点. 一个指针指向链表头，另一个指针指向第k个指针，然后两个指针一起移动，第二个指针到了末端则第一个指针就是倒数第k个节点
void ReverseDelete(int npos)
{

}

//判断两个链表是否相交。两种情况，如果链表有环，则先在环里设定一个指针不动，另一个链表从头开始移动，如果另一个链表能够与环中的指针相遇则是相交。如果没有环，则判断两个链表的最后个节点是否相同，相同则相交
bool IsCross(const CLinkList &la, const CLinkList &lb)
{

}

//两个链表相交，找出交点求出两个链表的长度a和b，一个指针指向较短链表的头head，另一个指针指向较长链表的第head+|a-b|，然后两个指针一起移动，相遇处即为交点。
int CrossNode(const CLinkList &la, const CLinkList &lb)
{

}

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

    cout<<"初始化链表link1："<<endl;
    int i = 0;
    for (i = 1; i <= 15; i++)
    {
        int val = random(100);
        if (!link1.insertnode(val, i))
        {
            return 0;
        }
    }
    
    link1.insertnode(41, 10);
    link1.printnode();
    cout<<"link1链表长度为："<<link1.getcount()<<endl;
    cout << "41在link1中第2次出现的位置："<<link1.locate(41, 2)<<endl;
    cout<<"link1链表逆序为："<<endl;
    link1.reverse();
    link1.printnode();
    cout<<endl;

    CLinkList link2;
    cout<<"初始化链表link2："<<endl;
    for (i = 1; i <= 20; i++)
    {
        int val = random(100);
        if (!link2.insertnode(val, i))
        {
            return 0;
        }
    }
    link2.insertnode(41, 17);
    link2.printnode();
    cout<<"link2链表长度为："<<link2.getcount()<<endl;

    DeleteAndInsertSub(link1, link2, 3, 3);
    link2.printnode();
    cout<<"修改后link2链表长度为："<<link2.getcount()<<endl;

    cout<<endl<<"两个链表进行排序，排序后显示："<<endl;
    link1.BubbleSort();
    link1.printnode();

    link2.BubbleSort();
    link2.printnode();

    cout<<"获取link1的中间元素：";
    cout<<link1.getmid()<<endl;
    return 0;
}