链表 基本操作

#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;
}