链表 基本操作

codeblocks测试通过，个人理解仅供参考。

如有错误，请联系我，以便更改。

 

#include <iostream>
#include <cstdlib>

using std::cin;
using std::cout;
using std::endl;

//结点。
struct node{
    int data;   //为了方便数据以int表示，实际可以用结构体，类，以及其他数据类型
    node *next;
};

/*~~~~~~~~~~~~~~~~~~~~~~   基础操作   ~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/*init_link：逆序初始化一个单向链表。   -----------------------
 *用法：向函数传递头指针，用户端输入一个或多个数据直到
 *输入^Z终止。返回头指针。
 */
node* init_link(node *head){
    int init_data;
    cin >> init_data;
    //对head赋初值
    node *first = (node *)malloc( sizeof(node) );
    first->data = init_data;
    first->next = 0;
    head = first;
    //继续顺序建立链表
    node *cursor = head;
    while ( cin >> init_data ){
        node *last = (node *)malloc( sizeof(node) );
        last->data = init_data;
        last->next = 0;
        cursor = cursor->next = last;
    }
    cin.clear();
    return head;
}


/*inverted_init_link：逆序初始化一个单向链表。   -----------------------
 *用法：向函数传递头指针，用户端输入一个或多个数据直到
 *输入^Z终止。返回头指针。
 */
node* inverted_init_link (node *head){
    int init_data;
    while ( cin >> init_data){
        node *first = (node *)malloc( sizeof(node) );
        first->data = init_data;
        first->next = head;
        head = first;
    }
    cin.clear();
    return head;
}


/*display_link：显示单向链表。 ----------------------------
 *用法：向函数传递头指针
 */
void display_link (node *head){
    node *cursor = head;
    while (0 != cursor){
        cout << cursor->data << endl;
        cursor = cursor->next;
    }
}

/*size_link：测试链表长度并返回。 ----------------------------
 *用法：传递链表头指针。返回链表长度(unsigned型)
 */
unsigned size_link (node *head){
    node *cursor = head;
    unsigned size(0);
    while (0 != cursor){
        ++size;
        cursor = cursor->next;
    }

    return size;
}

/*find_node：找到第flag个结点并返回 ------------------
 *用法：向函数传递头指针与flag。返回所查找结点。
 *异常：传入的flag大于链表长度。
 *异常处理：给出提示“给定值大于链表长度，若跳过返回数值为头指针，Y：重新输入，其他键返回头指针”
 */
node* find_node ( node *head, const unsigned flag){
    if (0 == flag)  return head;

    unsigned judge_size = size_link(head);
    if (flag > judge_size ){     //如果输入flag大于链表长度
        cout << "给定值大于链表长度或小于0，若跳过返回数值为头指针，Y：重新输入，其他键返回头指针" << endl;
        char in_error;
        cin >> in_error;
        if ( 'Y' == in_error || 'y' == in_error ){
            int user_flag;
            cout << "查找的结点是： ";
            cin >> user_flag;
            return find_node(head, user_flag);
        } else {
            return head;
        }
    }

    //查找结点
    node *cursor = head;    //查找的结点
    unsigned i(1);
    while ( i != flag ){
        cursor = cursor->next;
        ++i;
    }
    return cursor;
}


/*add_node：向单向链表第user_flag个结点（flag从0计数）之后添加一个结点。--
 *用法：向函数传递头结点，user_flag， 用户想添加的结点的数据。返回头指针。
 *异常：用户提供user_flag大于链表长度。
 *异常处理：提示用户user_flag超出链表长度，重新进行输入或结束函数。
 */
node* add_node (node *head, const unsigned flag, const int user_in){
    if(0 == size_link(head)){
        node *add = (node *)malloc( sizeof(node) );
        add->data = user_in;
        add->next = 0;
        head = add;
        return head;
    }


    node *cursor = find_node(head, flag);
    node *add = (node *)malloc( sizeof(node) );
    add->data = user_in;
    add->next = cursor->next;
    cursor->next = add;
    return head;
}


/*push_back：在单向链表末尾添加一个结点。------------------
 *用法：向函数传递单向链表头节点，与结点数据项数值。返回头指针。
 */
node* push_back (node *head, int init_data){
    head = add_node(head, size_link(head), init_data);
    return head;
}


/*delete_node：删除单向链表的一结点。 ------------------------
 *用法：向函数传递头结点与删除的位置。返回头指针。
 *异常：输入flag为0。
 *异常处理：重新输入。
 */
node* delete_node (node* head, const unsigned flag){
    if ( 0 == flag ) {     //判断flag是否为0。
        cout << "输入不能为0。重新输入。" << endl;
        unsigned again_flag;
        cin >> again_flag;
        return delete_node(head, again_flag);
    }


    node *cursor = find_node(head, flag - 1);   //所给标记是结点的标记，释放的是上一个结点
                                                //next所指向的本结点的内存所以flag - 1
    node *_delete = cursor->next;   //要删除元素
    cursor->next = _delete->next;

    free(_delete);
    return head;
}


/*swap_node：交换链表中两结点。 ------------------------------
 *用法：传递头指针，两结点位置。返回头指针。
 */
node* swap_node (node *head, const unsigned flag1, const unsigned flag2){
    node *cursor1 = find_node(head, flag1);
    node *cursor2 = find_node(head, flag2);
    int temp = cursor1->data;
    cursor1->data = cursor2->data;
    cursor2->data = temp;

    return head;
}