链表调通

数据结构-链表

新手学习，代码还很死板，不灵活。期待改进。

环境：vc6

语言：c 

运行结果： $ 为结束符号，不会读入$

qwe$
全部元素为:qwe
一共有:3个元素
查找节点的内容,元素序号为:2
2:w
查找节点的位置，内容为:e
e:3
删除节点，节点的位置:1
删除内容为：q
剩余元素为:we
在i插入e:2r
全部元素为:wre
排序后元素为:erw
新链表q:ert$
q合并p后:全部元素为:erwert
Press any key to continue

 

全部代码：

#include "stdio.h"
#include "malloc.h"
#include "string.h"

typedef struct Node
{ 
    char data;
    struct Node * next;
}Node, *LinkList;/* LinkList为结构指针类型*/

//创建一个链表
LinkList CreateFromHead();//头插
LinkList CreateFromTail(); //尾插/*将新增的字符追加到链表的末尾*/

int ListLength(LinkList L); //L为带头结点的链表求长度
//查找
Node * Get2(LinkList L, int i);//按元素序号查找
Node *Locate2(LinkList L,char key);//按元素值查找
void Get1(LinkList L, int i);//按元素序号查找
void Locate1(LinkList L,char key);//按元素值查找
//更改

//删除
void DelList(LinkList L,int i,char *e);//删除结点 序号
//插入
void InsList(LinkList L,int i,char e);//插入结点
//合并
LinkList Merge(LinkList LA, LinkList LB);
//排序
void sore(LinkList head);
//打印
void printList(LinkList L);

//合并 有序
LinkList MergeLinkList(LinkList LA, LinkList LB);//两个从小到大有序链表合并成为有序链表 LC

int main()
{   /* LinkList为结构指针类型*/
    Node *p, *q;
    char c, e;
    int i;

    p = (Node*)malloc(sizeof(Node));
    p = CreateFromTail();

    printf("全部元素为:");
    printList(p);
    printf("\n一共有:%d个元素\n", ListLength(p));

//查找
    printf("查找节点的内容,元素序号为:");
    scanf("%d", &i);
    Get1(p, i);
    printf("查找节点的位置，内容为:");
    scanf(" %c", &c);
    Locate1(p,c);
//删除
    printf("删除节点，节点的位置:");
    scanf("%d", &i);
    DelList(p,i,&e);
    printf("删除内容为：%c\n", e);
    printf("剩余元素为:");
    printList(p);
    printf("\n");
//插入
    printf("在i插入e:");
    scanf("%d%c", &i, &e);
    InsList(p,i,e);
    printf("全部元素为:");
    printList(p);
    printf("\n");

//排序
    sore(p);
    printf("排序后元素为:");
    printList(p);
    printf("\n");

    printf("新链表q:");
    q = (Node*)malloc(sizeof(Node));
    q = CreateFromTail();

//合并
    printf("q合并p后:");
    //q 为NULL  !!
    p = Merge(p, q);

    printf("全部元素为:");
    printList(p);
    printf("\n");
/*
//有序合并
    p = MergeLinkList(q, p);
    printf("合并后全部元素为:");//(原来的两个链表本来就有序,p长度短)
    printList(p);
    printf("\n");
*/

    return 0;
}





//头插
LinkList CreateFromHead()
{
    int flag=1; 
    LinkList L;
    Node *s;
    char c;
    L=(LinkList)malloc(sizeof(Node));
    L->next=NULL;

    while(flag) //因为flag是1，所以进入循环体执行
    {
        scanf("%c", &c); 
        //c = getchar(); //假设用户输入ab$,首先读入‘a’
        if(c !='$') //‘a’不等于‘$’,因此判断成立
        {    
            s=(Node*)malloc(sizeof(Node)); 
            s->data=c;
            s->next=L->next; 
            L->next=s;  
        }
    }
    return L;
}    
//尾插
LinkList CreateFromTail() /*将新增的字符追加到链表的末尾*/
{ 
    char c;
    LinkList L;
    Node *r, *s;
    L=(LinkList)malloc(sizeof(Node));
    L->next=NULL;
    r=L; /*r指针始终动态指向链表的当前表尾*/
    fflush(stdin);
    c=getchar();
    while(c!='$')/*输入“$”时flag为0，建表结束*/
    {     
        
        s=(LinkList)malloc(sizeof(Node)); 
        s->data=c;
        r->next=s; 
        r=s;
        c=getchar();
    }
    r->next=NULL; 
    return L;
}
//按元素序号查找
void Get1(LinkList L, int i)
{ //假设开始的情况是：
    Node *p;
    int j=0;
    p=L;
    while((p->next!=NULL)&&(j<i))        
    { 
        p=p->next;
        j++;                             
    }
    // p->next是NULL
    if(i==j)    
    {
        printf("%d:%c\n", i,p->data);
    }
    else //不满足判断条件，因此执行else部分
        printf("未找到");
}

//按元素值查找
void Locate1(LinkList L,char key)
{ 
    int i = 1;
    Node *p;
    p=L->next;
    while(p !=NULL)
    {
        if(p->data != key)    
        {
            i++;
            p=p->next;  
        }
        else 
        {
            printf("%c:%d\n", key, i);
            break;
        }
    }
}


//按元素序号查找
Node *Get2(LinkList L, int i)
{ //假设开始的情况是：
    Node *p;
    int j=0;
    p=L;
    while((p->next!=NULL)&&(j<i))        
    { //满足条件，因此进入循环体执行
        p=p->next;
        j++;                             
    }
    // p->next是NULL，不满足条件，因此不再执行循环体
    if(i==j)    
    {
        printf("%d:%c\n", i,p->data);
        return p;
    }
    else //不满足判断条件，因此执行else部分
        return NULL;
}

//按元素值查找
Node *Locate2(LinkList L,char key)
{ 
    int i = 1;
    Node *p;
    p=L->next;
    while(p !=NULL)
    {
        if(p->data != key)    
        {
            i++;
            p=p->next;  
        }
        else 
        {
            printf("%c:%d\n", key, i);
            break;
        }
    }
    return p;
}

//删除结点
void DelList(LinkList L,int i,char *e)
{ 
    Node *p,*r; 
    int k =0;
    p=L; 
    while(p->next != NULL &&  k < i-1) 
    { 
        p=p->next; 
        k=k+1; 
    }
    if(k!=i-1)  
    {
        printf("无此节点");
    }
    else
    {
        r=p->next; 
        p->next=p->next->next;            
        *e=r->data;//通过变量e返回删掉的元素值
        free(r);        //r这个变量及值都没有变动，但是不能再使用r指向的那个空间（因为已经释放）。
    }
}
//插入结点
void InsList(LinkList L,int i,char e)
{ 
    Node *pre,*s;
    int k=0;
    pre=L; 
    while(pre!=NULL&&k<i-1) /*先找到第i-1个数据元素的存储位置,使指针pre指向它*/ 
    { 
        pre=pre->next;    
        k=k+1;  
    }
    if(k!=i-1)   
    { 
        printf("插入位置不合理！"); 
        return; 
    }
    s=(Node*)malloc(sizeof(Node));/*为e申请一个新的结点*/
    s->data=e;     /*将待插入结点的值e赋给s的数据域*/
    s->next=pre->next; 
    pre->next=s;
} 



//求长度
int ListLength(LinkList L) /*L为带头结点的链表*/
{  
    Node *p; 
     int j=0; /*用来存放链表的长度*/
    p=L->next;    
     while(p!=NULL)
     {    
        p=p->next; 
        j++; 
    }
     return j;
}


//合并
LinkList Merge(LinkList LA, LinkList LB)
{
    LinkList p;
    p = LA->next;
    while(p->next)
        p = p->next;
    p->next = LB->next;
    free(LB);
    return LA;
}
//两个从小到大有序链表合并成为有序链表 LC
LinkList MergeLinkList(LinkList LA, LinkList LB)
{   
    Node *pa,*pb;
    LinkList LC;
    LinkList r;

    pa=LA->next;
    pb=LB->next;
    LC=LA;
    LC->next=NULL;
    r=LC;
    
    while(pa!=NULL && pb!=NULL) 
    {
        if(pa->data <= pb->data)
        {
            r->next=pa;
            r=pa;
            pa=pa->next;
        }
        else
        {
            r->next=pb;
            r=pb;
            pb=pb->next;
        }
    }
    if(pa != NULL) 
        r->next=pa;
        //return NULL;
    else//
        r->next=pb;
    free(LB);
    return (LC);
}
/*
bcd$
新链表q:aef$
合并后全部元素为:abcdef
bc$
新链表q:adef$
合并后全部元素为:abcdef
acdg$
新链表q:be$
合并后全部元素为:abcdeg
  */
//排序
void sore(LinkList head)
{
    LinkList pre,cur,next,end, temp;
    end = NULL;
    while(head->next != end)
    {
        //初始化三个指针 ; 判断是否到达结束位置 ; 三个指针集体后移
        for(pre=head,cur=pre->next,next=cur->next;  next!=end;  pre=pre->next,cur=cur->next,next=next->next)
        {
            if(cur->data > next->data) //从小到大
            {
                pre->next=next;
                cur->next=next->next;
                next->next=cur;
                //此时next变前一项，cur变后一项  交换next cur
                temp=cur; 
                cur=next; 
                next=temp;
            }
        }
        //一轮循环结束 最后一项已经排好 end提前一项 (冒泡原理)
        end = cur;
    }
}

void printList(LinkList L)
{
    Node *p = L;
    while(p->next)
    {
        p = p->next;
        if(p->data >= 'a' || p->data <='z')
            printf("%c", p->data);
        //printf(" ", p->data);
    }
}