單鏈表各種操作詳解

#include "stdio.h"
#include "stdlib.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 存儲空間初始分配量 */

typedef int Status;/* Status是函數的類型,其值是函數結果狀態代碼，如OK等 */
typedef int ElemType;/* ElemType類型根據實際情況而定，這裏假設爲int */

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
/* 定義LinkList */
typedef struct Node *LinkList;

/* 初始化順序線性表 */
Status InitList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(Node)); /* 產生頭結點,並使L指向此頭結點 */
    if(!(*L)) /* 存儲分配失敗 */
    {
        return ERROR;
    }
    (*L)->next=NULL; /* 指針域爲空 */

    return OK;
}

/* 初始條件：順序線性表L已存在。操作結果：返回L中數據元素個數 */
int ListLength(LinkList L)
{
    int i=0;
    LinkList p=L->next; /* p指向第一個結點 */
    while(p)
    {
        i++;
        p=p->next;
    }
    return i;
}

/* 初始條件：順序線性表L已存在。操作結果：將L重置爲空表 */
Status ClearList(LinkList *L)
{
	LinkList p,q;
	p=(*L)->next;           /*  p指向第一個結點 */
	while(p)                /*  沒到表尾 */
	{
		q=p->next;
		free(p);
		p=q;
	}
	(*L)->next=NULL;        /* 頭結點指針域爲空 */
	return OK;
}

/* 初始條件：順序線性表L已存在 */
/* 操作結果：依次對L的每個數據元素輸出 */
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

/* 初始條件：順序線性表L已存在 */
/* 操作結果：依次對L的每個數據元素輸出 */
Status ListTraverseLimit(LinkList L, int n)
{
    int i = 0;
    LinkList p=L->next;
    while(p && i < n)
    {
        visit(p->data);
        p=p->next;
        i++;
    }
    printf("\n只顯示 %d 個\n", n);
    return OK;
}

Status visit(ElemType c)
{
    printf("-> %d ",c);
    return OK;
}

/* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */
/* 操作結果：用e返回L中第i個數據元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
	int j;
	LinkList p;		/* 聲明一結點p */
	p = L->next;		/* 讓p指向鏈表L的第一個結點 */
	j = 1;		/*  j爲計數器 */
	while (p && j < i)  /* p不爲空或者計數器j還沒有等於i時，循環繼續 */
	{
		p = p->next;  /* 讓p指向下一個結點 */
		++j;
	}
	if ( !p || j>i )
		return ERROR;  /*  第i個元素不存在 */
	*e = p->data;   /*  取第i個元素的數據 */
	return OK;
}

/* 初始條件：順序線性表L已存在 */
/* 操作結果：返回L中第1個與e滿足關係的數據元素的位序。 */
/* 若這樣的數據元素不存在，則返回值爲0 */
int LocateElem(LinkList L,ElemType e)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(p->data==e) /* 找到這樣的數據元素 */
                return i;
        p=p->next;
    }

    return 0;
}

/*  隨機產生n個元素的值，建立帶表頭結點的單鏈線性表L（頭插法） */
void CreateListHead(LinkList *L, int n)
{
	LinkList p;
	int i;
	srand(time(0));                         /* 初始化隨機數種子 */
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;                      /*  先建立一個帶頭結點的單鏈表 */
	for (i=0; i < n; i++)
	{
		p = (LinkList)malloc(sizeof(Node)); /*  生成新結點 */
		p->data = rand()%100+1;             /*  隨機生成100以內的數字 */
		p->next = (*L)->next;
		(*L)->next = p;						/*  插入到表頭 */
	}
}

/*  隨機產生n個元素的值，建立帶表頭結點的單鏈線性表L（尾插法） */
void CreateListTail(LinkList *L, int n)
{
	LinkList p,r;
	int i;
	srand(time(0));                      /* 初始化隨機數種子 */
	*L = (LinkList)malloc(sizeof(Node)); /* L爲整個線性表 */
	r=*L;                                /* r爲指向尾部的結點 */
	for (i=0; i < n; i++)
	{
		p = (Node *)malloc(sizeof(Node)); /*  生成新結點 */
		p->data = rand()%100+1;           /*  隨機生成100以內的數字 */
		r->next=p;                        /* 將表尾終端結點的指針指向新結點 */
		r = p;                            /* 將當前的新結點定義爲表尾終端結點 */
	}
	r->next = NULL;                       /* 表示當前鏈表結束 */
}

/* 初始條件：順序線性表L已存在,1≤i≤ListLength(L)， */
/* 操作結果：在L中第i個位置之前插入新的數據元素e，L的長度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
	int j;
	LinkList p,s;
	p = *L;     /* 聲明一個結點 p，指向頭結點 */
	j = 1;
	while (p && j < i)     /* 尋找第i個結點 */
	{
		p = p->next;
		++j;
	}
	if (!p || j > i)
		return ERROR;   /* 第i個元素不存在 */
	s = (LinkList)malloc(sizeof(Node));  /*  生成新結點(C語言標準函數) */
	s->data = e;
	s->next = p->next;      /* 將p的後繼結點賦值給s的後繼  */
	p->next = s;          /* 將s賦值給p的後繼 */
	return OK;
}

/* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */
/* 操作結果：刪除L的第i個數據元素，並用e返回其值，L的長度減1 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{
	int j;
	LinkList p,q;
	p = *L;
	j = 1;
	while (p->next && j < i)	/* 遍歷尋找第i個元素 */
	{
        p = p->next;
        ++j;
	}
	if (!(p->next) || j > i)
	    return ERROR;           /* 第i個元素不存在 */
	q = p->next;
	p->next = q->next;			/* 將q的後繼賦值給p的後繼 */
	*e = q->data;               /* 將q結點中的數據給e */
	free(q);                    /* 讓系統回收此結點，釋放內存 */
	return OK;
}

/* 單鏈表反轉/逆序 */
LinkList ListReverse(LinkList L)
{
    LinkList current,pnext,prev;
    if(L == NULL || L->next == NULL)
        return L;
    current = L->next;  /* p1指向鏈表頭節點的下一個節點 */
    pnext = current->next;
    current->next = NULL;
    while(pnext)
    {
        prev = pnext->next;
        pnext->next = current;
        current = pnext;
        pnext = prev;
    }
    //printf("current = %d,next = %d \n",current->data,current->next->data);
    L->next = current;  /* 將鏈表頭節點指向p1 */
    return L;
}

LinkList ListReverse2(LinkList L)
{
    LinkList current, p;

    if (L == NULL)
    {
        return NULL;
    }
    current = L->next;
    while (current->next != NULL)
    {
        p = current->next;
        current->next = p->next;
        p->next = L->next;
        L->next = p;
        ListTraverse(L);
        printf("current = %d, \n", current -> data);
    }
    return L;
}

LinkList ListReverse3(LinkList L)
{
    LinkList newList;    //新鏈表的頭結點
    LinkList tmp;       //指向L的第一個結點，也就是要摘除的結點

    //參數爲空或者內存分配失敗則返回NULL
    if (L == NULL || (newList = (LinkList)malloc(sizeof(Node))) == NULL)
    {
        return ERROR;
    }

    //初始化newList
    newList->data = L->data;
    newList->next = NULL;

    //依次將L的第一個結點放到newList的第一個結點位置
    while (L->next != NULL)
    {
        tmp = newList->next;         //保存newList中的後續結點
        newList->next = L->next;       //將L的第一個結點放到newList中
        L->next = L->next->next;     //從L中摘除這個結點
        newList->next->next = tmp;        //恢復newList中後續結點的指針
    }

    //原頭結點應該釋放掉，並返回新頭結點的指針
    free(L);
    return newList;
}

// 獲取單鏈表倒數第N個結點值
Status GetNthNodeFromBack(LinkList L, int n, ElemType *e)
{
    int i = 0;
    LinkList firstNode = L;
    while (i < n && firstNode->next != NULL)
    {
        //正數N個節點，firstNode指向正的第N個節點
        i++;
        firstNode = firstNode->next;
        printf("%d\n", i);
    }
    if (firstNode->next == NULL && i < n - 1)
    {
        //當節點數量少於N個時，返回NULL
        printf("超出鏈表長度\n");
        return ERROR;
    }
    LinkList secNode = L;
    while (firstNode != NULL)
    {
        //查找倒數第N個元素
        secNode = secNode->next;
        firstNode = firstNode->next;
        //printf("secNode:%d\n", secNode->data);
        //printf("firstNode:%d\n", firstNode->data);
    }
    *e = secNode->data;
    return OK;
}

// 找到鏈表的中間節點
Status GetMidNode(LinkList L, ElemType *e) {
    LinkList search, mid;
    mid = search = L;
    while (search->next != NULL)
    {
        //search移動的速度是 mid 的2倍
        if (search->next->next != NULL)
        {
            search = search->next->next;
            mid = mid->next;
            //printf("search %d\n", search->data);
            //printf("mid %d\n", mid->data);
        }
        else
        {
            search = search->next;
        }
    }
    *e = mid->data;
    return OK;
}

int HasLoop(LinkList L)
{
    int step1 = 1;
    int step2 = 2;
    LinkList p = L;
    LinkList q = L;
    //while (p != NULL && q != NULL && q->next == NULL)
    while (p != NULL && q != NULL && q->next != NULL)
    {
        p = p->next;
        if (q->next != NULL)
            q = q->next->next;
        printf("p:%d, q:%d \n", p->data, q->data);
        if (p == q)
            return 1;
    }
    return 0;
}

int HasLoop2(LinkList L)
{
    int step1 = 1;
    int step2 = 2;
    LinkList p = L;
    LinkList q = L;
    while (p != NULL && q != NULL && q->next != NULL)
    {
        p = p->next;
        if (q->next != NULL)
            q = q->next->next;
        printf("p:%d, q:%d \n", p->data, q->data);
        if (p == q)
            return 1;
    }
    return 0;
}

Status BulidListLoop(LinkList *L, int num)
{
    int i = 0;
    LinkList cur = *L;
    LinkList tail = NULL;

    if(num <= 0 || L == NULL)
    {
        return ERROR;
    }
    for(i = 1; i < num; ++i)
    {
        if(cur == NULL)
        {
            return ERROR;
        }
        cur = cur->next;
    }
    tail = cur;
    while(tail->next)
    {
        tail = tail->next;
    }
    tail->next = cur;
    return OK;
}

LinkList RemoveDupNode(LinkList L)//刪除重複結點的算法
{
    LinkList p,q,r;
    p=L->next;
    while(p)    // p用於遍歷鏈表
    {
         q=p;
         while(q->next) // q遍歷p後面的結點，並與p數值比較
         {
             if(q->next->data==p->data)
             {
                 r=q->next; // r保存需要刪掉的結點
                 q->next=r->next;   // 需要刪掉的結點的前後結點相接
                 free(r);
             }
             else
                 q=q->next;
         }
         p=p->next;
    }
    return L;
}

int main()
{
    LinkList L;
    Status i;
    int j,k,pos,value;
    int opp;
    ElemType e;

    i=InitList(&L);
    printf("鏈表L初始化完畢，ListLength(L)=%d\n",ListLength(L));

    printf("\n1.整表創建（頭插法） \n2.整表創建（尾插法） \n3.遍歷操作 \n4.插入操作");
    printf("\n5.刪除操作 \n6.獲取結點數據 \n7.查找某個數是否在鏈表中 \n8.置空鏈表");
    printf("\n9.鏈表反轉逆序 \n10.求鏈表倒數第N個數 \n11.找到鏈表的中間結點 \n12.判斷鏈表是否有環");
    printf("\n13.鏈表建環 ");
    printf("\n14.鏈表去重 ");
    printf("\n0.退出 \n請選擇你的操作：\n");
    while(opp != '0'){
        scanf("%d",&opp);
        switch(opp){
            case 1:
                CreateListHead(&L,10);
                printf("整體創建L的元素(頭插法)：\n");
                ListTraverse(L);
                printf("\n");
                break;

            case 2:
                CreateListTail(&L,10);
                printf("整體創建L的元素(尾插法)：\n");
                ListTraverse(L);
                printf("\n");
                break;

            case 3:
                ListTraverse(L);
                printf("\n");
                break;

            case 4:
                printf("要在第幾個位置插入元素？");
                scanf("%d",&pos);
                printf("插入的元素值是多少？");
                scanf("%d",&value);
                ListInsert(&L,pos,value);
                ListTraverse(L);
                printf("\n");
                break;

            case 5:
                printf("要刪除第幾個元素？");
                scanf("%d",&pos);
                ListDelete(&L,pos,&e);
                printf("刪除第%d個元素成功，現在鏈表爲：\n", pos);
                ListTraverse(L);
                printf("\n");
                break;

            case 6:
                printf("你需要獲取第幾個元素？");
                scanf("%d",&pos);
                GetElem(L,pos,&e);
                printf("第%d個元素的值爲：%d\n", pos, e);
                printf("\n");
                break;

            case 7:
                printf("輸入你需要查找的數：");
                scanf("%d",&pos);
                k=LocateElem(L,pos);
                if(k)
                    printf("第%d個元素的值爲%d\n",k,pos);
                else
                    printf("沒有值爲%d的元素\n",pos);
                printf("\n");
                break;

            case 8:
                i=ClearList(&L);
                printf("\n清空L後：ListLength(L)=%d\n",ListLength(L));
                ListTraverse(L);
                printf("\n");
                break;

            case 9:
                ListReverse2(L);
                //L=ListReverse3(L);
                printf("\n反轉L後\n");
                ListTraverse(L);
                printf("\n");
                break;

            case 10:
                printf("你要查找倒數第幾個結點的值？");
                scanf("%d", &value);
                GetNthNodeFromBack(L,value,&e);
                printf("倒數第%d個元素的值爲：%d\n", value, e);
                printf("\n");
                break;

            case 11:
                GetMidNode(L, &e);
                printf("鏈表中間結點的值爲：%d\n", e);
                printf("\n");
                break;

            case 12:
                if( HasLoop(L) )
                {
                    printf("方法一: 鏈表有環\n");
                }
                else
                {
                    printf("方法一: 鏈表無環\n");
                }

                if( HasLoop2(L) )
                {
                    printf("方法二: 鏈表有環\n");
                }
                else
                {
                    printf("方法二: 鏈表無環\n");
                }
                printf("\n");
                break;

            case 13:
                printf("你要在哪個位置開始建環？");
                scanf("%d", &pos);
                BulidListLoop(&L, pos);
                ListTraverseLimit(L, 20);
                printf("\n");
                break;

            case 14:
                RemoveDupNode(L);
                ListTraverse(L);
                printf("\n");
                break;

            case 0:
                exit(0);
        }
    }

}

延伸閱讀

此文章所在專題列表如下：

1. 第01話：線性表的概念與定義
2. 第02話：線性表的抽象數據類型ADT定義
3. 第03話：線性表的順序存儲結構
4. 第04話：線性表的初始化
5. 第05話：線性表的遍歷、插入操作
6. 第06話：判斷線性表是否爲空與置空操作
7. 第07話：線性表的查找操作
8. 第08話：線性表刪除某個元素
9. 線性表順序存儲的優缺點
10. 線性錶鏈式存儲結構的由來與基本概念
11. 單鏈表的頭指針、頭結點與首元結點
12. 單鏈表的結構體定義與聲明
13. 單鏈表的初始化
14. 單鏈表的插入與遍歷操作
15. 單鏈表的刪除某個元素的操作
16. 獲取單鏈表中的指定位置的元素
17. 查找某數在單鏈表中的位置
18. 用頭插法實現單鏈表整表創建
19. 用尾插法實現單鏈表整表創建
20. 將單鏈表重置爲空表
21. 單鏈表反轉/逆序的兩種方法
22. 單鏈表反轉/逆序的第三種方法
23. 求單鏈表倒數第N個數
24. 用標尺法快速找到單鏈表的中間結點
25. 如何判斷鏈表是否有環的存在
26. 單鏈表建環，無環鏈表變有環
27. 刪除單鏈表中的重複元素