单链表的创建及各种操作

一、单链表的创建

        单链表创建的方法有两类：一种是直接使用结构体定义Node结点结构，通过typedef 申明一种链表结构,如：typedef  Node* PList;，从而实现链表的创建。

        另一种，通过使用C++模板类来创建SList类，从而实现单链表。

       第一种代码如下：

typedef int DataType;

struct Node
{
	DataType _data;
	struct Node* _next;

	//关系运算符==重载
	bool operator==(Node* n)
	{
		Node *m = this;
		while((m != NULL && n != NULL) && (m->_data == n->_data))
		{
			m = m->_next;
			n = n->_next;
		}
		if(m == NULL && n == NULL)
			return true;
		else
			return false;
	}

};

typedef Node* PList;

        这样就可以通过PList来创建单链表了。

        第二种代码如下：

#pragma once

template<typename T>
class SList;

template<typename T>
class Node
{
	friend class SList<T>;
public:
	Node() :_data(T()), _next(nullptr)//注意NULL和nullptr在C和C++中的不同
	{}
	Node(T x) :_data(x), _next(nullptr)
	{}
	~Node()
	{}
private:
	T _data;
	Node *_next;
};

template<typename T>
class SList
{
public:
	SList() :_head(nullptr)
	{}
	~SList()
	{}

//
	void push_back(T x)；
        //需要的操作
//


private:
	Node<T>* _head;
};

        这样，就可以通过SList类进行链表的初始化了。

二、单链表中的各种操作：

（1）尾插操作（push_back），同理的有（头插，尾删，头删等）

：通过使用_head指针，每插入一个值，都从头结点开始遍历至最后一个结点，再将最后一个结点的_next指向新创建的结点。代码如下：

	void push_back(T x)
	{
		Node<T> *temp = _head;
		Node<T> *cur = new Node<T>(x);
		if (temp == nullptr)
			_head = cur;
		else
		{
			while (temp->_next != nullptr)
				temp = temp->_next;
			cur->_next = temp->_next;
			temp->_next = cur;
		}
	}

（2）查找单链表中间的位置。（要求：只能遍历一遍单链表）

        可以通过快慢指针的思想实现这个操作。

Node* FindMiddleNode(PList head)
{
    assert(head);
    Node *fast = head;
    Node *slow = head;

    while ((fast->_next != NULL) && (fast->_next->_next != NULL))
    {
        fast = fast->_next->_next;
        slow = slow->_next;
    }
    return slow;
}

（3）查找单链表倒数第k个元素的位置。

思想，第一个指针指向head，第二个指针先走K步。判断第二个指针为空时，第一个指针即为倒数第K个元素

Node* FindFinalNode(PList head, int k)
{
    assert(head);
    int i = k;
    Node *cur = head;
    Node *tmp = cur;
    while (i-- > 0)
    {
        if (cur == NULL)
        {
            cout << "不存在" << endl;
            return NULL;
        }
        cur = cur->_next;
    }
    while (cur != NULL)
    {
        cur = tmp->_next;
        tmp = cur;
        i = k;
        while (i-- > 0)
        {   
            if (cur == NULL)
            {
                cout << "不存在" << endl;
                return NULL;
            }
            cur = cur->_next;
        }
    }
    return tmp;
}

（4）从尾到头打印单链表。

思想：因为单链表不可逆，所以，只能通过一边单链表的遍历，利用栈的先进后出特点，实现逆序打印。代码如下：

void PrintTailToHead(PList head)
{
	stack<Node*> s;
	Node* begin = head;
	while (begin != NULL)
	{
		s.push(begin);
		begin = begin->_next;
	}

	while (!s.empty())
	{
		cout << s.top()->_data << "->";
		s.pop();
	}
	cout << "NULL" <<endl;
}

（6）单链表的逆置反转。

思想：单链表逆置，可以直接使用容器存储再逆置，也可以使用两个指针一头一尾交换实现。但是，这些方法效率都不尽人意。这里给出一种非常巧妙也常规的方法：因为单链表只有一个方向从头指到尾，所以，当我们从头开始遍历指针，每次经过一个结点时，将其指向方向一改变，最后将head指向原来的尾，原来的head指针的next指向NULL，即实现了单链表的逆置，并且空间复杂度为0，时间复杂度为O（n）。代码如下：

Node* Rervse(PList head)
{
    Node* newHead = NULL;

    Node* cur = head;
    while (cur != NULL)
    {
        Node* tmp = cur;
        cur = cur->_next;

        tmp->_next = newHead;
        newHead = tmp;
    }

    return newHead;
}

（7）单链表的排序。

        链表实现排序可以选择只交换数据不换结点，或者必须交换结点两种方式。这里给出一种基于插入排序的排序方式。当然还可以使用冒泡排序使用一个tail指针，每次都指向一次遍历的末尾。

//查找要插入的位置
Node* Search(PList head, Node *x)
{
    Node *tmp = head;
    Node *ret = NULL;
    if (head == NULL)
        return head;
    while (tmp->_data <= x->_data)
    {
        ret = tmp;
        tmp = tmp->_next;
    }
    return ret;
}

void SortList(PList &head)
{
    assert(head);
    Node* cur = head;
    Node* INode = NULL;
    Node* tmp = cur->_next;
    //当只有一个结点的情况时
    if (tmp == NULL)
        return;
    //当有多个结点的情况时
    cur->_next = NULL;
    while (tmp != NULL)
    {
        INode = tmp;
        tmp = tmp->_next;
        cur = Search(head, INode);
        //当cur为空插入到head之前
        if (cur == NULL)
        {
            INode->_next = head;
            head = INode;
        }
        //当cur不为空插入到cur之后
        else
        {
            INode->_next = cur->_next;
            cur->_next = INode;
        }
    }
}

（8）两个有序单链表的合并

方法和单链表的合并相同，不过，是以一条链为基准，一条链开始拆除。

void Merge(PList list1, PList list2)
{
    assert(list1 || list2);
    Node* cur = list1;
    Node* INode = NULL;
    Node* tmp = list2;
    //当只有一个结点的情况时
    if (tmp == NULL)
        return;
    //当有多个结点的情况时
    while (tmp != NULL)
    {
        INode = tmp;
        tmp = tmp->_next;
        cur = Search(list1, INode);
        //当cur为空插入到head之前
        if (cur == NULL)
        {
            INode->_next = list1;
            list1 = INode;
        }
        //当cur不为空插入到cur之后
        else
        {
            INode->_next = cur->_next;
            cur->_next = INode;
        }
    }
}