C语言数据结构：单向链表

线性表是最常用且最简单的一种数据结构。一个线性表是多个数据元素的序列，数据元素的具体含义可以根据自己的情况实现，而一个数据元素又可以由若干个数据项组成。下面用单向链表的方式实现线性表，数据元素仅有一个int型变量和指向下一节点的数据指针。程序的功能有插入，删除，修改，判断相等的数据是否存在，计算链表长度，根据位置返回节点值，排序和就地逆置。

#include <stdio.h>
#include <stdlib.h>

typedef struct _listNode{
    int value;
    struct _listNode * next;
}listNode, *pListNode;

pListNode List_create(int);

void List_destroy(pListNode head);

int List_getListLength(pListNode head);

int List_getNode(pListNode head, int pos, pListNode myNode);
// 0 presents no node at pos

int List_isExisting(pListNode head, pListNode myNode);
// 0 presents not exist, positive number is the position of the same-value node

pListNode List_insert(pListNode head, int pos, pListNode myNode);
// insert node at pos

pListNode List_delete(pListNode head, int pos, pListNode myNode);

void List_union(pListNode head1, pListNode head2);
// head1 is the new list

void List_modify(pListNode head, int pos, pListNode myNode);
// replace node contents at pos with myNode

pListNode List_ascendingSort(pListNode head);

pListNode List_localReverse(pListNode head);

void List_displayAll(pListNode head);

int main()
{
    // these are test nodes
    pListNode insert0 = List_create(0);
    pListNode insert_1 = List_create(-1);
    pListNode insert2 = List_create(2);
    pListNode insert9 = List_create(9);

    // head node
    pListNode head = List_create(5);
    List_displayAll(head);

    // test insert operation
    // insert before head
    head = List_insert(head, 1, insert0);
    printf("insert 0 before head.\n");
    List_displayAll(head);
    // insert between
    head = List_insert(head, 2, insert_1);
    printf("insert -1 at pos 2.\n");
    List_displayAll(head);
    // insert at tail
    head = List_insert(head, 4, insert2);
    printf("insert 2 at tail.\n");
    List_displayAll(head);
    head = List_insert(head, 4, insert9);
    printf("insert 9 at pos 4.\n");
    List_displayAll(head);
    printf("\n");

    // test get length operation
    int len = List_getListLength(head);
    printf("list length is: %d\n\n", len);

    // test get node operation
    pListNode temp = List_create(0);
    printf("temp node value is: %d\n", temp->value);
    List_getNode(head, 2, temp);
    printf("after get node operation with pos 2, temp value is: %d\n", temp->value);
    printf("before modify:\n");
    List_displayAll(head);
    printf("after modify with value %d at pos 1:\n", temp->value);
    List_modify(head, 1, temp);
    List_displayAll(head);
    printf("\n");

    // test is existing operation
    int pos = List_isExisting(head, temp);
    printf("is existing operation with value -1, result is: %d\n\n", pos);

    // test delete operation
    // delete head
    head = List_delete(head, 1, temp);
    printf("delete head.\n");
    List_displayAll(head);
    head = List_delete(head, 2, temp);
    printf("delete node with pos 2.\n");
    List_displayAll(head);
    head = List_delete(head, List_getListLength(head), temp);
    printf("delete tail.\n");
    List_displayAll(head);
    printf("\n");

    // test union operation
    pListNode head1 = List_create(10);
    pListNode node = List_create(21);
    head1 = List_insert(head1, 1, node);
    printf("list 2 is: \n");
    List_displayAll(head1);
    printf("after union operation:\n");
    List_union(head, head1);
    List_displayAll(head);
    printf("\n");

    // test ascending operation
    printf("after ascending operation:\n");
    head = List_ascendingSort(head);
    List_displayAll(head);
    printf("\n");

    // test local reverse operation
    printf("after local reverse operation:\n");
    head = List_localReverse(head);
    List_displayAll(head);
    printf("\n");

    // test destroy operation
    printf("after destroy operation:\n");
    List_destroy(head);
    printf("head value is invalid: %d\n\n", head->value);

    system("pause");

    return 0;
}

pListNode List_create(int value){
    pListNode head = (pListNode)malloc(sizeof(listNode));
    if(head == NULL){
        printf("Have no space for head node.\n");
    }
    head->value = value;
    head->next = NULL;
    return head;
}

void List_destroy(pListNode head){
    pListNode previous = NULL, current = head;
    while(current != NULL){
        previous = current;
        current = current->next;
        free(previous);
    }

}

int List_getListLength(pListNode head){
    int count = 0;
    pListNode current = head;
    while(current != NULL){
        current = current->next;
        count++;
    }
    return count;
}

// 0 presents no node at pos
int List_getNode(pListNode head, int pos, pListNode myNode){
    if(pos < 1 || pos >= List_getListLength(head)){
        printf("wrong position when get node.\n");
        return 0;
    }
    int i = 1;
    pListNode current = head;
    while(i != pos){
        current = current->next;
        i++;
    }
    myNode->value = current->value;
    myNode->next = NULL;
    return 1;
}

// 0 presents not exist, positive number is the position of the same-value node
int List_isExisting(pListNode head, pListNode myNode){
    int pos = 0, tag = 0;
    pListNode current = head;
    while(current != NULL){
        pos++;
        if(current->value == myNode->value){
            tag = 1;
            break;
        }
        current = current->next;
    }
    if(tag == 0){
        pos = 0;
    }
    return pos;
}

// insert myNode at pos
pListNode List_insert(pListNode head, int pos, pListNode myNode){
    if(pos < 1 || pos > List_getListLength(head)+1){
        printf("wrong position when insert node.\n");
        return head;
    }
    // insert before head
    if(pos == 1){
        myNode->next = head;
        head = myNode;
        return head;
    }
    // insert into the list
    int i = 1;
    pListNode previous = NULL, current = head;
    while(current != NULL){
        previous = current;
        current = current->next;
        i++;
        if(i == pos){
            break;
        }
    }
    previous->next = myNode;
    myNode->next = current;
    return head;
}

pListNode List_delete(pListNode head, int pos, pListNode myNode){
    if(pos < 1 || pos > List_getListLength(head)){
        printf("wrong position when delete node.\n");
        return head;
    }
    // judge if list is empty
    if(head == NULL){
        printf("list is empty, can't be delete.\n");
        return head;
    }
    // delete head
    pListNode current = head;
    if(pos == 1){
        head = head->next;
        free(current);
        return head;
    }
    // other situation
    int i = 1;
    for(i = 1; i < pos - 1; i++){
        current = current->next;
    }
    pListNode deleteNode = current->next;
    current->next = deleteNode->next;
    myNode->value = deleteNode->value;
    free(deleteNode);
    return head;
}

// head1 is the new list
void List_union(pListNode head1, pListNode head2){
    if(head1 == NULL){
        printf("parameter is type of NULL, exit.\n");
        return;
    }
    pListNode current = head1;
    for(; current->next != NULL; current = current->next);
    current->next = head2;
}

// replace node contents at pos with myNode
void List_modify(pListNode head, int pos, pListNode myNode){
    if(head == NULL || myNode == NULL){
        printf("head or node is type of NULL, exit.\n");
        return;
    }
    if(pos < 1 || pos > List_getListLength(head)){
        printf("wrong position when modify node.\n");
        return;
    }
    int i = 1;
    pListNode current = head;
    for(; i < pos; i++, current = current->next);
    current->value = myNode->value;
}

pListNode List_ascendingSort(pListNode head){
    if(head == NULL){
        printf("head is NULL.\n");
        return head;
    }
    // bubble sort
    pListNode current = head;
    int temp = 0;
    int i = 0, j = 0, k = List_getListLength(head);
    for(i = 0; i < k; i++){
        current = head;
        for(j = 0; j < i; j++){
            current = current->next;
        }
        for(j = i; j < k-1; j++){
            if(current->value > current->next->value){
                temp = current->value;
                current->value = current->next->value;
                current->next->value = temp;
            }
            current = current->next;
        }
    }
    return head;
}

pListNode List_localReverse(pListNode head){
    pListNode p = head, q = NULL;
    head = NULL;
    while(p){
        q = p->next;
        p->next = head;
        head = p;
        p = q;
    }
    return head;
}

void List_displayAll(pListNode head){
    if(head == NULL){
        printf("head is NULL, exit\n");
        return;
    }
    pListNode current = head;
    printf("list is: ");
    for(; current != NULL; current = current->next){
        printf("\t%d", current->value);
    }
    printf("\n");
}

下面是测试结果

list is:        5
insert 0 before head.
list is:        0       5
insert -1 at pos 2.
list is:        0       -1      5
insert 2 at tail.
list is:        0       -1      5       2
insert 9 at pos 4.
list is:        0       -1      5       9       2

list length is: 5

temp node value is: 0
after get node operation with pos 2, temp value is: -1
before modify:
list is:        0       -1      5       9       2
after modify with value -1 at pos 1:
list is:        -1      -1      5       9       2

is existing operation with value -1, result is: 1

delete head.
list is:        -1      5       9       2
delete node with pos 2.
list is:        -1      9       2
delete tail.
list is:        -1      9

list 2 is:
list is:        21      10
after union operation:
list is:        -1      9       21      10

after ascending operation:
list is:        -1      9       10      21

after local reverse operation:
list is:        21      10      9       -1

after destroy operation:
head value is invalid: 7025048