链表集锦

/* LNode表示该结构类，是该结构的一个实例
LinkList是该结构类的指针，指代的是一个实例的地址

他们的区别在于访问其成员不一样：
LNode.data
LinkList->data

举个通俗的例子：人
小明站在河边。
LNode相当于小明
LinkList相当于 在河边的那个人
当 LinkList=&LNode 时候就表示小明在河边 */
typedef struct LNode{
	ElemType data;
	struct LNode  *next;
}LNode,*LinkList;



//单向链表,3个文件
//LinkList.h
#ifndef LINKLIST_H
#define LINKLIST_H
#define INFINITY 65535
typedef int ElemType;

typedef struct node
{
	ElemType data;
	struct node *next;
}LinkNode, *LinkList;

void InitList(LinkList *l); //初始化单链表  
void InsertList(LinkList l, int i, ElemType e); //在单链表的第i个位置插入元素e  
void DeleteList(LinkList l, int i);//删除单链表的第i个位置的元素,把删除的元素存入*e
void GetElem(LinkList l, int i);//返回链表中第i个位置的元素
void Print(LinkList l);
void Push_front(LinkList l,ElemType e); //倒序插入元素  
void Push_back(LinkList l,ElemType e); //正序插入元素
void DestroyList(LinkList l);

#endif

/
//method.cpp 具体方法实现
#include "stdafx.h"
#include "LinkList.h"
#include <stdio.h>
#include <stdlib.h>

void InitList(LinkList *l) //初始化链表
{
	(*l) = (LinkList)malloc(sizeof(LinkNode));
	(*l)->next = NULL;
}

void InsertList(LinkList l, int i, ElemType e) //在链表的第i个位置插入元素e  
{
	LinkList p = l->next;
	int j = 1;

	while (p && j<i-1) //使p成为要插入位置的前一个结点  
	{
		p = p->next;
		++j;
	}

	if (!p)
	{
		printf("超出范围插入失败\n");
		return;
	}
	else
	{
		LinkList temp = (LinkList)malloc(sizeof(LinkNode));
		temp->data = e;
		temp->next = p->next; //使新结点的指针域指向p的指针域所指向的位置  
		p->next = temp; //使p的指针域指向新结点
	}
}

void DeleteList(LinkList l, int i) //删除第i个位置的结点,将结点的数据赋值给*e  
{
	LinkList p = l->next;
	int j = 1;

	while (p && j<i-1) //移动到要删除的结点的前一个结点  
	{
		p = p->next;
		++j;
	}

	if (p)
	{
		LinkList temp = p->next; //使temp指向要删除结点
		p->next = temp->next; //使p->next指向要删除的结点的下一个结点
		free(temp);
	}
}

void GetElem(LinkList l, int i) //将第i个元素的位置存入*e  
{
	LinkList temp = l->next;
	int j = 1;

	while (temp && j<i)
	{
		temp = temp->next;
		++j;
	}

	if (temp)
	{
		printf("%d\n",temp->data);
	}
	else
	{
		printf("没有找到\n");
	}
}

void Print(LinkList l) //打印链表
{
	LinkList p = l->next;

	while (p)
	{
		printf("%d ",p->data);
		p = p->next;
	}

	printf("\n");
}

void Push_front(LinkList l, ElemType e) //倒序插入元素  
{
	LinkList temp = (LinkList)malloc(sizeof(LinkNode));
	temp->data = e; 
	temp->next = l->next; //新结点的指针域指向头结点所指向的结点  
	l->next = temp; //头结点指向新结点 
}

void Push_back(LinkList l, ElemType e) //正序插入元素 
{
	static LinkList order = l;
	LinkList temp = (LinkList)malloc(sizeof(LinkNode));
	temp->data = e;
	temp->next = order->next; //temp保存上一个指针域
	order->next = temp;      //上下两个指针链接起来，此时temp->next保存order->next，原来order指向哪里就哪里
	order = order->next; //使order一直指向最后一个结点 ，如果原来order指向第1个结构体，order = order->next执行后已经指向第2个结构体
}

void DestroyList(LinkList l) //清空链表 
{
	while (l)
	{
		LinkList temp = l;
		l = l->next;
		free(temp);
	}
}

/

//main.cpp 测试
#include "stdafx.h"
#include "LinkList.h"
#include <stdio.h>

int main(void)
{
	LinkList l;
	InitList(&l);

	int i;

	for (i = 1; i<20; i+=2)
	{
		Push_back(l, i);
	}
	printf("链表的元素为:\n");
	Print(l);

	printf("在第11个位置插入元素:22,插入后的链表元素为:\n");  
	InsertList(l, 11, 22);
	Print(l);

	printf("在第5个位置删除元素后的链表为:\n");  

	DeleteList(l, 5);
	Print(l);

	printf("链表第7个位置的元素为: ");  
	GetElem(l, 7);

	DestroyList(l);

	return 0;
}

///

//双向链表，3个文件
//LinkList.h
typedef int ElemType;
typedef struct node
{
	ElemType data;
	struct node *next; //链表的指针域,指向后继  
	struct node *prev; //链表的指针域,指向前驱
}LinkNode, *LinkList;

void InitList(LinkList *l); //初始化链表 
void CreateList(LinkList l); //创建一个双向链表 
void InsertList(LinkList l, int i, ElemType e); //在双向链表的第i个位置插入元素  
void DeleteList(LinkList l, int i); //删除双向链表的第i个位置的元素  
void DestroyList(LinkList l); //销毁双向链表 
void Print(LinkList l);
int GetLinkLength(LinkList l);

/
//method.cpp
#include "stdafx.h"
#include "LinkList.h"
#include <stdio.h>
#include <stdlib.h>

void InitList(LinkList *l)
{
	(*l) = (LinkList)malloc(sizeof(LinkNode));
	(*l)->next = (*l)->prev = NULL;
}

void CreateList(LinkList l)
{
	LinkList order = l;
	printf("请输入双向链表的数据:\n");  
	int data;

	while ((scanf("%d",&data)) != EOF)
	{
		LinkList temp = (LinkList)malloc(sizeof(LinkNode));

		if (temp) //如果内存分配成功  
		{
			temp->data = data;
			temp->next = order->next; //使新结点的指针域指向当前结点所指向的结点  

			if (order == l) //如果temp是第一个结点,则他的指向前驱的指针是NULL  
			{
				temp->prev = NULL;
			}
			else
			{
				temp->prev = order; //否则就指向当前的结点 
			}

			order->next = temp; //当前结点的后继指针域指向新结点
			order = order->next; //指向当前结点的指针指向新结点
		}
	}
}

int GetListLength(LinkList l)
{
	int i = 0;
	LinkList temp = l->next;

	while (temp)
	{
		temp = temp->next;
		i++;
	}

	return i;
}

void InsertList(LinkList l, int i, ElemType e)
{
	if (i < 1 || i > GetListLength(l) + 1)
	{
		return;
	}

	LinkList temp = l;

	int j;
	for (j = 0; j < i - 1; ++j)  //循环到要插入的位置的前一个位置  
	{
		temp = temp->next;
	}

	LinkList tp = (LinkList)malloc(sizeof(LinkNode));

	if (tp)
	{
		tp->data = e; //初始化新结点的数据 
		tp->next = temp->next; //初始化新结点的后继指针域 
		temp->next->prev = tp; //使当前结点的后继结点的前驱指针域指向新结点  
		temp->next = tp; //当前结点指向的后继指针域指向新结点 
		tp->prev = temp; //新结点的后继指针域指向当前结点 
	}
}

void DeleteList(LinkList l, int i)
{
	if(i < 1 || i > GetListLength(l)) //超出范围返回  
	{
		return;
	}

	LinkList temp = l;

	int j;
	for (j = 0; j < i; ++j)
	{
		temp = temp->next;
	}

	temp->prev->next = temp->next; //使要删除结点的前驱的后继指针指向要删除的结点的后继结点  
	temp->next->prev = temp->prev; //使要删除结点的后继结点的前驱指针指向要删除结点的后继结点  
	free(temp);
}

void DestroyList(LinkList l)
{
	LinkList temp = l->next;

	while (temp)
	{
		LinkList tp = temp;
		temp = temp->next;
		free(tp);
	}
	
	free(l);
}

void Print(LinkList l)
{
	LinkList temp = l->next;

	while (temp)
	{
		printf("%d ",temp->data);  
		temp = temp->next;
	}

	printf("\n");
}

//
//main.cpp
#include "stdafx.h"
#include "LinkList.h"
#include <stdio.h>
int main()
{
	LinkList l;
	InitList(&l);
	CreateList(l);
	Print(l);
	printf("在链表的第2个位置插入元素:5\n");
	InsertList(l,2,5);
	Print(l);
	printf("删除链表的第3个位置的元素:\n");
	DeleteList(l,3);
	Print(l);
	DestroyList(l);
	return 0;
}

///
//单链表
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
    int data;
    struct node *next;
}node;

/*
int init_linklist(node **head)
{
    if (NULL == head)
    {
        return -1;
    }

    *head = (node *)malloc(sizeof(node));
    if (NULL == *head)
    {
        return -1;
    }
    (*head)->next = NULL;
    
    return 0;
}*/
/*
int insert_linklist(node **head, int i, int data)
{
    if (NULL == head)
    {
        return -1;
    }

    int j = 0;
    node *p = *head;

    while (p && (j < i))
    {
        j++;
        p++;
    }
    if ((NULL == p) || (j > i - 1)) 
    {
        return -1;
    }

    node *s = (node *)malloc(sizeof(node));
    if (NULL == s)
    {
        return -1;
    }
    s->data = data;
    s->next = p->next;
    p->next = s;

    return 0;
}
*/
/*
int length_linklist(node *head)
{
    if (NULL == head)
    {
        return -1;
    }

    int count = 0;
    node *p = head->next;

    while (p)
    {
        count++;
        p = p->next;
    }

    return count;
}
*/


void output_linklist(node *head)
{
    if (NULL == head)
    {
        return;
    }

    node *p = head->next;

    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }

    return;
}

int delete_linklist(node **head, int i)
{
    if (NULL == head)
    {
        return -1;
    }

    int j = 0;
    node *p = (*head)->next;
    node *q = NULL;

    while (p &&(j < i - 1))
    {
        p = p->next;
        j++;
    }
    if ((NULL == p) || (j > i - 1))
    {
        return -1;
    }

    q = p->next;
    if (NULL == q)
    {
        return -1;
    }
    p->next = q->next;
    free(q);

    return 0;
}


int remove_linklist(node **head, int data)
{
    if (NULL == head)
    {
        return -1;
    }

    node *p = (*head)->next;
    node *q = NULL;

    while (p && (p->data != data))
    {
        p = p->next;
    }
    if (NULL == p)
    {
        return -1;
    }

    q = p->next;
    p->next = q->next;
    free(p);

    return 0;
}

int destory_linklist(node **head)
{
    if ((NULL == head) || (NULL == *head))
    {
        return -1;
    }

    clear_linklist(head);

    if (*head)
    {
        free(head);
        head = NULL;
    }

    return 0;
}

int clear_linklist(node *head)
{
    if (NULL == head)
    {
        return -1;
    }

    node *p = head->next;
    node *q = NULL;

    while (p)
    {
        q = p->next;
        free(p);
        p = q;
    }

    return 0;
}


int main(void)
{
    node *La = NULL;

 /*   if(init_linklist(&La) < 0)
    {
        printf("init error\n");
        return -1;
    }
*/
    int i;
    for(i = 0; i<5 ;i++)
    {
        if(insert_linklist(&La,i+1,i+1) < 0)
        {
            printf("insert error\n");
            return -1;
        }
    }
    
    printf("LinkLength: %d\n",length_linklist(La));
    
    output_linklist(La);

    if(destory_linklist(&La) < 0)
    {
        return -1;
    }

    return 0;
}

//
//4、递升链表合并
#include <stdio.h>
#include <stdlib.h>

#define MAXLENGTH 5

struct Data {
    int data;
    struct Data *next;
};

struct Data *list_merge(struct Data *list_a, struct Data *list_b, struct Data *result);

int main(){
    typedef struct Data Data;
    Data *head_a, *head_b;
    Data *now_a, *now_b;
    Data *curr;

    head_a = (Data *)malloc(sizeof(Data));
    head_a -> data = 1;
    now_a = head_a;

    head_b = (Data *)malloc(sizeof(Data));
    head_b -> data = 2;
    now_b = head_b;

    int i;
    for (i = 1; i < MAXLENGTH; i++){
        curr = (Data *)malloc(sizeof(Data));
        curr->data = i*2 + 1;
        curr->next = NULL;
        now_a -> next = curr;
        now_a = curr;
    }

    for (i = 1; i < MAXLENGTH + 2; i++){
        curr = (Data *)malloc(sizeof(Data));
        curr -> data = i * 2 + 2;
        curr -> next = NULL;
        now_b -> next = curr;
        now_b = curr;
    }

    printf("List A: ");
    now_a = head_a;
    while (now_a != NULL){
        printf("%d", now_a -> data);
        if (now_a -> next != NULL)
            printf(" -> ");
        now_a = now_a -> next;
    }
    printf("\n");

    printf("List B: ");
    now_b = head_b;
    while (now_b != NULL){
        printf("%d", now_b -> data);
        if (now_b -> next != NULL)
            printf(" -> ");
        now_b = now_b -> next;
    }
    printf("\n");

    printf("After merge: ");
    Data *result = NULL;
    result = list_merge(head_a, head_b, result);
    while (result) {
        printf("%d", result -> data);
        if (result -> next != NULL){
            printf(" -> ");
        }
        result = result -> next;
    }
    printf("\n");
    return 0;
}

struct Data *list_merge(struct Data *list_a, struct Data *list_b, struct Data *result){
    struct Data *pa, *pb, *pc;
    pa = list_a;
    pb = list_b;
    if (pa != NULL && pb != NULL && pa -> data <= pb -> data){
        result = pa;
        pc = pa;
        pa = pa -> next;
    }else if (pa != NULL && pb != NULL) {
        result = pb;
        pc = pb;
        pb = pb -> next;
    }

    while (pa && pb){
        if (pa -> data <= pb -> data){
            pc -> next = pa;
            pc = pa;
            pa = pa -> next;
        }else{
            pc -> next = pb;
            pc = pb;
            pb = pb -> next;
        }
    }
    pc -> next = pb == NULL ? pa : pb;
    pc = result;
    return pc;

}



//链表c++
#include <iostream>
using namespace std;


typedef struct LNODE
{
	int    iData;
	LNODE *pNext;
}*SLINK;

LNODE *pPtr, *pTemp;

SLINK CreateList_S(int iArr[], int iNum)
{
	int iCnti;
	SLINK L = new LNODE;
	if (!L)
	{
		exit(1);
	}

	L->pNext = NULL;
	LNODE *pTail = L;

	for (iCnti = 0; iCnti < iNum; iCnti++)
	{
		pPtr = new LNODE;
		if (!pPtr)
		{
			exit(1);
		}
		pPtr->iData = iArr[iCnti];
		pTail->pNext = pPtr;
		pTail = pPtr;
	}
    pTail->pNext = NULL;

    return L;
}

SLINK CreateList_R(int iArr[], int iNum)
{
	int iCnti;
	SLINK L = new LNODE;
	if (!L)
	{
		exit(1);
	}
	
	L->pNext = NULL;

	for (iCnti = iNum; iCnti > 0; --iCnti)
	{
		pPtr = new LNODE;
		if (!pPtr)
		{
			exit(1);
		}
		pPtr->iData = iArr[iCnti-1];
		pPtr->pNext = L->pNext;
		L->pNext = pPtr;
	}

	return L;
}

bool InsertList(SLINK &L, int iPoint, const int iData)
{
	int iCntj = 0;
	pPtr = L;

	while (pPtr && (iCntj < iPoint-1))
	{
		pPtr = pPtr->pNext;
		iCntj++;
	}

	if (!pPtr || (iCntj > iPoint - 1))
	{
		return false;
	}

	pTemp = new LNODE;
	if (!pTemp)
	{
		exit(1);
	}
	pTemp->iData = iData;
	pTemp->pNext = pPtr->pNext;
	pPtr->pNext = pTemp;

	return true;	
}


void PrintList(const SLINK &L)
{
	pPtr = L->pNext;
	
	while (pPtr)
	{
		cout<<pPtr->iData <<" ";
		pPtr = pPtr->pNext;
	}
	cout<<endl;

	return;
}

bool DeleteList(SLINK &L, int iPoint)
{
	int iCntj = 0;
	pPtr = L;

	while (pPtr->pNext && (iCntj < iPoint -1))
	{
		pPtr = pPtr->pNext;
		iCntj++;
	}
	if (!pPtr || (iCntj > iPoint-1))
	{
		return false;
	}

	pTemp = pPtr->pNext;
	pPtr->pNext = pTemp->pNext;
	delete pTemp;
	
	return true;
}

int main(void)
{
	int iArr[] = {1, 3, 4, 2, 5};

	SLINK head1 = CreateList_S(iArr, 5);
    PrintList(head1);

	SLINK head2 = CreateList_R(iArr, 5);
    PrintList(head2);

	InsertList(head2, 6, 8);
	PrintList(head2);

	DeleteList(head2, 2);
	PrintList(head2);
	
	return 0;
}



//循环链表，解决约瑟夫问题
#include <stdio.h>
#include <stdlib.h>

#define MAX_NUM 5

typedef struct NODE
{
	int iData;
	struct NODE *pNext;
}NODE_S;

/* 创建循环链表 */
NODE_S *CreateList(int iNum)
{
	int iCnti;
	NODE_S *pHead = NULL;
	NODE_S *ptail = NULL;
	NODE_S *pPtr = NULL;

	for (iCnti = 0; iCnti < iNum; iCnti++)
	{
		pPtr = (NODE_S *)malloc(sizeof(NODE));
		if (NULL == pPtr)
		{
			exit(1);
		}
		pPtr->iData = iCnti;

		if (NULL == pHead)
		{
			pHead = pPtr;
		}
		else
		{
			ptail->pNext = pPtr;
		}

		ptail = pPtr;
	}
	pPtr->pNext = pHead;
	
	return(pHead);
}

//约瑟夫问题
void Josephus(NODE_S *pHead, int iStart)
{
	int iCnti;
	NODE_S *pPtr = pHead;
	NODE_S *pTail;

	/* 寻找第一个报数点的位置 */
	for (iCnti = 0; iCnti < iStart; iCnti++)
	{
		pTail = pPtr;
		pPtr = pPtr->pNext;
	} /* 此时p指向第1个出发点 */

	/* 一直循环直到链表中只剩下一个链接点   */
	while (pPtr->pNext != pPtr)
	{
		for (iCnti = 1; iCnti < MAX_NUM; iCnti++)
		{
			pTail = pPtr;
			pPtr = pPtr->pNext;
		} /* 此时p指向第m个结点，r指向第m-1个结点  */

		pTail->pNext = pPtr->pNext;
		printf( "%d ", pPtr->iData);    /* 输出一个结点编号 */
		free(pPtr);
		pPtr = pTail->pNext;
	}
	printf( "%d\n", pPtr->iData);  /* 输出最后那个结点的编号 */

	return;
}

void PrintList(NODE_S *pHead)
{
	NODE_S *pPtr = pHead;

	while (pPtr->pNext != pHead)
	{
		printf("%d ", pPtr->iData);
		pPtr = pPtr->pNext;
	}
	printf("%d ", pPtr->iData);

	return;
}

int main(void)
{
	int iStart = 3;
	NODE_S *pHead;
	pHead = CreateList(MAX_NUM);
	PrintList(pHead);
	printf("\n");
    Josephus(pHead, iStart);

	return 0;
}
///

//双向链表（自己实现）
#include <stdio.h>
#include <stdlib.h>

typedef struct NODE
{
	int iData;
	struct NODE *pNext;
	struct NODE *pPrev;
}NODE_S;

void InitList(NODE_S **pHead)
{
	(*pHead) = (NODE_S *)malloc(sizeof(NODE_S));
    (*pHead)->pNext = (*pHead)->pPrev = NULL;

	return;
}

void CreateList(NODE_S *pHead)
{
	int iData;
	NODE_S *pOrder = pHead;
	printf("请输入双向链表的数据:\n");  

	while(EOF != (scanf("%d", &iData)))
	{
		NODE_S *pTemp = (NODE_S*)malloc(sizeof(NODE_S));
		if (pTemp) /* 如果内存分配成功 */
		{
			pTemp->iData = iData;
			pTemp->pNext = pOrder->pNext; /* 使新结点的指针域指向当前结点所指向的结点   */

			if (pOrder == pHead)
			{
				pTemp->pPrev = NULL;
			} 
			else
			{
				pTemp->pPrev = pOrder;
			}

			pOrder->pNext = pTemp;
			pOrder = pOrder->pNext;
		}
	}

	return;
}

int GetListLength(NODE_S *pHead)
{
	int iCnti = 0;
	NODE_S *pTemp = pHead->pNext;

	while (pTemp)
	{
		pTemp = pTemp->pNext;
		iCnti++;
	}

    return iCnti;
}

void InsertList(NODE_S *pHead, int iPoint, int iData)
{
	if ((iPoint < 1) || (iPoint > GetListLength(pHead) + 1))
	{
		return;
	}

	NODE_S *pPtr = pHead;
	int iCnti;
	for (iCnti = 0; iCnti < iPoint - 1; iCnti++)
	{
		pPtr = pPtr->pNext;
	}

	NODE_S *pTemp = (NODE_S*)malloc(sizeof(NODE_S));

	if (pTemp)
	{
		pTemp->iData = iData;
		pTemp->pNext = pPtr->pNext;
		pPtr->pNext->pPrev = pTemp;
		pPtr->pNext = pTemp;
		pTemp->pPrev = pPtr;
	}

	return;
}

void PrintList(NODE_S *pHead)
{
	NODE_S *pTemp = pHead->pNext;

	while (pTemp)
	{
		printf("%d ", pTemp->iData);
		pTemp = pTemp->pNext;
	}
	printf("\n");

	return;
}

void DeleteList(NODE_S *pHead, int iPoint)
{
	if ((iPoint < 1) || (iPoint > GetListLength(pHead) + 1))
	{
		return;
	}

	NODE_S *pTemp = pHead;
	int iCnti;
	for (iCnti = 0; iCnti < iPoint; iCnti++)
	{
		pTemp = pTemp->pNext;
	}
     pTemp->pPrev->pNext = pTemp->pNext;
	 pTemp->pNext->pPrev = pTemp->pPrev;
	 free(pTemp);

	 return;
}

void DestoryLst(NODE_S *pHead)
{
	NODE_S *pPtr = pHead->pNext;

	while (pPtr)
	{
		NODE_S *pTemp = pPtr;
		pPtr = pPtr->pNext;
		free(pTemp);
	}

	return;
}

int main(void)
{
	NODE_S *pHead;
	InitList(&pHead);
	CreateList(pHead);
	PrintList(pHead);

	InsertList(pHead, 3, 100);
	PrintList(pHead);

	DeleteList(pHead, 2); /* 删除头结点会出问题 */
	PrintList(pHead);

	DestoryLst(pHead);
	
	return 0;
}
///