Linked list（单链表）

不记得是大一还是大二开的《数据结构》，当时可真是可爱，按照我当时的想法就是这东西有什么用，目光短浅的我。。。学什么都是学这个有什么用啊？典型的一枚功利分子。

后来读了一些读物，了解到 数据结构 就是如何表示 数据 的一种形式，计算机什么是计算，计算就是机械式的信息处理，信息是什么，信息就是数字，一列列的 binary number。

但是在处理信息时，考虑到了 效率，人就是懒，不懒不进步。把信息以一种什么样的形式交给计算机，就可以立马得出 result。这就用到了 数据结构 + 算法，虽然算法还没看。。。

在GeeksforGeeks学DS，我也真的是有意思。

Linked list 单链表，优点和缺点也已经写过了。

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

//Linked list from FengSF
struct node
{
    int data;
    struct node * next;
};
void printList(struct node * n)
{
    while(NULL != n)
    {
        printf("%d	", n->data);
        n = n->next;
    }

}
//在头结点之前插入新节点
void push(struct node ** head_ref, int new_data)
{
    struct node * new_node = (struct node*) malloc(sizeof(struct node));

    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}
//链表中间插入新节点
void afterAdd(struct node * prev_node, int new_data)
{
    if(NULL == prev_node)
    {
        printf("ERROR!");
        return;
    }

    struct node * new_node = (struct node *) malloc (sizeof(struct node));
    new_node->data = new_data;
    new_node->next = prev_node->next;
    prev_node->next = new_node;
}
//在尾节点之后插入新节点
void endAdd(struct node ** head_ref, int new_data)
{
    struct node * new_node = (struct node *) malloc (sizeof(struct node));
    struct node * last = (*head_ref);
    new_node->data = new_data;
    new_node->next = NULL;

    if(NULL == (*head_ref))
    {
        (*head_ref) = new_node;
        return ;
    }

    while(NULL != last->next)
    {
        last = last->next;
    }

    last->next = new_node;
}
//移除结点通过data
void deleteElementByKey(struct node ** head_ref, int key)
{
    struct node * temp = (*head_ref), * pre;

    if(NULL != temp && temp->data  == key)
    {
        (*head_ref) = temp->next;
        free(temp);
        return ;
    }

    while(NULL != temp && temp->data != key)
    {
        pre = temp;
        temp = temp->next;
    }
    if(NULL == temp)
    {
        printf("The element isn`t exist!");
        return ;
    }
    pre->next = temp->next;
    free(temp);
}
//移除结点通过位置
void deleteElementByPosition(struct node ** head_ref, int position)
{
    struct node * temp = (*head_ref), * pre;
    int listLength = linkedListLength(temp);

    if(position < 0 && position > listLength)
    {
        printf("The position is error!");
        return ;
    }
    temp = (*head_ref);
    if(NULL != temp && 1 == position)
    {
        (*head_ref) = temp->next;
        free(temp);
        return ;
    }
    int times = 0;
    while(NULL != temp && (position-1) != times)
    {
        pre = temp;
        temp = temp->next;
        times++;
    }
    if(NULL == temp)
    {
        printf("The position %d isn`t exist! and the linkedlist`s length is %d
", position, listLength);
        return ;
    }
    pre->next = temp->next;
    free(temp);
}
//销毁链表
void destroyLinkedlist(struct node ** head_ref)
{
    struct node * current = (*head_ref), *next;

    while(NULL != current)
    {
        next = current->next;
        free(current);
        current = next;
    }

    (*head_ref) = NULL;
}
//链表的长度
int linkedListLength(struct node * head_ref)
{
    int length = 0;

    while(NULL != head_ref)
    {
        length++;
        head_ref = head_ref->next;
    }

    return length;
}
//搜索元素值是否存在于链表中
int searchElement(struct node * head_ref, int key)
{
    int judge;

    while(NULL != head_ref && key != head_ref->data)
    {
        head_ref = head_ref->next;
    }
    if(NULL == head_ref)
    {
        judge = 0;
        return judge;
    }

    judge = 1;
    return judge;
}
//通过结点的位置获取结点
struct node * getNodeByPosition(struct node * head_ref, int position)
{
    int length = linkedListLength(head_ref);

    if(NULL == head_ref)
    {
        printf("
 The linked list no elements");
    }
    if(position <= 0 && position > length)
    {
        printf("
 Error ");
        return ;
    }
    int times = 0;
    while(NULL != head_ref && times != position-1)
    {
        head_ref = head_ref->next;
        times++;
    }
    return head_ref;
}
//获取倒数的元素
struct node * getNodeByPositionFromLast(struct node * head_ref, int position)
{
    int length = linkedListLength(head_ref);

    if(NULL == head_ref)
    {
        printf("
 The linked list no elements");
    }
    if(-1 == boolPosition(head_ref, position))
    {
        printf("
Error");
    }

    for(int i = 0; i < length-position; i++)
    {
        head_ref = head_ref->next;
    }
    return head_ref;
}
//判断所求位置是否正确
int boolPosition(struct node * head_ref, int position)
{
    int length = linkedListLength(head_ref);

    if(position <= 0 && position > length)
    {
        return -1;
    }

    return 1;
}
//返回中间的元素
int findMiddleElement(struct node * head_ref)
{
    int length = linkedListLength(head_ref)/2 + 1;
    //int length1 = (length%2 == 0) ? length/2+1 : length/2+1;

    //printf("
length1 = %d and length = %d", length1, length);
    struct node * temp = getNodeByPosition(head_ref, length);
    return temp->data;
}
int findMiddleElement_2(struct node * head_ref)
{
    struct node * fast_ptr = head_ref;
    struct node * slow_ptr = head_ref;

    if(NULL == head_ref)
    {
        printf("
 ERROR");
        return -1;
    }
    while(NULL != fast_ptr && NULL != fast_ptr->next)
    {
        fast_ptr = fast_ptr->next->next;
        slow_ptr = slow_ptr->next;
    }

    return slow_ptr->data;
}
int findMiddleElement_3(struct node * head_ref)
{
    struct node * mid = head_ref;
    int counter = 0;

    while(NULL != head_ref)
    {
        if(counter & 1)
        {
            mid = mid->next;
        }

        counter++;
        head_ref = head_ref->next;
    }

    return mid->data;
}
//不用递归返回元素个数
int countWhithoutRecursion(struct node * head_ref, int key)
{
    int counter = 0;
    int length = linkedListLength(head_ref);

    if(-1 == headIsNULL(head_ref))
    {
        printf("The linked list is null!");
        return -1;
    }
    for(int i = 0; (i < length && head_ref != NULL); i++)
    {
        if(key == head_ref->data)
        {
            counter++;
            head_ref = head_ref->next;
        }
        else
        {
            head_ref = head_ref->next;
        }
    }

    return counter;
}
/*void sortList(struct node ** head_ref)
{
    struct node * temp = (*head_ref);
    struct node * pre = NULL;

    if(-1 == headIsNULL(*head_ref))
    {
        printf("ERROR!");
        return ;
    }
    else
    {
        if(temp->data > temp->next->data)
        {
            temp->next = temp->next->next;
            temp->next->next = temp;
            (*head_ref) = temp;
        }
        temp = (*head_ref);

        while(temp != NULL)
        {
            if(temp->data <= temp->next->data)
            {
                pre = temp;
                temp = temp->next;
            }
            else
            {
                pre->next = temp->next;
                temp->next = temp->next->next;
                temp->next->next = temp;
                temp =
            }
        }
    }
}*/
//判断是否为循环链表
int isCircular(struct node * head_ref)
{
    if(NULL == head_ref)
    {
        return 1;
    }

    struct node * temp = head_ref->next;

    while(temp != NULL && temp != head_ref)
    {
        temp = temp->next;
    }

    return (temp == head_ref) ? 1 : -1;
}
static int counter = 0;
//通过递归返回节点个数
int countWithRecursion(struct node * head_ref, int key)
{
    if(NULL == head_ref)
    {
        return counter;
    }
    if(key == head_ref)
    {
        counter++;
    }
    countWhithoutRecursion(head_ref->next, key);
}
//判断是否为空链表
int headIsNULL(struct node * head_ref)
{
    return (NULL == head_ref)? -1 : 1;
}
int main(void)
{
    struct node * first = NULL;
    struct node * second = NULL;
    struct node * third = NULL;

    first = (struct node *)malloc(sizeof(struct node));
    second = (struct node *)malloc(sizeof(struct node));
    third = (struct node *)malloc(sizeof(struct node));

    first->data = 1;
    first->next = second;

    second->data = 2;
    second->next = third;

    third->data = 3;
    third->next = NULL;

    endAdd(&first, 100);
    push(&first, 99);
    push(&first, 88);
    push(&first, 77);
    push(&first, 11);
    push(&first, 66);
    push(&first, 99);
    push(&first, 88);
    push(&first, 77);
    push(&first, 11);
    push(&first, 66);
    //destroyLinkedlist(&first);
    int length = linkedListLength(first);
    printList(first);
    printf("
The length of singly linked list is %d", length);
    printf("
 The value of bool is %d", searchElement(first, 44));
    struct node * temp = getNodeByPosition(first, 4);
    printf("
 The node`s value is %d", temp->data);
    struct node * temp1 = getNodeByPositionFromLast(first, 2);
    printf("
 The node`s value is %d", temp1->data);
    printf("
 The middle element of linked list is %d", findMiddleElement(first));
    printf("
 The middle element of linked list is %d", findMiddleElement_2(first));
    printf("
 The middle element of linked list is %d", findMiddleElement_3(first));
    printf("
 Count the %d is %d", 88, countWhithoutRecursion(first, 88));
    printf("
 Count the %d is %d", 88, countWhithoutRecursion(first, 88));
    printf("
 Count the %d is %d", 88, countWhithoutRecursion(first, 11));
    if(0 < isCircular(first))
    {
        printf("
The linked list is circularLinked list!------%d");
    }
    else
    {
        printf("
The linked list isn`t circularLinked list!");
    }
    return 0;
}

受益良多