C语言单链表-19个功能函数

线性表链接存储（单链表）操作

刚开始学习数据结构，找点题目练手，题目和部分源码参考 http://www.cnblogs.com/lifuqing/archive/2011/08/20/list.html

注意问题：

1. 采用vs2012开发，由于vs不支持C99标准，因此申明变量必须位于运算语句之前

2. 链表没有设置头结点（第一个结点包含元素值）

3. 对链表指针的编写有些混乱（如有的 Node* L, 有的用Node** ），注意区分

4. 链表的排序没能编写成功，（后续应多联系链表，并着重学习一下排序）

/************************************************************************//*             以下是关于线性表链接存储（单链表）操作的18种算法        */ /* 1.初始化线性表，即置单链表的表头指针为空 *//* 2.创建线性表，此函数输入负数终止读取数据*//* 3.打印链表，链表的遍历*//* 4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表 *//* 5.返回单链表的长度 *//* 6.检查单链表是否为空，若为空则返回１，否则返回０ *//* 7.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行 *//* 8.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL *//* 9.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０ *//* 10.向单链表的表头插入一个元素 *//* 11.向单链表的末尾添加一个元素 *//* 12.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０ *//* 13.向有序单链表中插入元素x结点，使得插入后仍然有序 *//* 14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行 *//* 15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行 *//* 16.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行 *//* 17.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0 *//* 18.交换2个元素的位置 *//* 19.将线性表进行快速排序 */

list_link.h

#ifndef LINK_LIST_H#define LINK_LIST_H#include<stdlib.h>#include <string.h>#include <stdio.h>typedef int elemType;typedef struct Node    {     elemType element;      struct Node *next;    } Node;void init_list(Node *L);Node * creat_list();int print_list(Node *L);Node * clear_list(Node *L);int length_list(Node *L);int isEmpty_list(Node *L);elemType get_pos_element(Node *L, int pos);Node* get_pos_prev_address(Node *L, int pos);Node *get_element_position(Node* L, elemType x);Node *get_element_prev_position(Node* L, elemType x);int modify_element(Node* L, int pos, elemType x);void insert_head_node(Node **L, elemType x);void insert_end_node(Node **L, elemType x);int insert_pos_list(Node **L, int pos, elemType x);int insert_element_to_sorted_list(Node **L, elemType x);elemType delete_head_node(Node **L);elemType delete_end_node(Node **L);elemType delete_pos_node(Node **L, int pos);int delete_element_node(Node **L, elemType x);void swap_element_position(Node**L, elemType x, elemType y);int sort_list(Node **L);#endif // LINK_LIST_H

link_list.c

#include "link_list.h"/* 1.初始化线性表，即置单链表的表头指针为空 */void init_list(Node * L){L = NULL;printf("初始化链表成功！\n");}/* 2.创建线性表，此函数输入负数终止读取数据*/Node * creat_list(){Node * L = NULL;Node *p1, *p2;p1 = ( Node *)malloc(sizeof(struct Node));p2 = ( Node *)malloc(sizeof(struct Node));if(p1 == NULL || p2 == NULL){printf("内存分配失败！\n");exit(0);system("pause");}memset(p1, 0, sizeof(struct  Node));printf("请输入链表元素的值：");scanf("%d",&(p1->element));p1->next = NULL;//while(p1->element > 0)while(p1->element > 0){if( L == NULL){L = p1;}else{p2->next = p1;}p2 = p1;p1 = ( Node *)malloc(sizeof(struct Node));if(p1 == NULL || p2 == NULL){printf("内存分配失败！\n");exit(0);system("pause");}memset(p1, 0, sizeof(struct  Node));printf("请输入链表元素的值：");scanf("%d",&(p1->element));p1->next = NULL;}printf("创建链表成功！\n");return L;}/* 3.打印链表，链表的遍历*/int print_list(Node * L){Node *p = L;if (NULL == p){printf("print_list:链表为空!\n");return 0;}printf("打印链表如下：\n");while (p != NULL){printf("%d, ",p->element);p = p->next;}printf("\n");return 0;}/* 4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表 */Node* clear_list(Node *L){Node *p = L;Node *temp = NULL;printf("clear_list运行成功！\n");if (p == NULL){printf("链表为空，不需清空\n");exit(0);}while (p != NULL){temp = p->next;free(p);p = temp;}L =NULL;printf("已清空链表！\n");return L;}/* 5.返回单链表的长度 */int length_list(Node *L){int count = 0;printf("length_list运行成功！\n");if (L == NULL){printf("链表为空,长度为0\n");return 0;}while( L != NULL){++count;L = L->next;}return count;}/* 6.检查单链表是否为空，若为空则返回１，否则返回０ */int isEmpty_list(Node *L){printf("isEmpty_list运行成功！\n");if (L == NULL){printf("链表为空！\n");return 1;}else{printf("链表非空！\n");return 0;}}/* 7.1 返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行 */elemType get_pos_element( Node *L, int pos ){int i = 1;if (L == NULL){printf("get_pos_element()运行成功，链表为空, 获取元素失败！\n");system("pause");exit(0);}if (pos < 1){printf("get_pos_element()运行成功，给定节点数非法！\n");system("pause");exit(0);}while(L != NULL){if ( i == pos){printf("get_pos_element()运行成功，第%d个节点元素为%d！\n", pos, L->element);return L->element;}L = L->next;++i;}printf("get_pos_element()运行成功，超出查找范围！\n");system("pause");exit(0);}/* 7.2 返回单链表中第pos个结点的前一个地址，方便在pos位置上插入元素，若pos超出范围，则停止程序运行 */Node* get_pos_prev_address(Node *L, int pos){Node *prev = NULL;int i = 1;if (L == NULL){printf("get_pos_address()运行成功，链表为空, 获取元素失败！\n");system("pause");return NULL;}if (pos < 1){printf("get_pos_address()运行成功，给定节点数非法, 获取元素失败！\n");system("pause");return NULL;}while(L != NULL){if ( i == pos){printf("get_pos_address()运行成功，第%d个节点元素前一结点的地址为0x%x！\n", pos, L);//return L;  //若返回L，则方便在pos的后一个位置插入元素return prev; //返回pos的前一个地址，方便在pos位置上插入元素}prev = L;L = L->next;++i;}printf("get_pos_address()运行成功，超出查找范围！\n");system("pause");return NULL;}/* 8.1 从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL */Node * get_element_position( Node* L, elemType x ){if (L == NULL){printf("get_element_position运行成功，链表为空, 获取元素失败！\n");system("pause");exit(0);}while (L != NULL){if ( L->element == x){printf("get_element_position运行成功，该链表中元素%d的地址为0x%x\n", x, L);return L;}L = L->next;}printf("get_element_position运行成功，该链表不含有元素%d\n",x);return NULL;}/* 8.2 从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点前一结点data域的存储地址，否则返回NULL */Node * get_element_prev_position( Node* L, elemType x ) //和8.2程序只有返回值的不同{Node *prev = NULL;if (L == NULL){printf("get_element_prev_position运行成功，链表为空, 获取元素失败！\n");system("pause");exit(0);}while (L != NULL){if ( L->element == x){printf("get_element_prev_position运行成功，该链表中元素%d前一结点的地址为0x%x\n", x, L);return prev;}prev = L;L = L->next;}printf("get_element_prev_position运行成功，该链表不含有元素%d\n",x);return NULL;}/* 9.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０ */int modify_element(Node* L, int pos, elemType x){int i = 1;if (L == NULL){printf("modify_element函数运行成功，链表为空, 修改失败！\n");system("pause");return 0;}if (pos < 1){printf("modify_element函数运行成功，给定节点非法！\n");system("pause");return 0;}while(L != NULL){if ( i == pos){L->element = x;printf("modify_element函数运行成功，已更换第%d个节点为 %d！\n", pos, x);return 1;}L = L->next;++i;}printf("modify_element函数运行成功，超出查找范围！\n");system("pause");return 0;}/* 10.向单链表的表头插入一个元素 */void insert_head_node( Node **L, elemType x ){Node *insert_node;insert_node = (Node*)malloc(sizeof(Node));insert_node->element = x;insert_node->next = *L;*L = insert_node;printf("insert_head_list运行成功,向表头添加元素%d！\n", x);}/* 11.向单链表的末尾添加一个元素 */void insert_end_node(Node **L, elemType x){Node *insert_node, *last = NULL;Node *p = (*L);insert_node = (Node*)malloc(sizeof(Node));while (p != NULL){last = p;p = p->next;}last->next = insert_node;insert_node->element = x;insert_node->next = NULL;printf("insert_end_list运行成功,向末尾添加元素%d！\n", x);}/* 12.向单链表中第pos个结点位置插入元素为x的结点，成功返回1， 失败返回0 */int insert_pos_list(Node **L, int pos, elemType x){Node *insert_node = (Node *)malloc(sizeof(Node));Node *pos_node = get_pos_prev_address(*L, pos);if (pos_node == NULL){printf("insert_pos_list已运行，但向第%d个节点处添加元素%d时失败，请查看上述提示\n",pos, x);return 0;}insert_node->element = x;insert_node->next = pos_node->next;pos_node->next = insert_node;printf("insert_pos_list运行,向第%d个节点处添加元素%d 成功！\n", pos, x);return 1;}/* 13.向有序单链表中插入元素x结点，使得插入后仍然有序 */int insert_element_to_sorted_list(Node **L, elemType x){int sort_type = 0; //升序排列为1，降序为0int ret = 1; //标志位，判断是否为异常情况elemType first;Node *p = *L;Node *left = NULL, *right = NULL, *temp = NULL;Node *insert_node = (Node *)malloc(sizeof(Node));insert_node->element = x;if (p == NULL){printf("insert_element_to_sorted_list运行，链表为空，插入失败\n");return 0;}if ( p->next == NULL) //只有一个元素时{printf("insert_element_to_sorted_list运行，链表只有一个元素，插入成功\n");insert_head_node(L, x);return 1;}first = p->element;if (p->element >= p->next->element) //根据1st >= 2nd 降序{sort_type = 1;}//降序时x>=max, 升序时x <= min 应该将x插入表头if (sort_type && (x >= first)){insert_head_node(L, x);ret = 0; //标志位置0，跳过while}if ( (!sort_type) &&  x <= first){insert_head_node(L, x);ret = 0; //标志位置0，跳过while}while(ret && p != NULL){//升序排列时，right首先非0if(x < p->element ) right = p;elseleft = p;// x 左右一大一小时，插入xif (left != NULL && right != NULL){if (sort_type) //降序，right在insert_node前面，left在后；{insert_node->next = right->next;right->next = insert_node;}else //升序，left在前，right在后{insert_node->next = left->next;left->next = insert_node;}break;//插入成功，跳出循环}p = p->next;} //while//降序时x<min, 升序时x > max 应该将x插入表尾if (p == NULL){insert_end_node(L, x);}printf("insert_element_to_sorted_list运行，插入元素%d成功\n",x);return 1;}/* 14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行 */elemType delete_head_node(Node **L){elemType head_element;Node *head = NULL;if(*L == NULL){printf("delete_head_node执行，此链表为空，删除失败, 程序将终止运行\n");system("pause");exit(0);}head = *L;head_element = head->element;*L = head->next;free(head);printf("delete_head_node执行，删除表头结点元素%d 成功\n",head_element);return head_element;}/* 15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行 */elemType delete_end_node(Node **L){elemType end_element;Node *p = *L, *prev = NULL;if(p == NULL){printf("delete_end_node执行，此链表为空，删除失败, 程序将终止运行\n");system("pause");exit(0);}while(p->next != NULL){prev = p;p = p->next;}end_element = p->element;if ( prev != NULL)//链表只有一个元素时，prev == NULL{prev->next = NULL;}else *L = NULL; //只有一个元素，将表头置空free(p);printf("delete_end_node执行，删除表尾结点元素%d 成功\n",end_element);return end_element;}/* 16.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行 */elemType delete_pos_node(Node **L, int pos){elemType delete_node_element;Node *delete_node = NULL;Node *pos_prev_node = NULL;if(*L == NULL){printf("delete_pos_node执行，此链表为空，删除失败, 程序将终止运行\n");system("pause");exit(0);}pos_prev_node = get_pos_prev_address(*L, pos);if(pos_prev_node == NULL){printf("delete_pos_node执行，查找第%d个结点失败，删除失败, 程序将终止运行\n", pos);exit(0);}delete_node = pos_prev_node->next;pos_prev_node->next = delete_node->next;delete_node_element = delete_node->element;free(delete_node);printf("delete_pos_node执行，删除第%d个结点（其元素值为%d）成功, 程序将终止运行\n", pos, delete_node_element);return delete_node_element;}/* 17.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0 */int delete_element_node(Node **L, elemType x){Node *delete_node = NULL;Node *x_prev_node = NULL;if(*L == NULL){printf("delete_pos_node执行，此链表为空，删除失败\n");return 0;}x_prev_node = get_element_prev_position(*L, x);if(x_prev_node == NULL){printf("delete_element_node执行，查找结点元素%d失败，删除失败\n", x);return 0;}delete_node = x_prev_node->next;x_prev_node->next = delete_node->next;free(delete_node);printf("delete_element_node执行，删除元素值为%d的结点成功, 程序将终止运行\n", x);return 1;}/* 18.交换2个元素的位置 */void swap_element_position(Node**L, elemType x, elemType y){Node *x_prev_node = NULL, *y_prev_node = NULL, *x_node = NULL, *y_node = NULL, *temp = NULL;Node *head = NULL;elemType first = (*L)->element;if ( *L ==NULL ){printf("swap_element_position运行，链表为空，终止运行\n");}/*===由于采用返回查找元素前一结点的地址，因此表头节点需要单独考虑===*/if ( first ==x ){y_prev_node = get_element_prev_position(*L, y);y_node = y_prev_node->next;x_node = *L;temp = y_node->next;y_prev_node->next = x_node;y_node->next =  x_node->next;*L = y_node;x_node->next = temp;}else if( first == y){x_prev_node = get_element_prev_position(*L, x);x_node = x_prev_node->next;y_node = *L;temp = x_node->next;x_prev_node->next = y_node;x_node->next =  y_node->next;*L = x_node;y_node->next = temp;}else //一般情况，x, y 都不在表头{x_prev_node = get_element_prev_position(*L, x);y_prev_node = get_element_prev_position(*L, y);if (x_prev_node != NULL && y_prev_node != NULL) //画出结点连接图，易懂{y_node = y_prev_node->next;x_node = x_prev_node->next;temp = y_node->next;y_prev_node->next = x_node;y_node->next =  x_node->next;x_prev_node->next = y_node;x_node->next = temp;}}printf("交换元素%d和%d成功！\n", x, y);}/* 19.将线性表进行快速排序 */int sort_list(Node **L) //有错误，仍需修改{Node *x = NULL, *y = NULL;Node *p = NULL, *f = NULL, *head = *L;if ( p == NULL || p->next == NULL){}f = NULL;  //判断是否只有一个元素或者没有元素  if(head == NULL || head  -> next == NULL)  {  printf("sort_list运行，链表为空or只有一个元素，终止运行\n");return;  }  while(f != head->next)  {  for(p = head; p -> next -> next != f; p = p -> next)  {  if(p -> next -> element > p -> next -> next ->element)  {  x = p -> next;  y = p -> next -> next;  p -> next = y;  x -> next = y -> next;  y -> next = x;  }  }  f = p -> next;  }  //*L = p;printf("升序排列完成\n");}

main.c

#include "link_list.h"int main(){int n;Node * L = NULL;Node *p = NULL;init_list(L);length_list(L);isEmpty_list(L);L = creat_list();length_list(L);insert_element_to_sorted_list(&L, 5);print_list(L);swap_element_position(&L, 2, 5);print_list(L);sort_list(&L);print_list(L);delete_element_node(&L, 3);print_list(L);delete_pos_node(&L, 2);print_list(L);delete_head_node(&L);print_list(L);delete_end_node(&L);print_list(L);insert_head_node(&L, 200);insert_end_node(&L, 400);print_list(L);insert_pos_list(&L, 2, 50);insert_pos_list(&L, 6, 40);print_list(L);n = get_pos_element(L, 3);printf("第3个元素为%d\n",n);modify_element(L, 3, 100);print_list(L);modify_element(L, 5, 100);print_list(L);modify_element(L, 0, 100);print_list(L);p = get_element_position(L, 3);printf("元素3的地址：%x\n",p);p = get_element_position(L, 10);printf("元素10的地址：%x\n",p);isEmpty_list(L);n = length_list(L);printf("链表长度为：%d\n", n);print_list(L);L = clear_list(L);system("pause");return 0;}