链表

链表的19种基本操作：

1. 初始化线性表，即置单链表的表头指针为空

2. 创建线性表，输入负数终止读取数据

3. 打印链表，链表的遍历

4. 清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表

5. 返回单链表的长度

6. 检查单链表是否为空，若为空则返回１，否则返回０

7. 返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行

8. 从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点的位置，否则返回NULL

9. 把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０

10. 向单链表的表头插入一个元素

11. 向单链表的末尾添加一个元素

12. 向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０

13. 向有序单链表中插入元素x结点，使得插入后仍然有序  

14. 从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行

15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行

16. 从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行

17. 从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0

18. 交换2个元素的位置

19. 将线性表进行快速排序

#include

#include

#include

 

using namespace std;

 

typedef struct node

{

    int data;

    struct node *next;

} st;

void Empty(st *head)//1.初始化线性表，即置单链表的表头指针为空

{

    head->next=NULL;

}

void input(st *head)  //3.打印链表，链表的遍历

{

    st *q;

    q=head->next;

    while(q)

    {

        if(q->next!=NULL)

            printf("%d ",q->data);

        else

            printf("%d\n",q->data);

        q=q->next;

    }

}

void isEmpty(st *head)//4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表

{

    st *q, *p;

    q = head;

    while(q ->next!= NULL)

    {

        q = q->next;

        free(q);

        p = q;

    }

}

int getlong(st *head)//5.返回单链表的长度

{

    st *n;

    int k=0;

    n=head->next;

    while(n)

    {

        if(n->next!=NULL)

            k++;

        n=n->next;

    }

    return k+1;

}

int doEmpty(st *head)//6.检查单链表是否为空，若为空则返回１，否则返回０

{

    if(head->next==NULL)

        return 1;

    else

        return 0;

}

int getpos(st *head,int pos)//7.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行

{

    int m;

    m=getlong(head);

    if(pos>m) return 0;

    st *q;

    q=head->next;

    int i=0;

    while(q->next!=NULL&&i

    {

        i++;

        q=q->next;

    }

    if(i==pos-1)

        return q->data;

}

int getx(st *head,int x)//8.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点的位置，否则返回NULL

{

    st *q;

    q=head->next;

    int m=1;

    while(q->next!=NULL&&x!=q->data)

    {

        q=q->next;

        m++;

    }

    if(x==q->data)

 

        return m;

    else

        return 0;

}

int changepos(st *head,int pos,int x)//9.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０

{

 

    int m;

    m=getlong(head);

    if(pos>m) return 0;

    st *q;

    q=head->next;

    int i=1;

    while(q->next!=NULL&&i

    {

        i++;

        q=q->next;

    }

    if(i==pos)

        q->data=x;

    return 1;

 

}

void chabiaotou(st *head,int x)//10.向单链表的表头插入一个元素

{

    st *p,*q;

    q=head;

    p=(st *)malloc(sizeof(st));

    if(head->next==NULL)

    {

        p->next=NULL;

        p->data=x;

        q->next=p;

        q=p;

    }

    else if(head->next!=NULL)

    {

        p->data=x;

        p->next=q->next;

        q->next=p;

        q=p;

    }

}

void chabiaowei(st *head,int x)//11.向单链表的末尾添加一个元素

{

    int m;

    m=getlong(head);

    st *q,*p;

    q=head->next;

    p=(st *)malloc(sizeof(st));

    int i=1;

    while(q->next!=NULL&&i

    {

        i++;

        q=q->next;

    }

    if(i==m)

    {

        p->data=x;

        p->next=NULL;

        q->next=p;

        q=p;

    }

}

int charu(st *head,int pos,int x)//12.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０

{

    int m;

    m=getlong(head);

    if(pos<0||pos>m) return 0;

    if(pos==1)

    {

        chabiaotou(head,x);

        return 1;

    }

    else

    {

        st *q,*p;

        q=head->next;

        p=(st *)malloc(sizeof(st));

        int i=1;

        while(q->next!=NULL&&i

        {

            i++;

            q=q->next;

        }

        if(i==pos-1)

        {

            p->data=x;

            p->next=q->next;

            q->next=p;

            q=p;

        }

        return 1;

    }

}

void charuyouxu(st *head,int x)//13.向升序单链表中插入元素x结点，使得插入后仍然有序

{

 

    st *p,*t,*q;

    t=head;

    p=t->next;

    q=(st *)malloc(sizeof(st));

    int i=1;

    while(p!=NULL&&p->data

    {

        i++;

        t=t->next;

        p=p->next;

 

    }

    if(p->data>=x)

    {

 

        q->data=x;

        q->next=p;

        t->next=q;

    }

    if(i==getlong(head))

    {

        q->data=x;

        q->next=NULL;

        p->next=q;

        p=q;

    }

}

int deletebt(st *head)//14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行

{

 

    st *t,*q=head;

    int x;

    if(head->next==NULL) return 0;

    t=head->next;

    x=t->data;

    q->next=t->next;

    free(t);

    return x;

}

int deletebw(st *head)//15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行

{

    if(head->next==NULL)

        return 0;

    st *t,*q;

    int x;

    t=head;

    q=t->next;

    while(q->next!=NULL)

    {

        t=t->next;

        q=q->next;

    }

    if(q->next==NULL)

    {

        x=q->data;

        t->next=NULL;

        free(q);

 

    }

 

    return x;

}

int deletepos(st *head,int pos)//16.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行

{

    int m=getlong(head);

    if(pos<=0||pos>m) return 0;

    st *t,*q;

    int x,i=1;

    t=head;

    q=t->next;

    while(q->next!=NULL&&i

    {

        i++;

        t=t->next;

 

        q=q->next;

    }

    if(i==pos)

    {

        x=q->data;

        t->next=q->next;

        free(q);

    }

    return x;

}

int deletex(st *head,int x)//17.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0

{

    st *t,*q;

    t=head;

    q=t->next;

    while(q->next!=NULL&&q->data!=x)

    {

        t=t->next;

        q=q->next;

    }

    if(x==q->data)

    {

        t->next=q->next;

        free(q);

        return 1;

    }

    else

        return 0;

}

 

void jiaohuan(st *head,int pos1,int pos2)  //18.交换2个元素的位置

 

{

    if(pos1<1||pos1>getlong(head))return ;

    if(pos2<1||pos2>getlong(head))return ;

    int i;

    st *t,*q;

    t=head->next;

    q=head->next;

    for(i=1;i

    {

        t=t->next;

    }

    for(i=1;i

    {

        q=q->next;

    }

    int m;

    m=t->data;

    t->data=q->data;

    q->data=m;

}

 

int paixu(st *head)   //19.将线性表进行快速排序，每个数不大于10000，从小到大排序，简单桶排的思想

{

    int i,j,n;

    n=getlong(head);

    st *q;

    int a[10001];

    for(i=0; i<10001; i++)

    {

        a[i]=0;

    }

 

    for(i=0; i<10001; i++)

    {

        q=head->next;

        while(q)

        {

            if(i==q->data)

            {

                a[i]++;

            }

 

            q=q->next;

        }

    }

    for(i=0; i<10001; i++)

        for(j=0; j

            cout<

}

int main()//2.创建线性表，输入负数终止读取数据

{

    int i,a;

    st *head,*p,*tail;

    head=(st *)malloc(sizeof(st));

    head->next=NULL;

    tail=head;

    while(1)

    {

        cin>>a;

        if(a==-1)break;

        p=(st *)malloc(sizeof(st));

        p->data=a;

        p->next=NULL;

        tail->next=p;

        tail=p;

    }

}