單鏈表的翻轉

前面我們大約把單鏈表 ADT 的基本操作都過了一遍，但是這還不夠。單鏈表在面試與筆試中出現的機率很高，接下來我們再花點時間把常見的單鏈表面試題儘可能過一遍，徹底掌握單鏈表～
那開始我們的第一個面試題？不妨做做“單鏈表反轉”，或者說“單鏈表逆序”吧？還是基於前面的例子。

究竟要如何反轉呢？我們不妨拿一個例子來說明一下算法。

我先畫一個單鏈表，這個單鏈表有4個元素。我的思路就是，每次把第二個元素提到最前面來。比如下面是第一次交換，我們先讓頭結點的next域指向結點a2，再讓結點a1的next域指向結點a3，最後將結點a2的next域指向結點a1，就完成了第一次交換。

第一次交換

然後進行相同的交換將結點a3移動到結點a2的前面，然後再將結點a4移動到結點a3的前面就完成了反轉。

第二次交換

第三次交換

思路有了，那就可以寫代碼了。這裏我們需要額外的兩個工作指針來輔助交換。這個下面的步驟慢慢理解下，結合圖片。注意結點之間的關係要先斷再連。

步驟：

定義當前結點 current，初始值爲首元結點，current = L->next;
定義當前結點的後繼結點 pnext， pnext = current->next;
只要 pnext 存在，就執行以下循環：
- 定義新節點 prev，它是 pnext的後繼結點，prev = pnext->next;
- 把pnext的後繼指向current, pnext->next = current;
- 此時，pnext 實際上已經到了 current 前一位成爲新的current，所以這個時候 current 結點實際上成爲新的 pnext，current = pnext;
- 此時，新的 current 就是 pnext，current = pnext;
- 而新的 pnext 就是 prev，pnext = prev;
最後將頭結點與 current 重新連上即可，L->next = current;

函數設計如下：

/* 單鏈表反轉/逆序 */
Status 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);
    }
    //printf("current = %d,next = %d \n",current->data,current->next->data);
    L->next = current;  /* 將鏈表頭節點指向p1 */
    return L;
}

其實在你寫函數的時候，我也寫了個函數，也能運行。思路也差不多，不過你的current一直是表的第一個結點，我這裏的current始終是首元結點的值，我的函數需要每次對pnext重新賦值。一會解釋下。

Status 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;
    }
    return L;
}

p = current->next; p 就相當於前面的 pnext。（圖1中a2即爲p）
current->next = p->next; p->next 就相當於 prev的角色，這句代碼意思是 current 的後繼指向 prev.（相當於圖1中a1->next = a3(a2->next)）
p->next = L->next; 這句就是 p 的後繼直接指向首元節點。（相當於圖1中a2->next = a1）
L->next = p; 然後再將頭結點指向 p。（相當於圖1中L->next = a2）

參照圖就很容易理解上面的步驟了。我覺得我這麼寫比你的清晰一些。我先將current指向prev，再將pnext指向current，最後將頭結點指向pnext。

這個是程序運行的結果。

整體創建L的元素(頭插法)：
// 原鏈表，current = 68， pnext = 55，68指向18，55指向18，頭結點指向55
-> 68 -> 55 -> 18 -> 45 -> 41 -> 43 -> 5 -> 28 -> 80 -> 67

// 第一次交換後，原鏈表變成這樣
-> 55 -> 68 -> 18 -> 45 -> 41 -> 43 -> 5 -> 28 -> 80 -> 67
// 進行第二次交換，pnext = 18，68指向45，18變成頭結點
-> 18 -> 55 -> 68 -> 45 -> 41 -> 43 -> 5 -> 28 -> 80 -> 67
// 進行第三次交換，pnext = current->next = 45，68指向41，45變成頭結點
-> 45 -> 18 -> 55 -> 68 -> 41 -> 43 -> 5 -> 28 -> 80 -> 67
// ……
-> 41 -> 45 -> 18 -> 55 -> 68 -> 43 -> 5 -> 28 -> 80 -> 67

-> 43 -> 41 -> 45 -> 18 -> 55 -> 68 -> 5 -> 28 -> 80 -> 67

-> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68 -> 28 -> 80 -> 67

-> 28 -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68 -> 80 -> 67

-> 80 -> 28 -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68 -> 67
// current 68 沒有後繼，反轉結束
-> 67 -> 80 -> 28 -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68


反轉L後
-> 67 -> 80 -> 28 -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68

最後附上完整代碼，反轉有兩個函數。

方法1，current始終保持在第一位，pnext與prev遍歷並完成交換。
方法2，current始終是原鏈表的第一個數，然後把pnext不斷移動到首位。

#include "stdio.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;
}

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;
}

/* 單鏈表反轉/逆序 */
Status 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;
}

Status 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;
}

int main()
{
    LinkList L;
    Status i;
    int j,k,pos,value;
    char 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.鏈表反轉逆序");
    printf("\n0.退出 \n請選擇你的操作：\n");
    while(opp != '0'){
        scanf("%c",&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);
                printf("\n反轉L後\n");
                ListTraverse(L);
                printf("\n");
                break;

            case '0':
                exit(0);
        }
    }

}

前面我們大約把單鏈表 ADT 的基本操作都過了一遍，但是這還不夠。單鏈表在面試與筆試中出現的機率很高，接下來我們再花點時間把常見的單鏈表面試題儘可能過一遍，徹底掌握單鏈表～
那開始我們的第一個面試題？不妨做做“單鏈表反轉”，或者說“單鏈表逆序”吧？還是基於前面的例子。

究竟要如何反轉呢？我們不妨拿一個例子來說明一下算法。

我先畫一個單鏈表，這個單鏈表有4個元素。我的思路就是，每次把第二個元素提到最前面來。比如下面是第一次交換，我們先讓頭結點的next域指向結點a2，再讓結點a1的next域指向結點a3，最後將結點a2的next域指向結點a1，就完成了第一次交換。

第一次交換

然後進行相同的交換將結點a3移動到結點a2的前面，然後再將結點a4移動到結點a3的前面就完成了反轉。

第二次交換

第三次交換

思路有了，那就可以寫代碼了。這裏我們需要額外的兩個工作指針來輔助交換。這個下面的步驟慢慢理解下，結合圖片。注意結點之間的關係要先斷再連。

步驟：

定義當前結點 current，初始值爲首元結點，current = L->next;
定義當前結點的後繼結點 pnext， pnext = current->next;
只要 pnext 存在，就執行以下循環：
- 定義新節點 prev，它是 pnext的後繼結點，prev = pnext->next;
- 把pnext的後繼指向current, pnext->next = current;
- 此時，pnext 實際上已經到了 current 前一位成爲新的current，所以這個時候 current 結點實際上成爲新的 pnext，current = pnext;
- 此時，新的 current 就是 pnext，current = pnext;
- 而新的 pnext 就是 prev，pnext = prev;
最後將頭結點與 current 重新連上即可，L->next = current;

函數設計如下：

/* 單鏈表反轉/逆序 */
Status 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);
    }
    //printf("current = %d,next = %d \n",current->data,current->next->data);
    L->next = current;  /* 將鏈表頭節點指向p1 */
    return L;
}

其實在你寫函數的時候，我也寫了個函數，也能運行。思路也差不多，不過你的current一直是表的第一個結點，我這裏的current始終是首元結點的值，我的函數需要每次對pnext重新賦值。一會解釋下。

Status 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;
    }
    return L;
}

p = current->next; p 就相當於前面的 pnext。（圖1中a2即爲p）
current->next = p->next; p->next 就相當於 prev的角色，這句代碼意思是 current 的後繼指向 prev.（相當於圖1中a1->next = a3(a2->next)）
p->next = L->next; 這句就是 p 的後繼直接指向首元節點。（相當於圖1中a2->next = a1）
L->next = p; 然後再將頭結點指向 p。（相當於圖1中L->next = a2）

參照圖就很容易理解上面的步驟了。我覺得我這麼寫比你的清晰一些。我先將current指向prev，再將pnext指向current，最後將頭結點指向pnext。

這個是程序運行的結果。

整體創建L的元素(頭插法)：
// 原鏈表，current = 68， pnext = 55，68指向18，55指向18，頭結點指向55
-> 68 -> 55 -> 18 -> 45 -> 41 -> 43 -> 5 -> 28 -> 80 -> 67

// 第一次交換後，原鏈表變成這樣
-> 55 -> 68 -> 18 -> 45 -> 41 -> 43 -> 5 -> 28 -> 80 -> 67
// 進行第二次交換，pnext = 18，68指向45，18變成頭結點
-> 18 -> 55 -> 68 -> 45 -> 41 -> 43 -> 5 -> 28 -> 80 -> 67
// 進行第三次交換，pnext = current->next = 45，68指向41，45變成頭結點
-> 45 -> 18 -> 55 -> 68 -> 41 -> 43 -> 5 -> 28 -> 80 -> 67
// ……
-> 41 -> 45 -> 18 -> 55 -> 68 -> 43 -> 5 -> 28 -> 80 -> 67

-> 43 -> 41 -> 45 -> 18 -> 55 -> 68 -> 5 -> 28 -> 80 -> 67

-> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68 -> 28 -> 80 -> 67

-> 28 -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68 -> 80 -> 67

-> 80 -> 28 -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68 -> 67
// current 68 沒有後繼，反轉結束
-> 67 -> 80 -> 28 -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68


反轉L後
-> 67 -> 80 -> 28 -> 5 -> 43 -> 41 -> 45 -> 18 -> 55 -> 68

最後附上完整代碼，反轉有兩個函數。

方法1，current始終保持在第一位，pnext與prev遍歷並完成交換。
方法2，current始終是原鏈表的第一個數，然後把pnext不斷移動到首位。

#include "stdio.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;
}

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;
}

/* 單鏈表反轉/逆序 */
Status 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;
}

Status 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;
}

int main()
{
    LinkList L;
    Status i;
    int j,k,pos,value;
    char 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.鏈表反轉逆序");
    printf("\n0.退出 \n請選擇你的操作：\n");
    while(opp != '0'){
        scanf("%c",&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);
                printf("\n反轉L後\n");
                ListTraverse(L);
                printf("\n");
                break;

            case '0':
                exit(0);
        }
    }

}

單鏈表的翻轉

Nginx R31 doc 官方文檔-01-nginx 如何安裝

Qt/C++音視頻開發74-合併標籤圖形/生成yolo運算結果圖形/文字和圖形合併成一個/水印濾鏡

挑戰程序設計競賽 2.2章習題 POJ - 3617 Best Cow Line 貪心

字節面試：MySQL什麼時候鎖表？如何防止鎖表？

.NET8連接SQL SERVER 2008 R2 報：證書鏈是由不受信任的頒發機構頒發的

golang開發環境搭建(win10)

python計算機視覺學習筆記——PIL庫的用法

單鏈表就地逆置（Java版），單鏈java版

mysql索引失效的幾種情況

Nginx使用反向代理時Hessian411錯誤解決方案(轉)

瀏覽器中輸入URL到返回頁面的全過程

JVM性能調優

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結