单链表的创建、插入、删除、查找

  #返回上一级

@Author: 张海拔

@Update: 2014-01-23

@Link: http://www.cnblogs.com/zhanghaiba/p/3530532.html

/*
 *Author: ZhangHaiba
 *Date: 2014-1-22
 *File: single_linked_list.c
 *
 *single linked list demo
 */

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#define INF 0x7fffffff
#define CMD_LNE 128

typedef struct node* link;
typedef struct node {
    int item;
    link next;
}node;

//public
link NODE(int item, link next);
link list_create(int n);
link list_reverse_create(int n);
bool list_insert(link head, int pos, int item);
bool list_delete(link head, int pos);
link list_search(link head, int item);
void list_travel(link head);
int list_length(link head);
void list_destroy(link head);


int main(void)
{
    int n;
    int pos, item;
    char cmd[CMD_LNE];

    printf("Create list reversely enter '1', or naturally enter '0'.
");
    int creation_mode;
    scanf("%d", &creation_mode);
    printf("Now we are gonna create list_a made by n nodes, please assign value of n:
");
    scanf("%d", &n);
    printf("Enter values of n items: 
");
    link list_a = creation_mode == 1 ? list_reverse_create(n) : list_create(n);
    printf("The length of list_a is %d
", list_length(list_a));
    printf("Now you can operate link_a by using command line.
");
    bool flag = true;
    while(flag) {
        scanf("%s", cmd);
        switch(cmd[0]) {
            case 'i':
            scanf("%d%d", &pos, &item);
            if (list_insert(list_a, pos, item))
                  printf("Inserted successfully!
");
            else
                printf("Insert failed! -- check pos
");
            break;
            case 'd':
            scanf("%d", &item);
            if (list_delete(list_a, item))
                printf("Delete successfully!
");
            else
                printf("Delete failed! -- check pos
");
            break;
            case 's':
            scanf("%d", &item);
            link ans = list_search(list_a, item);
            ans == NULL ? printf("Not found!
") : printf("Found item %d
", ans->item); 
            break;
            case 't':
            list_travel(list_a);
            break;
            case 'q':
            list_destroy(list_a);
            printf("list_a have been destroy!
");
            flag = false;
            break;
            default:
            break;
        }
    } //while
    return 0;
}


link NODE(int item, link next)
{
    link born = malloc(sizeof (node));
    born->item = item;
    born->next = next;
    return born;
}

//create by 'tail insert'
link list_create(int n)
{
    int i, item;
    link head = NODE(INF, NULL);
    link tail = head;

    for (i = 0; i < n; ++i) {
        scanf("%d", &item);
        tail->next = NODE(item, NULL);
        tail = tail->next;
    }
    return head;
}

//create by 'head insert'
link list_reverse_create(int n)
{
    int i, item;
    link head = NODE(INF, NULL), tmp;

    for (i = 0; i < n; ++i) {
        scanf("%d", &item);
        tmp = head->next;
        head->next = NODE(item, tmp);
    }
    return head;
}

int list_length(link head)
{
    int cnt = 0;

    for (head = head->next; head != NULL; head = head->next)
        ++cnt;
    return cnt;
}

bool list_insert(link head, int pos, int item)
{
    //illegal position: insert nothing
    if (pos < 0 || pos > list_length(head))
        return false;
    while (pos--)
        head = head->next;
    link tmp = head->next;
    head->next = NODE(item, tmp);
    return true;
}

bool list_delete(link head, int pos)
{
    //illegal position: delete nothing
    if (pos < 0 || pos > list_length(head)-1)
        return false;
    while (pos--)
        head = head->next;
    link save = head->next;
    head->next = save->next;
    free(save);
    return true;
}

link list_search(link head, int item)
{
    for (head = head->next; head != NULL; head = head->next)
        if (head->item == item)
            return head;
    return NULL;
}

void list_travel(link head)
{
    for (head = head->next; head != NULL; head = head->next)
        printf(head->next == NULL ? "%d
" : "%d ", head->item);
}

void list_destroy(link head)
{
    head->next == NULL ? free(head) : list_destroy(head->next);
}

测试示范：

ZhangHaiba-MacBook-Pro:code apple$ ./a.out
Create list reversely enter '1', or naturally enter '0'.
1
Now we are gonna create list_a made by n nodes, please assign value of n:
6
Enter values of n items: 
534 31 525 62 12 68
The length of list_a is 6
Now you can operate link_a by user command.
t
68 12 62 525 31 534
i 0 44
Inserted successfully!
t
44 68 12 62 525 31 534
i 8 99
Insert failed! -- check pos
i 7 99
Inserted successfully!
t
44 68 12 62 525 31 534 99
d -1
Delete failed! -- check pos
d 0
Delete successfully!
t
68 12 62 525 31 534 99
d 7
Delete failed! -- check pos
d 6
Delete successfully!
t
68 12 62 525 31 534
s 11
Not found!
s 68
Found item 68
s 534
Found item 534
q
list_a have been destroy!

对于带头节点的单链表的实现，值得注意的是，头插法和尾插法是相对创建方式而言，没有单独成为一个方法（函数）的必要。

而且这里提供了支持任意位置插入的函数list_insert()。

链式数据结构都是动态分配的空间，所有必须提供销毁函数（类似C++的析构函数）。这里的销毁函数联系到二叉树，可以看做是一叉树的后根（后序）遍历。

上述实现只有销毁函数是递归实现的，而其他函数都是迭代实现的，尽管递归实现也很自然，但考虑到用户空间栈有限，容易迭代实现的一律优先用迭代实现。

list_insert()和list_delete()函数返回bool类型是考虑到要对pos做边界检查。另外，C99的_Bool类型实在不怎么好看，而且没有定义true/false，所以还是用<stdbool>。

对于位置参数pos，其正确性应该由客户端或说API调用者负责。

   #返回上一级