数据结构之单链表常见操作 C

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define N 15

typedef struct node
{
    int data;
    struct node *next;
}node,*linklist;

//初始化单链表
int creat_list(linklist *list)
{
    *list = (linklist)malloc(sizeof(list));
    if (!(&list))
    {
        return -1;
    }
    (*list)->next = NULL;
    return 1;
}

/*头插建表*/
void head_insert_list(linklist *list)
{
    int i;
    linklist p = *list;
    linklist ptemp;
    srand(time(0));
    for (i = 1; i < N; i++)
    {
        ptemp = (linklist)malloc(sizeof(list));
        ptemp->data = rand() % 100;
        ptemp->next = p->next;
        p->next = ptemp;    
    }
}
/*求出单链表长度*/
int list_length(linklist list)
{
    linklist p = list;
    p = p->next;
    int count = 0;
    while (p != NULL)
    {
        count++;
        p = p->next;
    }
    return count;
}
/*尾插*/
void tail_insert_list(linklist *list)
{
    int i;
    linklist p = *list;
    linklist ptemp;
    for ( i = 1; i < N; i++)
    {
        ptemp = (linklist)malloc(sizeof(list));
        ptemp->data = i;
        p->next = ptemp;
        p = ptemp;
    }
    p->next = NULL;
}

/*第i处插入一个元素*/
int insert_i_list(linklist* list, int i, int elem)
{
    int count = 0;
    linklist p = *list;
    linklist s = (linklist)malloc(sizeof(list));
    s->data = elem;
    s->next = NULL;
    p = p->next;

    while (p != NULL && count < i)
    {
        count++;
        p = p->next;
    }
    if (p!=NULL)
    {
        s->next = p->next;
        p->next = s;
    }
    else
    {
        return -1;
    }

    return 1;
}

/*链表删除某个元素*/
int delete_elem(linklist *list, int elem)
{
    linklist p = *list;
    linklist q;
    if (p->next == NULL)
    {
        printf("空表！\n");
        return -1;
    }
    else
    {
        while (p->next != NULL)
        {
            if (elem == p->next->data)
            {
                q = p->next;
                p->next = q->next;
                q = NULL;
                free(q);
            }
            p = p->next;
            if (p == NULL)
            {
                return -1;
            }
        }
    }
    return 1;
}

void print_list(linklist list)
{
    linklist p = list->next;
    while (p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

/*获取单链表指定位置的元素*/
int get_i_elem(linklist list, int n)
{
    int i;
    linklist p = list;

    if (n > list_length(list))
    {
        printf("n太大，去火星找吧\n");
        return -1;
    }
    while (p->next != NULL)
    {
        for ( i = 0; i < n; i++)
        {
            p = p->next;
        }

        if (NULL == p)
        {
            return -1;
        }
        else
        {
            printf("第%d个数是%d \n", n,p->data);
            break;
        }
    }
    return 1;
}

//链表置为空表
int empty_list(Linklist* list)
{
    Linklist p = (*list);
    Linklist ptemp;

    if ((*list)->next == NULL)
        return -1;
    p = p->next;
    while (p != NULL)
    {
        ptemp = p->next;
        free(p);
        p = ptemp;
    }
    p = NULL;

    (*list)->next = NULL;
    return 0;
}

/*单链表倒数第n个数*/
int get_daoshu_n(linklist list, int n)
{
    linklist p;
    linklist q;
    int count = 0;

    p = list->next;
    q = list->next;
    if (p == NULL)
    {
        return 0;
    }

    while (p != NULL)
    {
        count++;
        p = p->next;
        if (count > n)
        {
            q = q->next;
        }
    }
    printf("倒数第%d个数是%d\n",n, q->data);
    return 1;
}

/*标尺--链表中间结点*/
int find_mid_node(linklist list)
{
    linklist p;
    linklist q;
    p = list->next;
    q = list->next;
    if (p == NULL)
    {
        return 0;
    }
    while (q->next != NULL )
    {
        if (q->next->next != NULL)
        {
            q = q->next->next;
            p = p->next;
        }
        else
        {
            q = q->next;
        }
    }
    printf("中间结点：%d \n",p->data);

    return 1;
}

/*逆置1*/
int reverse_list_1(linklist list)
{
    /*  1      2        3     4
    **  pcur   pnext   prev
    **/
    if ((list) == NULL || (list)->next == NULL)
    {
        return -1;
    }
    linklist pcur = (list)->next;/*第一个结点*/
    linklist pnext = pcur->next;
    linklist prev ;
    pcur->next = NULL;/*!!!!!将第一个结点的后继置为0*/

    while (pnext != NULL)
    {
        prev = pnext->next;
        pnext->next = pcur;
        pcur = pnext;
        pnext = prev;
    }
    (list)->next = pcur;/*链表头结点指向pcur*/

    return 1;
}

/*逆置2*/
int reverse_list_2(linklist list)
{
    linklist p, pcur;
    if (list == NULL)
    {
        return -1;
    }
    pcur = list->next;
    while (pcur->next != NULL)
    {
        p = pcur->next;
        pcur->next = p->next;
        p->next = list->next;
        list->next = p;
    }
    return 1;
}

/*删除重复元素*/
int delete_dup_elem(linklist list)
{
    linklist p;
    linklist q;
    linklist temp = NULL;

    if (list == NULL)
    {
        return -1;
    }
    p = list->next;
    while (p != NULL)
    {
        q = p;
        while (q->next != NULL)
        {
            if (q->next->data == p->data)
            {
                temp = q->next;
                q->next = temp->next;
                //free(temp); free弹出bug?
            }
            else
            {
                q = q->next;
            }       
        }
        p = p->next;
    }
    return 1;
}

/*单链表第n个位置建环*/
int build_loop(linklist *list, int n)
{
    int count = 0;
    linklist cur;
    linklist tail;
    cur = (*list);
    tail = (*list)->next;

    if (n > list_length((*list)))
    {
        printf("n 好大，建议去火星找吧\n");
        return -1;
    }

    while (cur->next != NULL)
    {
        count++;
        cur = cur->next;
        if (count == n)
        {
            break;
        }
    }

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

    return 1;
}

void main()
{
    linklist list;
    creat_list(&list);

    head_insert_list(&list);
    print_list(list);

    /*tail_insert_list(&list);
    print_list(list);*/

    //insert_i_list(&list, 5, 33); print_list(list);
    //delete_elem(&list, 10); print_list(list);
    //get_i_elem(list, 11); print_list(list);
    ////print_list(list);
    //empty_list(&list); print_list(list);
    //get_daoshu_n(list,10); print_list(list);

    //find_mid_node(list); print_list(list);

    //reverse_list_1(list); print_list(list);

    //reverse_list_2(list); print_list(list);

    //delete_dup_elem(list); print_list(list);

    //build_loop(&list, 4); print_list(list);
    system("pause");
}