链表操作

链表操作

这篇文章是上课实验的内容，包括顺序表，链表，以及链表的各种应用。

顺序表

顺序表的存储：

typedef struct Sqlist
{
    ElemType *slist;
    int length;
    int listsize;
}Sqlist;

顺序表的各种操作：

/*（2）---线性表的初始化*/
int InitList_sq(Sqlist *L)
{
    L->slist=(ElemType *)malloc(INIT_SIZE * sizeof(ElemType));
    if(!L->slist) return ERROR;
    L->length = 0;
    L->listsize=INIT_SIZE;
    return OK;
}
/*（3）---创建具有n个元素的顺序表*/
int CreateList_sq(Sqlist *L,int n)
{
    for(int i=0;i<n;i++)
    {
        L->slist[i]=i;
        L->length++;
        if(L->length>=L->listsize)
        {
            L->slist=(ElemType*) realloc(L->slist,(L->listsize+INCREM)*sizeof(ElemType));
            if(!L->slist)  return ERROR;
            L->listsize+=INCREM;
        }
    }
    return OK;
}/*（4）---输出顺序表中的元素*/
/*（5）---在顺序表的第i个位置之前插入新元素e*/
int ListInsert_sq(Sqlist *L,int i,ElemType e)
{
    int k;
    if(i<1 || i>L->length+1) return ERROR;
    if(L->length>=L->listsize)
    {
        L->slist=(ElemType*) realloc(L->slist,(L->listsize+INCREM)*sizeof(ElemType));
            if(!L->slist)  return ERROR;
            L->listsize+=INCREM;
    }
for(k=L->length-1;k>=i-1;k--)
        L->slist[k+1]=L->slist[k];
L->slist[i-1]=e;
L->length++;
return OK;
}
/*（6）---在顺序表中删除第i个元素，e返回删除的元素*/
int ListDelete_sq(Sqlist *L,int i,ElemType *e)
{
    int j;
    if(i<1 || i>L->length)
        return ERROR;
    *e = L->slist[i];
    for(j=i;j<L->length;j++)
        L->slist[j-1] = L->slist[j];
    L->length --;
    return OK;
}/* ListDelete_sq */
/*（7）---在顺序表中查找指定值元素，pos为返回其位置序号*/
int ListLocate(Sqlist *L,ElemType e,int *pos)
{
    int i;
    for(i=0;i<L->length;i++)
        if(e==L->slist[i])
        {
            *pos = i;
            return OK;
        }
    return ERROR;
}/* ListLocate */

int PrintList_sq(Sqlist *L)
{
    int i=0;
    for(i=0;i<L->length;i++)
        printf("%d ",L->slist[i]);
    return OK;
}

链表

链表的存储：

typedef struct LNode{
    ElemType data;
    struct LNode * next;
}LNode,*LinkList;

链表的各种操作：

/*带头结点单链表初始化*/
LNode *InitList(LinkList L)
{
L=(LNode *)malloc(sizeof(LNode));  /*申请一个头结点*/
if (!L)  return ERROR;/*申请失败*/
L->next=NULL;  /*头结点的指针域置空*/
return L;
}

/*（1）---输出带头结点单链表的所有元素*/
void PrintList(LinkList L)
{
    LinkList p = L->next;
    while(p){
        printf("%d ",p->data);
        p = p->next;
    }
}/*PrintList*/

/*（2）---在单链表的第i个位置插入元素e，若插入成功返回OK，插入失败返回ERROR*/
int InsertElem(LinkList L,int i,ElemType e)
{
LinkList p = L, s;
    int j=0;
    while(p && j< i-1 ){
        p = p->next;
        j++;
    }
    if(!p || j>i-1)
            return ERROR;
    s = (LinkList)malloc(sizeof(LNode));
    if(!s)
            return ERROR;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return OK;
}/* InsertElem */
/*（3）---查找第i位置的元素，若存在返回OK并由e返回其值，若不存在返回ERROR*/
int GetElem(LinkList L,int i,ElemType *e)
{

   LinkList p = L;
   int j=0;
   while(p && j<i){
       p = p->next;
       j++;
   }
   if(!p || j>i)
        return ERROR;

   *e = p->data;
   return OK;
}/*GetElem*/

/*（4）---删除第i位置的元素，成功返回OK，并由e返回其值，若不成功返回ERROR，注意删除的结点必须释放其所占空间*/
int DeleteElem(LinkList L,int i,ElemType *e)
{
   LinkList p = L, s;
   int j=0;
   while(p && j<i-1){
       p = p->next;
       j++;
   }
   if(!p || j>i-1)
        return ERROR;



    s = p->next;
    p->next = s->next;
    *e = s->data;
    free(s);
return OK;
}/* DeleteElem */
/*（5）---创建具有n个结点的单链表，创建成功返回其头指针*/
LinkList CreateList(int n)
{
LinkList L = NULL, s;
    int e,i;
    L = InitList(L);

    for(i=0;i<n;i++){
        printf("input e=");
        scanf("%d",&e);
        InsertElem(L,i+1,e);
    }
    return L;
}/*CreateList*/

/*释放链表及其空间*/
void DestroyLinkList(LinkList L)
{
LNode *p=L,*q;
while(p)
{
q=p->next;
free(p);
p=q;
}
}/* DestroyLinkList */

接下来提到了几个应用。

约瑟夫环

约瑟夫环是经典的循环链表的应用。

用整数序列1，2，3，…，n表示顺序坐在圆桌周围的人，并采用循环链表作为存储结构。任意位置k开始计数，计到m让此位置的人出局，重复上述过程，直至只剩下最后一个人。依次输出每个出局的人的序号。
提示：用一个无头结点的循环单链表来实现n个元素的存储。exp2_3.c部分代码如下：

#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1

typedef  int ElemType; /*定义表元素的类型*/
typedef struct LNode   /*线性表的单链表存储*/
{
ElemType data;
struct LNode *next;
} LNode,*LinkList;

/*（1）---创建具有n个结点的无头结点的单向循环链表，返回其头指针*/
LinkList CreateList(int n)
{
    int i;
    LinkList head = (LinkList)malloc(sizeof(struct LNode));

    LinkList s=head,p;

    for(i=1;i<=n;i++)
    {
        p = (LinkList)malloc(sizeof(struct LNode));
        p->data = i;
        s->next = p;
        s = p;
    }
    p->next = head->next;
    return head->next;
}/*CreateList*/

/*（2）---输出无头结点循环单链表的所有元素*/
void PrintList(LinkList L)
{
    LinkList p=L;
    while(p){
        printf("%d ",p->data);
        p = p->next;
    }
}/*PrintList*/

/*（3）---约瑟夫问题计算，依次输出出局的元素的序号*/
void JOSEPHUS(int n,int k,int m,LinkList L)
{
    L = CreateList(n);
    int i;

    LinkList p = L,tmp;
    while(p->data!=k)
        p = p->next;

    while(p->next!=p)
    {
        for(i=0;i<m-1;i++)
        {
            tmp = p;
            p = p->next;
        }
        printf("%d ",p->data);
        tmp->next = p->next;
        free(p);
        p = tmp->next;
    }
    printf("%d",p->data);
    free(p);
}/*JOSEPHUS*/
int main()
{
    int n,m,k;
    LinkList L=NULL;/*定义指向单链表的指针*/
    while(scanf("%d%d%d",&n,&k,&m)==3) /*n个元素从k位置开始每m个报数*/
        JOSEPHUS(n,k,m,L);
    return 0;
}

删除重复结点的链表

LinkList del(LinkList L)
{
    LinkList p=L->next,q,r;

    while(p)
    {
        q = p;
        while(q->next)
        {
            if(q->next->data==p->data)
            {
                r = q->next;
                q->next = r->next;
                free(r);
            }
            else
                q = q->next;
        }
        p = p->next;
    }
    return L;
}