C语言数据结构-2-单链表

注意：现在偷的懒以后都要补回来的！

希望大家认真学好数据结构，不希望后悔！

1. 单链表删除
   【问题描述】
   设有头结点单链表，实现单链表删除。
   【输入形式】
   第一行输入N，表示单链表表长为N；
   第二行输入N个整数，建立有头结点单链表；
   第三行输入一个整数M，表示删除结点位置为M（即第M个元素）。
   【输出形式】
   若删除成功，先输出删除结点的值；下一行输出删除后单链表的所有元素；
   若删除不成功，输出error。
   【样例输入1】
   5
   10 20 30 40 50
   2
   【样例输出1】
   20
   10 30 40 50
   【样例输入2】
   10
   10 20 30 40 50 60 70 80 90 100
   0
   【样例输出2】
   error
   【评分标准】
   采用有头结点单链表存储，实现用算法函数完成。

#include 
#include 
typedef struct Node{
    int data;
    struct Node *next;
}Node;

int main()
{
    int n,pos,k=0;
    Node *node,*head,*p,*q;
    scanf("%d", &n);
    head=(Node *)malloc(sizeof(Node));
    head->next=NULL;
    q=head;
    for(int i=0;i<n;i++){
        node=(Node *)malloc(sizeof(Node));
        scanf("%d",&node->data);
        q->next=node;
        q=node;
    }
    q->next=NULL;
    p=head;
    scanf("%d",&pos);
    if(pos>0 && pos<=n){
        do{
            q=p;
            p=p->next;
            k++;
            if(k==pos){
                q->next=p->next;
            }
        }while(p!=NULL);
        p=head->next;
        do{
            printf("%d ",p->data);
            p=p->next;
        }while(p!=NULL);
    }else{
        printf("error");
    }
    return 0;
}

2. 单链表查找
   【问题描述】
   设有头结点单链表，在链表中查找关键字值在链表中首次出现的位序。
   【输入形式】
   第一行输入一个整数N；
   第二行输入N个整数，创建有头结点单链表；
   后面进行若干次查找，每输入一个关键字值，输出查找结果。（利用scanf()的返回值判断是否仍有数据输入）
   【输出形式】
   若找到关键字值，输出其在链表中首次出现的位序；
   若未找到，输出-1。
   【样例输入】
   5
   12 34 96 -67 100
   12
   100
   96
   28
   【样例输出】
   1
   5
   3
   -1
   【评分标准】
   采用单链表作为存储结构，查找实现用算法函数表示。

#include 
#include 
typedef struct Node{
    int data;
    struct Node *next;
}Node;

int main()
{
    int n, m,k;
    Node *node,*head,*q,*p;
    head=(Node *)malloc(sizeof(Node));
    head->next=NULL;
    q=head;
    scanf("%d,",&n);
    for(int i=0;i<n;i++){
        scanf("%d,",&m);
        node=(Node *)malloc(sizeof(Node));
        node->data=m;
        q->next=node;
        q=node;
    }
    q->next=NULL;
    int flag=0,j;
    while(scanf("%d",&k)==1){
        j=0;
        p=head->next;
        while(p){
            j++;
            if(k==p->data){
                printf("%d\n",j);
                flag=0;
                break;
            }else{
                flag=1;
            }
            p=p->next;
        }
        if(!p){
            printf("-1\n");
        }
    }
    return 0;
}

3. 有头结点单链表逆置
   【问题描述】
   设有头结点单链表，编写算法实现单链表逆置。
   【输入形式】
   第一行输入一个整数N；
   第二行输入N个整数，以空格作为分隔，创建单链表；
   【输出形式】
   输出逆置后的单链表,，元素之间以空格分隔。
   【样例输入】
   5
   10 20 30 40 50
   【样例输出】
   50 40 30 20 10
   【评分标准】
   采用单链表实现，逆置过程写成算法函数。（要求链表次序逆置，而不是仅逆序输出）

#include 
#include 
typedef struct Node{
    int data;
    struct Node *next;
}Node;

int main()
{
    int n, m;
    Node *node,*head,*p;
    head=(Node *)malloc(sizeof(Node));
    head->next=NULL;
    scanf("%d,",&n);
    for(int i=0;i<n;i++){
        scanf("%d,",&m);
        node=(Node *)malloc(sizeof(Node));
        node->data=m;
        node->next=head->next;
        head->next=node;
    }
    p=head->next;
    while(p){
        printf("%d ",p->data);
        p=p->next;
    }
    return 0;
}

4. 统计不带头结点的单链表长度（循环方法）
   【问题描述】
   统计不带头结点的单链表结点个数。
   【输入形式】
   重复输入数字建立不带头结点的单链表，输入字符结束。
   【输出形式】
   输出单链表结点的个数。
   【样例输入】
   2 3 4 5 6 e
   【样例输出】
   5
   【评分标准】
   在一个函数中用循环方法统计结点个数。

#include 
#include 
typedef struct Node{
    int data;
    struct Node *next;
}Node;

int main()
{
    int n;
    Node *node,*head,*p;
    head=NULL;
    while(scanf("%d",&n)==1){
        node=(Node *)malloc(sizeof(Node));
        node->data=n;
        node->next=head;
        head=node;
    }
    p=head;
    int count=0;
    while(p){
        count++;
        p=p->next;
    }
    printf("%d",count);
    return 0;
}

5. 链表字符统计
   【问题描述】单链表实现字符统计。
   【输入形式】从键盘输入N个字符，字符以逗号隔开。
   【输出形式】统计各字符出现的次数，并删除重复字符。
   【样例输入】5,a,b,c,a,b
   【样例输出】
   a 2
   b 2
   c 1
   【样例说明】键盘输入5个字符,分别为a,b,c,a,b,统计出各字符出现次数分别为2，2，1
   【评分标准】要求以单链表形式实现。

#include 
#include 
typedef struct Node{
    char data;
    int count;
    struct Node *next;
}Node;

int main()
{
    int n;
    char m;
    Node *node,*head,*q,*z,*p;
    head=(Node *)malloc(sizeof(Node));
    head->next=NULL;
    scanf("%d,",&n);
    for(int i=0;i<n;i++){
        q=head->next;
        scanf("%c,",&m);
        if(!q){
            node=(Node *)malloc(sizeof(Node));
            node->data=m;
            node->count=1;
            node->next=head->next;
            head->next=node;
            z=node;
            continue;
        }else{
            while(q){
                if(m==q->data ){
                    q->count++;
                    break;
                }else{
                    q=q->next;
                }
            }
            if(!q){
                node=(Node *)malloc(sizeof(Node));
                node->data=m;
                node->count=1;
                z->next=node;
                z=node;
                z->next=NULL;
            }
        }
    }
    p=head->next;
    while(p){
        printf("%c %d\n",p->data,p->count);
        p=p->next;
    }
    return 0;
}

#include 
#include 
#include 

typedef struct LNode
{
    char ch;
    int count;
    struct LNode *next;
}LNode,*LinkList;
LinkList LocateElem(LinkList L,char e)
{
    LinkList p=L->next;
    while(p&&p->ch!=e)
        p=p->next;
    return p;
}

LinkList CreateN(int n)
{
    LinkList head,p,q,f;
    int i;
    char e;
    p=head=(LNode*)malloc(sizeof(LNode));
    p->next=NULL;
    for(i=1;i<=n;i++)
    {
        scanf("%c,",&e);
        f=LocateElem(head,e);
        if(!f)
        {
            q=(LNode*)malloc(sizeof(LNode));
            q->ch=e;
            q->count=1;
            p->next=q;
            p=q;
            p->next=NULL;
        }
        else
            f->count++;
    }
    return head;
}
void PrintList(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        printf("%c %d\n",p->ch,p->count);
        p=p->next;
    }
}
int main()
{
    int n;
    LinkList L;
    scanf("%d,",&n);
    L=CreateN(n);
    PrintList(L);
    return 0;
}