链表练习

1.双链表的增删查改
typedef int Type;

typedef struct Node

{

	Type _data;

	struct Node* _next;

	struct Node* _prev;



}Node;



typedef struct List

{

	Node* _header;

}List;



void printList(List* lst);



void listInit(List* lst);

Node* creatNode(Type data);



void listPushBack(List* lst, Type data);

void listPopBack(List* lst);



void listPushFront(List* lst, Type data);

void listPopFront(List* lst);



void listInsert(Node* pos, Type data);

void listErase(Node* pos);





void listDesroy(List* lst);

void listInit(List* lst)

{

	//创建一个头结点, 构成循环结构

	lst->_header = creatNode(0);

	lst->_header->_next = lst->_header;

	lst->_header->_prev = lst->_header;

}

Node* creatNode(Type data)

{

	Node* node = (Node*)malloc(sizeof(Node));

	node->_prev = node->_next = NULL;

	node->_data = data;

	return node;

}



void printList(List* lst)

{

	Node* cur = lst->_header->_next;

	while (cur != lst->_header)

	{

		printf("%d ", cur->_data);

		cur = cur->_next;

	}

	printf("\n");

}



void listPushBack(List* lst, Type data)

{

	/*

	Node* node = creatNode(data);

	Node* last = lst->_header->_prev;

	// last node _header

	last->_next = node;

	node->_prev = last;



	node->_next = lst->_header;

	lst->_header->_prev = node;

	*/

	//尾插

	listInsert(lst->_header, data);

}



void listPopBack(List* lst)

{

	/*

	Node* last, *prev;

	//注意： 不能删除header

	if (lst->_header->_next == lst->_header)

		return; //空链表，没有数据可以删除



	last = lst->_header->_prev;

	prev = last->_prev;

	// prev _header

	prev->_next = lst->_header;

	lst->_header->_prev = prev;



	free(last);

	*/

	listErase(lst->_header->_prev);

}



void listPushFront(List* lst, Type data)

{

	/*

	Node* front = lst->_header->_next;

	Node* node = creatNode(data);



	node->_next = front;

	front->_prev = node;



	node->_prev = lst->_header;

	lst->_header->_next = node;

	*/

	listInsert(lst->_header->_next, data);

}



void listPopFront(List* lst)

{

	/*

	Node* front, *next;

	if (lst->_header->_next == lst->_header)

		return;



	front = lst->_header->_next;

	next = front->_next;



	free(front);

	lst->_header->_next = next;

	next->_prev = lst->_header;

	*/

	listErase(lst->_header->_next);

}



void listInsert(Node* pos, Type data)

{

	Node* prev = pos->_prev;

	Node* node = creatNode(data);

	// prev node pos

	prev->_next = node;

	node->_prev = prev;



	node->_next = pos;

	pos->_prev = node;

}

void listErase(Node* pos)

{

	Node* prev, *next;

	//删除当前位置的节点

	//注意： header不能删除

	if (pos->_next == pos)

		return; //空表不能删除

	prev = pos->_prev;

	next = pos->_next;

	free(pos);

	prev->_next = next;

	next->_prev = prev;

}





void listDesroy(List* lst)

{

	Node* cur = lst->_header->_next;

	while (cur != lst->_header)

	{

		Node* next = cur->_next;

		free(cur);

		cur = next;

	}

	free(lst->_header);

	lst->_header = NULL;

}

//2.对链表进行插入排序
struct ListNode* insertionSortList(struct ListNode* head){

    struct ListNode *cur, *prev, *start, *newH;

    if(head == NULL || head->next == NULL){

        return head;

    }

    prev = head;

    cur = head->next;

    newH = (struct ListNode*)malloc(sizeof(struct ListNode));

    newH->next = head;

    while(cur){

        if(cur->val >= prev->val){

            prev = cur;

            cur = cur->next;

        }

        else{

            start = newH;

            while(start->next && start->next->val <= cur->val){

                start = start->next;

            }

            //start   cur  start->next

            prev->next = cur->next;

            cur->next = start->next;

            start->next = cur;

            cur = prev->next;

        }

    } 

    cur = newH->next;

    free(newH);

    return cur;

}

//3.在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针
class Solution {

public:

  ListNode* deleteDuplication(ListNode* pHead)

  {

    if(pHead == NULL || pHead->next == NULL){

      return pHead;

    }

    ListNode* prev, *cur, *next, *newH, *tmp;

    newH = (ListNode*)malloc(sizeof(ListNode));

    newH->next = pHead;

    prev = newH;

    cur = pHead;

    next = cur->next;

    while(next){

      if(cur->val != next->val){

        prev = cur;

        cur = next;

        next = next->next;

      }

      else{

        while(next && cur->val == next->val){

          next = next->next;

        }

        while(cur != next){

          tmp = cur->next;

          free(cur);

          cur = tmp;

        }

        prev->next = cur;

        if(next)

          next = next->next;

      }

    }

    cur = newH->next;

    free(newH);

    return cur;

  }

};