链表操作

一、有头节点、无头节点

有头节点的链表，第一个节点一般不存数据，无头节点的，第一个节点就放数据。
我们一般使用的都是有头节点的，这样初始化的时候就获得了链表头部地址。如果使用无头节点的，那么只有在创建第一个数据节点时，才能知道链表头地址。
我们使用的时候，一般会再次封装一个结构体，将链表头部节点，放到这个结构体里。

//有头节点
phead = (struct node*)malloc(sizeof(struct node));
phead->pnext = NULL;

pnode = create_node(1);
insert_tail(phead, pnode);

//没有头节点
phead = create_node(1);
pnode = create_node(22);
insert_tail(phead, pnode);	

二、单链表操作

typedef struct node
{
    int data;
    struct node *pnext;
}node;
//创建节点
node* create_node(int data)
{
	node *pnode = (node*)malloc(sizeof(node));
	pnode->data = data;
	pnode->pnext = NULL;
	return pnode;
}
//尾插
void insert_tail(node *phead, node *pnode)
{
	node *p1 = phead;
	node *p2 = p1->pnext;
	while (p2)
	{
	    p1 = p2;
	    p2 = p2->pnext;
	}
	p1->pnext = pnode;
	return;
}
//遍历
void bianli(node *phead)
{
	node *pnode = phead->pnext;
	while (pnode)
	{
		cout << "data: " << pnode->data << endl;
		pnode = pnode->pnext;	
	}
	return;
}   

//自动排序插入

void insert_auto(node *phead, node *pnode)
{
	node *p1 = phead;
	node *p2 = p1->pnext;
	while (p2)
	{
	    if (p2->data < pnode->data) {
	        p1 = p2;
	        p2 = p2->pnext;
	    }
	    else {
	        p1->pnext = pnode;
	        pnode->pnext = p2;
	        return;
	    }
	}
	p1->pnext = pnode;
	return;
}

//链表排序

int get_size(node *phead)
{
	int count = 0;
	node *pnode = phead->pnext;
	while (pnode)
	{
		count++;
		pnode = pnode->pnext;
	}
	return count;
}
void paixu(node *phead)
{
	int n = get_size(phead);
	if (n < 2)
		return;
	node *pnode1, *pnode2;
	int tmp;

	for (int i = 0; i < n -1; i++) 
	{
		pnode1 = phead->pnext;
		pnode2 = pnode1->pnext;
		for (int j = 0; j < n -1 - i; j++)
		{
			if (pnode1->data > pnode2->data) {
				tmp = pnode1->data;				
				pnode1->data = pnode2->data;
				pnode2->data = tmp;
			}
			pnode1 = pnode2;
			pnode2 = pnode2->pnext;
		}	
	}
	return;
}

删除节点，删除所有数据相同的

int delete_node(node *phead, int data)
{
	node *p1 = phead;
	node *p2 = phead->pnext;
	int ret = -1;
	
	while (p2)
	{
		if (p2->data == data) {
			p1->pnext = p2->pnext;
			free(p2);
		}
		else 
		    p1 = p2;
		p2 = p1->pnext;
	}

	return 0;
}

逆序

void nixu(node *phead)
{
	node *p1 = phead;
	node *p2 = phead->pnext;
	node *p3;

	while (p2)
	{
	    p3 = p2->pnext;
	    if (p1 == phead) 
	        p2->pnext = NULL;
        else
            p2->pnext = p1;
		p1 = p2;
		p2 = p3;
	}
	phead->pnext = p1;

	return;
}

三、双链表操作

struct node
{
	int data;
	struct node *pprev;
	struct node *pnext;
};

struct node* create_node(int data)
{
	struct node* pnode = (struct node* )malloc(sizeof(struct node));
	assert(pnode != NULL);
	bzero(pnode, sizeof(struct node));
	pnode->data = data;
	pnode->pprev = NULL;
	pnode->pnext = NULL;
	
	return pnode;
}

void iterator_node(struct node* phead)
{
	struct node *pnode = phead->pnext;
	
	while (pnode) {
		printf("data: %d\n", pnode->data);
		pnode = pnode->pnext;
	}
	
	return;	
}

struct node* insert_tail(struct node* phead, struct node* pnode)
{
	struct node *p1 = phead;
	struct node *p2 = p1->pnext;
	
	while (p2) {
		p1 = p2;
		p2 = p2->pnext;
	}
	p1->pnext = pnode;
	pnode->pprev = p1;
	
	return pnode;
}

struct node* insert_head(struct node* phead, struct node* pnode)
{
	phead->pnext->pprev = pnode;
	pnode->pnext = phead->pnext;
	pnode->pprev = phead;
	phead->pnext = pnode;
	
	return pnode;
}

int delete_node(struct node* phead, int data)
{
	struct node* pnode = phead->pnext;
	struct node *pdelete;
	
	while (pnode) 
	{
		
		if (pnode->data == data) {
			if (pnode->pnext)
				pnode->pnext->pprev = pnode->pprev;
			pnode->pprev->pnext = pnode->pnext;		
			pdelete = pnode;
			pnode = pnode->pnext;
			free(pdelete) ;
		}
		else
			pnode = pnode->pnext;
	}	
	return 0;	
}
//逆序
void nixu(struct node* phead)
{
	struct node *p2 = phead->pnext;
	struct node *p3;

	while (p2)
	{
	    p3 = p2->pnext;
	    if (p2->pprev == phead) 
	        p2->pnext = NULL;
	    else 
	        p2->pnext = p2->pprev;
	    if (p3)
	        p2->pprev = p3;
	    else {
	        p2->pprev = phead;
	        phead->pnext = p2;
	        break;
	    }
		p2 = p3;		
	}
	return;	
}

四、循环链表操作

Node *create_node(int data) 
{
    Node *pnode = (Node*)malloc(sizeof(Node));
    pnode->data = data;
    pnode->pprev = pnode;
    pnode->pnext = pnode;
    return pnode;
}
void insert_tail(Node *phead, Node *pnode)
{
    pnode->pprev = phead->pprev;
    phead->pprev->pnext = pnode;
    pnode->pnext = phead;
    phead->pprev = pnode;
    return;
}
void bianli(Node *phead)
{
    Node *pnode = phead->pnext;
    while (pnode != phead)
    {
        cout << pnode->data << endl;
        pnode = pnode->pnext;
    }
    return;
}

int delete_node(Node *phead, int data)
{
    Node *pnode = phead->pnext;
    Node *psave;
    int ret = -1;
    while (pnode != phead)
    {
        psave = pnode->pnext;
        if (pnode->data == data) {
            pnode->pnext->pprev = pnode->pprev;
            pnode->pprev->pnext = pnode->pnext;
            free(pnode);
            ret = 0;
        }
        pnode = psave;
    }
    return ret;
}