单链表的排序

单链表的逆序：

　　　　　　由于链表不同于数组一样，所以将排好序的结点放到另一个链表中去，然后再由头指针指向该链表。

void Link::Sort(Node * Head) {

    Node * Root = NULL;    // 头指针，作为一个新链表指针，将所有结点链接到这里
    Node * Tail = NULL;    // 尾指针
    Node * pMin = NULL;    // 作为待操作链表结点中最小结点的前驱
    Node * min = NULL;    // 最小结点的指针
    Node * p = NULL;    // 操作指针

    // 第一次Head是没有进过初始化的结点，所以它的data是一个负无穷值
    while (Head != NULL) {
        min = Head;        // 将最小值链接到Root中以后，需要重新设置默认最小值 min为头的第一个结点，再找出真正最小结点
        for (p = Head; p->next != NULL; p = p->next) {    // 由于要设置前驱，所以不从 p=p->next开始
            if (p->next->data < min->data) {
                pMin = p;
                min = p->next;
            }
        }    // 获得最小结点
        // 将最小结点插入到 Root中去，但是需要判断最小值是不是头结点，如果是就不必链接到Root
        // 因为最后面会将Root中的链表又重新链接到Head中去
        if (Root == NULL) {
            // 当Root为空的时候，Root就是第一个结点，也是最小的
            Root = min;
            Tail = min;
        }
        else {
            // 已经存在头结点了，需要插入到链表中，即末尾
            Tail->next = min;
            Tail = min;
        }

        if (min == Head) {
            // 当最小值是链表中的第一个结点的时候，只需要后移一位就行了
            Head = Head->next;
        }
        else {
            // 当不是第一个结点的时候，则让当前最小结点断开链表，故此借助 前驱 pMin指向 min的下一个结点
            pMin->next = min->next;
        }
    }    // 获得有序链表 Root,Root中的结点都来自于Head中
    if (Root != NULL) {
        // Root不为空，表明有结点链接上来了，链表中都是结点尾指针，没有设置链表结束符 ->next=NULL;
        Tail->next = NULL;
    }
    Head = Root;    // 将Root中排序好的结点链接到Head上去
}

#include <iostream>
using namespace std;

struct Node {
    char data;
    Node * next;
};

class Link {
public:
    Link();
    ~Link();
    void Sort(Node *);
    void Output();
    Node * getHead();
private:
    Node * Head;
    void Create();
};

int main() {

    cout << "ASCII码大小为：数字 < 大写字母 < 小写字母。注：数字10代表两个字符1,0" << endl;
    Link L1;
    L1.Output();
    L1.Sort(L1.getHead());
    cout << "排序后:" << endl;
    L1.Output();

    system("pause");
    return 0;
}

void Link::Sort(Node * Head) {

    Node * Root = NULL;    // 头指针，作为一个新链表指针，将所有结点链接到这里
    Node * Tail = NULL;    // 尾指针
    Node * pMin = NULL;    // 作为待操作链表结点中最小结点的前驱
    Node * min = NULL;    // 最小结点的指针
    Node * p = NULL;    // 操作指针

    // 第一次Head是没有进过初始化的结点，所以它的data是一个负无穷值
    while (Head != NULL) {
        min = Head;        // 将最小值链接到Root中以后，需要重新设置默认最小值 min为头的第一个结点，再找出真正最小结点
        for (p = Head; p->next != NULL; p = p->next) {    // 由于要设置前驱，所以不从 p=p->next开始
            if (p->next->data < min->data) {
                pMin = p;
                min = p->next;
            }
        }    // 获得最小结点
        // 将最小结点插入到 Root中去，但是需要判断最小值是不是头结点，如果是就不必链接到Root
        // 因为最后面会将Root中的链表又重新链接到Head中去
        if (Root == NULL) {
            // 当Root为空的时候，Root就是第一个结点，也是最小的
            Root = min;
            Tail = min;
        }
        else {
            // 已经存在头结点了，需要插入到链表中，即末尾
            Tail->next = min;
            Tail = min;
        }

        if (min == Head) {
            // 当最小值是链表中的第一个结点的时候，只需要后移一位就行了
            Head = Head->next;
        }
        else {
            // 当不是第一个结点的时候，则让当前最小结点断开链表，故此借助 前驱 pMin指向 min的下一个结点
            pMin->next = min->next;
        }
    }    // 获得有序链表 Root,Root中的结点都来自于Head中
    if (Root != NULL) {
        // Root不为空，表明有结点链接上来了，链表中都是结点尾指针，没有设置链表结束符 ->next=NULL;
        Tail->next = NULL;
    }
    Head = Root;    // 将Root中排序好的结点链接到Head上去
}

Link::Link() {
    Head = new Node();
    Head->next = NULL;
    Create();
}
Link::~Link() {
    Node * p = NULL;
    while (Head != NULL) {
        p = Head;
        Head = Head->next;
        delete p;
    }
}

void Link::Create() {

    Node * p = Head;
    char ch;
    cout << "创建单链表，请输入一个结点（#作为结束符）：" << endl;
    cin >> ch;
    Node * tem = NULL;
    while (ch != '#') {
        tem = new Node();
        tem->data = ch;
        p->next = tem;
        p = tem;
        cin >> ch;
    }
    p->next = NULL;

}

void Link::Output() {
    Node * p = Head->next;
    while (p != NULL) {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}
Node * Link::getHead() {
    return Head;
}