數據結構與算法單鏈表

1.什麼是鏈表

     鏈表我的理解要包含以下特徵：（1）.由n個節點離散分配；（2）.每個節點通過指針連接（3）每一個節點由一個前驅節點和一個後驅節點（4）.首節點沒有前驅節點，尾節點沒有後驅節點；

     滿足上面的4條，我們就稱爲鏈表；鏈表既然由很多個節點，那節點又由什麼組成？節點由兩個部分組成，一是數據域，用來存放有效數據；二是指針域，用來指向下一個節點；下面用C語言來構建鏈表數據結構，首先應該構造出節點，然後再把所有的節點連起來，就構成了鏈表；

（1）節點的構造

typedef struct Node
{
    ElementType element;
    Position next;
}Node;

（2）鏈表的創建

     在創建鏈表之前，我們需要需要了解一下專業術語：

   首節點：存放第一個有效數據的節點；

   尾節點：存放最後一個有效數據的節點；

   頭節點：頭節點的數據類型與首節點的數據類型相同，並且頭節點是首節點前面的那個節點，並不存放有效數據；頭節點的存在只是爲了方便鏈表的操作。

   頭指針：指向頭節點的指針；

   尾指針：指向尾節點的指針；

首先，我們應該創建一個頭節點，並用頭指針指向它，用C語言描述：用malloc向計算機申請一塊內存，並定義一個指向與頭節點數據類型相同的指針（一定要判斷申請內存是否成功）；

然後，要知道要創建鏈表的長度，用一個循環來每次創建一個節點，並把每個節點連在一起；

（3）檢查空表

int IsEmpty(List L)  
{  
    return L->Next==NULL;  
}  

如果是空表，表的第一個指針指向NULL。
（4）查找節點

Position Find(ElementType X, List L)  
{  
    Position P;  
    P = L->Next;  
    while(L!=NULL && L->Element!=X)  
        P = P->Next;  
    return P;  
}  

（5）插入節點

void Insert(ElementType X,List L,Position P)  
{  
    Position tmp;  
    Tmp = malloc(sizeof(struct Node));  
    if(tmp==NULL)  
        FatalError("Out of Space!");  
    Tmp->Element = X;  
    Tmp->Next = P->Next;  
    P->Next = Tmp;  
}  

（6）刪除節點

6.1刪除節點之前，我們要找到所刪除節點的位置，即前驅

Position FindPrevious(ElementType X, List L)  
{  
    Position P;  
    P=L;  
    while(P->Next!=NULL && P_>Next->Element!=X)  
        P=P->Next;  
    return p;  
}  

6.2找到前驅後進行刪除

void Delete(ElementType X,List L)  
{  
    Position P,Tmp;  
    P = FindPrevious(X,L);  
    if(!IsLast(P,L))  
    {  
        Tmp = P->Next;  
        p->Next = Tmp->Next;  
        free(Tmp);  
    }  
}  
int IsLast(Position P,List L)  
{  
    return P->Next==NULL;  
}  

本篇博客主要介紹帶頭結點的單鏈表的一系列操作，包括鏈表的創建，鏈表的插入，鏈表的刪除，鏈表的查找，判斷一個鏈表是否爲空，以及在寫程序的時候一些注意事項等內容。鏈表是數據內容的基礎，學好了，後面棧就比較容易了。下面就發佈可以運行的完整的程序來例舉了上述所有的內容

#include <stdio.h>
#include <stdlib.h>

struct Node;
typedef struct Node* ptrToNode;
typedef ptrToNode List;
typedef ptrToNode Position;
typedef int ElementType;

typedef struct Node
{
    ElementType element;
    Position next;
}Node;


List createList(int *ptr, int len)
{
    List head;
    Position p;
    Position tmp;
    head =(Position)malloc(sizeof(struct Node)); 
    p = (Position)malloc(sizeof(struct Node)); 
    int i = 0;
    for(; i < len; i++)
    {
	if (i == 0)
	{
		p -> element = *(ptr + i);//遍歷第一個元素 
		head -> next = p;
	}
	else
	{
   		tmp = (Position)malloc(sizeof(struct Node)); 
	     	tmp -> element=*(ptr+i);
        	p -> next = tmp;
		p = p->next;
	}
    }
    p -> next = NULL;
    return head;
}


int IsEmpty(List L)
{
   return L->next == NULL;
}

Position FindPrevious(ElementType X, List L)
{
	Position p;
	p = L;
	while(p->next != NULL && p->next->element != X)
		p = p ->next;
	return p;

}

void Delete(ElementType X, List L)
{
	Position previous;
	Position pnow;
	previous = FindPrevious(X,L);
	if(IsEmpty(previous))
	{
		printf("Sorry, there is no %d in the list!\n", X);
		exit(1);
	}
	else
	{
		pnow = previous -> next;
		previous -> next = pnow -> next;
		free(pnow);
	}
}
void prinList(List L)
{
	Position p = L -> next;
	printf("The list is: \n");
	while(p->next != NULL)
	{
		printf("%d ",p -> element);
		p = p -> next;
	}
	printf("\n");
}

void InsertList(ElementType X, Position P, List L)
{
	Position temp;
	temp =(Position)malloc(sizeof(struct Node)); 
	if (!temp)
	{
		printf("Out of space!\n");
		exit(1);
	}
	temp -> element = X;
	temp -> next = P -> next;
	P -> next = temp;
}
int main()
{
    int a[10] = {8,54,6,86,23,2,1,93,4,85};
    List L = (Position)malloc(sizeof(struct Node)); 
    L = createList(a,10);
    if(IsEmpty(L))
	{
		printf("The list is empty!\n");
		exit(1);
	}
	prinList(L);
	Delete(a[5],L);
	prinList(L);
	InsertList(a[3],L->next,L);
	prinList(L);
    return 0;
}

程序結果

參考博客：http://blog.csdn.net/lpp0900320123/article/details/20356143

                 http://blog.csdn.net/xiaxia__/article/details/16865859