【数据结构】链表

实现链表的 初始化 插入 以及相关的笔试题

头文件

#pragma once

typedef int ElemType;
typedef struct ListNode;
typedef struct ListNode
{
	ElemType data;
	struct ListNode* next;

}ListNode, * LinkList;

// 购买结点
ListNode* Buynode();
//释放空间
void Freenode(ListNode* p);
//初始化单链表
ListNode* InitList();
//清除函数
void ClearList(LinkList head);
//摧毁函数
void DestroyList(LinkList head);
//判空
bool IsEmpty(LinkList head);
//交换函数
void Swap(ElemType* ap, ElemType* bp);
//获得链表的元素个数 不算头结点
int GetSize(LinkList head);
// 打印
void PrintList(LinkList head);
// 查找val * ************
ListNode* FindValue(LinkList head, ElemType val);
// 查找val的前驱 
ListNode* FindValue_Pre(LinkList head, ElemType val);
//查找pos位置的值
ListNode* FindPos(LinkList head, int pos);
//查找pos位置前驱
ListNode* FindPos_Prev(LinkList head, int pos);
//在某个节点后面插入
bool Insert_Next(LinkList head, ListNode* ptr, ElemType val);
//找出最后一个结点；
ListNode* Getptr(LinkList head);
//尾插
void Push_Back(LinkList head, ElemType val);
//头插
void Push_Front(LinkList head, ElemType val);
//在pos位置插入数据
bool  InsertPos(LinkList head, int pos, ElemType val);
//在pos位置删除数据
bool   Erase_Next(LinkList head, ListNode* ptr);
//在头部删除
void Pop_Front(LinkList head);
//在尾部删除
void Pop_Back(LinkList head);
//删除 val相等的数据元素
bool Remove(LinkList head, ElemType val);
//删除和val相等的所有数据元素
void Remove_All(LinkList head, ElemType val);
void Remove_All_b(LinkList head, ElemType val);
//逆置链表
//三指针
void ReverseList(LinkList head);
//双指针
void ReverseList_a(LinkList head);
//通过头插法
void ReverseList_b(LinkList head);
//通过栈
void ReverseList_c(LinkList head);
//通过递归
ListNode* Reverse(ListNode* p);
void ReverseList_d(LinkList head);


// 不带头结点的链表逆置  
//递归方式

//非递归方式
ListNode* NotHeadRevese(LinkList head);

//打印单链表不带头结点的倒数第K个值
//计算法
void PrintList_K(LinkList head, int k);
int  PrintLK(ListNode* p, int k);
void PrintList_K_a(LinkList head, int k);
void PrintList_K_b(LinkList head, int k);

//返回链表的中心结点
ListNode* ListMid(LinkList head);
//双指针方案
ListNode* ListMid_a(LinkList head);

//判断有环
bool   IsCycle(LinkList head);
//返回环的开始位置
ListNode* GetCycleBegin(LinkList head);
//两个链表相交 的起始位置
ListNode* GetIntNode(LinkList heada, LinkList headb);
//快慢指针
ListNode* GetIntNode_a(LinkList heada, LinkList headb);
//
ListNode* GetIntNode_b(LinkList heada, LinkList headb);

//旋转链表
ListNode* RotaRight(LinkList head, int k);
//分割链表
ListNode* Praition(LinkList head, int k);

//单链表快排
ListNode* ListPraition(ListNode* Listbegin, ListNode* end);
void QuickPass(ListNode* begin, ListNode* end);

//判断回文链表
bool IsPail(LinkList head);
bool IsPail_a(LinkList head);//

//插入排序
ListNode* InsertPass(LinkList head);

//合并两个有序单链表
ListNode* MergeList(LinkList headA, LinkList headB);

//链表求和
ListNode* AddListNum(LinkList headA, LinkList headB);
//删除链表中重复的数据
ListNode* deleteDuplicates(ListNode* head);

ListNode* insertionSortList(ListNode* head);

//两数相加
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2);

 实现代码

#include"LinkList.h"
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<stack>
#include<iostream>
//购买结点
ListNode* Buynode()
{
	ListNode* s = (ListNode*)malloc(sizeof(ListNode));
	if (NULL == s)exit(1);
	memset(s, 0, sizeof(ListNode));
	return s;
}
//释放空间
void Freenode(ListNode* p)
{
	free(p);
 }
//初始化
ListNode* InitList()
{
	
	return Buynode();
}
//清除函数
void ClearList(LinkList head)
{
	assert(head != NULL);
	while (!IsEmpty(head))
	{
		Pop_Front(head);
	}
}
//摧毁函数
void DestroyList(LinkList head)
{
	assert(head != NULL);
	ClearList(head);
	Freenode(head);
}
//交换函数
void Swap(ElemType* ap, ElemType* bp)
{
	assert(ap != NULL || bp != NULL);
	ElemType tmp =* ap;
	*ap = *bp;
	*bp = tmp;
}
//判空
bool IsEmpty(LinkList head)
{
	assert(head != NULL);
	return head->next == NULL;
}
//获得链表的元素个数 不算头结点
int GetSize(LinkList head)
{
	assert(head != NULL);
	int i = 0;
	ListNode* p = head->next;
	while (p != NULL)
	{
		i++;
		p = p->next;
	}
	return i;
}
// 打印
void PrintList(LinkList head)
{
	assert(head != NULL);
	ListNode* p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}
// 查找val * ************
ListNode *FindValue(LinkList head, ElemType val)
{
	assert(head != NULL);
	ListNode* p = FindValue_Pre(head, val);
	if(p != NULL)
	{
		p = p->next;
	}
	return p;
}
// 查找val的前驱
ListNode* FindValue_Pre(LinkList head, ElemType val)
{
	assert(head != NULL);
	ListNode* prev = head;
	ListNode* p = head->next;
	while (p != NULL &&p->data != val)
	{

		prev = p;
		p = p->next;
	}
	if (NULL == p)
	{
		prev = NULL;
	}
	return prev;
}
// 查找pos位置的值
ListNode* FindPos(LinkList head, int pos)
{
	assert(head != NULL);
	ListNode* p = FindPos_Prev(head, pos);
	if (p != NULL)
	{
		p = p->next;
	}
	return p;
}
// 查找pos位置前驱
ListNode* FindPos_Prev(LinkList head, int pos)
{
	assert(head != NULL);
	int i = 1;
	ListNode* pre = head;
	ListNode* p = head->next;
	if (pos < 1)return NULL;
	while (p != NULL && i < pos)
	{
		pre = p;
		p = p->next;
		i++;
	}
	if (p == NULL)
	{
		pre = NULL;
	}
	return pre;
}
//在某个节点后面插入
bool Insert_Next(LinkList head, ListNode* ptr, ElemType val)
{
	assert(head != NULL);
	if (NULL == ptr)
	{
		return false;
	}
	ListNode* s = Buynode();

    s->data = val;
	s->next = ptr->next;
	ptr->next = s;

	return true;
}
//找出最后一个结点的值；
ListNode* Getptr(LinkList head)
{
	assert(head != NULL);
	ListNode* p = head;
	while (p->next !=NULL)
	{
		p=p->next;
	}
	return p;
}
//尾插
void Push_Back(LinkList head, ElemType val)
{
	assert(head != NULL);
	Insert_Next(head, Getptr(head), val);
}
//头插
void Push_Front(LinkList head, ElemType val)
{
	assert(head != NULL);
	Insert_Next(head,head ,val);
}
//在pos之前位置插入数据
bool InsertPos(LinkList head, int pos,ElemType val)
{
	assert(head != NULL);
	if (pos < 1 )return false;
	int i = 1;
	ListNode* p = head;
	while (p->next != NULL && i < pos)
	{
		p = p->next;
		i++;
	}
	if ( pos>i)return false;
	//ListNode* p = FindPos_Prev(head, pos);
	return Insert_Next(head, p, val);;
}
//在pos位置的后继 删除数据
bool   Erase_Next(LinkList head, ListNode* ptr)
{
	assert(head!= NULL);
	if (NULL == ptr||NULL==ptr->next) return false;
	ListNode* q = ptr->next;
	ptr->next=q->next ;
	Freenode(q);
	q = NULL;
	return true;
}
//在头部删除
void Pop_Front(LinkList head)
{
	assert(head != NULL);
	Erase_Next(head,head);

}
//在尾部删除
void Pop_Back(LinkList head)
{
	assert(head != NULL);
	ListNode* pre = head;
	ListNode* p = head->next;
	while (p != NULL&&p->next != NULL)
	{
		pre = p;
		p = p->next;
	}
	
	Erase_Next(head, pre);
}
//删除 val相等的数据元素
bool Remove(LinkList head, ElemType val)
{
	assert(head != NULL);
	return Erase_Next(head, FindValue_Pre(head, val));

}
//删除和val相等的所有数据元素
void Remove_All(LinkList head, ElemType val)
{
	assert(head != NULL);
	ListNode* p = NULL;
	while((p=FindValue_Pre(head,val)) != NULL)
	{
		Erase_Next(head, p);
	}
}
void Remove_All_b(LinkList head, ElemType val)
{
	assert(head != NULL);
	ListNode* pre = head;
	ListNode* p = head->next;
	while (p != NULL)
	{
		if (p->data != val)
		{
			pre = pre->next;
			Swap(&pre->data, &p->data);
		}
		p = p->next;
	}
	while (pre->next != NULL)
	{
		Erase_Next(head, pre);
	}
}


//逆置链表
//三指针
void ReverseList(LinkList head)
{
	assert(head!=NULL);
	if (head->next == NULL || head->next->next == NULL)
	{
		return;
	}
	ListNode* pre = NULL, * s = NULL;
	ListNode* p = head->next;
	while (p != NULL)
	{
		s = p;
		p = p->next;
		s->next = pre;
		pre = s;
	}
	head->next = pre;

}
//双指针
void ReverseList_a(LinkList head)
{
	assert(head != NULL);
	if (head->next == NULL || head->next->next == NULL)
	{
		return;
	}
	ListNode* s = NULL;
	ListNode* p = head->next;
	head->next = NULL;
	while (p != NULL)
	{
		s = p;
		p = p->next;
		s->next = head->next;
		head->next = s;
	}
}
//通过头插法
void ReverseList_b(LinkList head)
{
	assert(head != NULL);
	if (head->next == NULL || head->next->next == NULL)
	{
		return;
	}
	ListNode* p = head->next;
	head->next = NULL;
	while (p != NULL)
	{
		ElemType val = p->data;
		ListNode* q = p;//用来释放 防止内存泄漏
		p = p->next;
		free(q);
		Push_Front(head, val);
	}

}
//通过栈
void ReverseList_c(LinkList head)
{
	assert(head != NULL);
	if (head->next == NULL || head->next->next == NULL)
	{
		return;
	}
	int len = 0;
	ListNode* p = head->next;
	while (p != NULL)
	{
		len++;
		p=p->next;
	}
	int* stack = (int*)malloc(sizeof(int) * len);
	int top = -1;
	p = head->next;
	while (p != NULL)
	{
	
		stack[top] = p->data;
		p = p->next;
	}
	p = head->next;
	while (p != NULL)
	{
		p->data = stack[top--];
		//top-=1;
		p = p->next;
	}
	free(stack);
}
//通过递归
ListNode* Reverse(ListNode* p)
{
	if (p == NULL || p->next == NULL)
	{
		return p;
	}
	ListNode* firstnode = Reverse(p->next);
	p->next->next = p;
	p->next = NULL;
	return firstnode;
}
void ReverseList_d(LinkList head)
{
	assert(head != NULL);
	ListNode* p = head->next;
	head->next = Reverse(p);
}//O(N)

//************************************************
// 以下均为不带头结点的实现方式

// 不带头结点的链表逆置  
//非递归方式
ListNode* NotHeadRevese(LinkList head)
{
	if (head != NULL || head->next == NULL)
		return  head;
	ListNode* pre = NULL, * s = NULL;
	ListNode* p = head->next;
	while (p != NULL)
	{
		s = p;
		p = p->next;
		s->next = pre;
		pre = s;
	}
	return pre;
}



//打印单链表不带头结点的倒数第K个值
//计算法
void PrintList_K(LinkList head, int k)
{
	if (head == NULL||k<1)return;
	int n = 0;
	ListNode* p = head;
	while (p != NULL)
	{
		n++;
		p = p->next;
	}
	p = head;
	while (n > k)
	{
		n--;
		p = p->next;
	}
	printf("%d\n", p->data);
}
//递归
int  PrintLK(ListNode *p, int k)
{
	if (NULL == p)return 0;
	else
	{
		int  n = PrintLK(p->next, k) + 1;
		if (n == k)
		{
			printf("%d\n", p->data);
		}
		return n;
	}
}
void PrintList_K_a(LinkList head, int k)
{
	if (head == NULL || k < 1)return;
	PrintLK(head, k);
	
}
//双指针
void PrintList_K_b(LinkList head, int k)
{
	if (head == NULL || k < 1)return;
	ListNode* p = head, * cur = head;
	while (p != NULL && k--)
	{
		p = p->next;
	}
	if (NULL == p)
	{
		return;
	}
	while (p != NULL)
	{
		cur = cur->next;
		p = p->next;
	}
	printf("%d\n", cur->data);
}



//返回链表的中心结点
ListNode* ListMid(LinkList head)
{
	if (head == NULL || head->next == NULL)return head;
	int n = 1;
	ListNode* p = head;
	while (p != NULL)
	{
		n += 1;
		p = p->next;
	}
	p = head;
	for (int i = 0; i < n / 2; ++i)
	{
		p = p->next;
	}
	return p;
}
//双指针方案  快慢指针
ListNode* ListMid_a(LinkList head)
{

	if (head == NULL || head->next == NULL)return head;
	ListNode* fast = head;
	ListNode* slow = head;
	while (fast != NULL|| fast->next != NULL)
	{
		slow = slow->next;	
		fast = fast->next;
		if (fast->next != NULL)
		{
			break;
		}
		fast=fast->next;
	}
	return slow;
}

//判断有环
bool   IsCycle(LinkList head)
{
	bool res = true;
	if (head == NULL) return !res;
	ListNode* slow = head;
	ListNode* fast = head->next;
	while (slow != fast)
	{
		if (fast== NULL || fast->next == NULL)
		{
			res = false;
			return res;
		}
		slow = slow->next;
		fast = fast->next->next;
	}  
	return res;
}
//返回环的开始位置
ListNode* GetCycleBegin(LinkList head)
{
	if (head == NULL) return head;
	ListNode* slow = head;
	ListNode* fast = head->next;
	while (slow != fast)
	{
		if (false == NULL || fast->next == NULL)
		{
			return NULL;
		}
		slow = slow->next;
		fast = fast->next->next;
	}
	slow = head;
	while (slow != fast)
	{
		slow = slow->next;
		fast = fast->next;
	}
	return slow;
}
//两个链表相交 的起始位置
//暴力法 O(n*m)
ListNode* GetIntNode(LinkList heada, LinkList headb)
{
	if (heada == NULL || heada->next || headb == NULL || headb->next == NULL)
	{
		return NULL;
	}
	ListNode* pa = heada->next;
	while (pa != NULL)
	{
		ListNode* pb = headb->next;
		while (pb != NULL && pb != pa)
		{
			pb = pb->next;
		}
		if (pb == pa)return pa;
		pa = pa->next;
	}
	return NULL;
}
//快慢指针
ListNode* GetIntNode_a(LinkList heada, LinkList headb)
{
	if (heada == NULL || heada->next || headb == NULL || headb->next == NULL)
	{
		return NULL;
	}
	int na = GetSize(heada);
	int nb = GetSize(headb);
	ListNode* pa = heada->next;
	ListNode* pb = headb->next;
	while (na > nb) 
	{ 
		pa = pa->next;
		--na;
	}
	while (nb > na) 
	{ 
		pb = pb->next;
		--nb;
	}
	while (pa != NULL && pb != NULL && pa != pb)
	{
		pa = pa->next;
		pb = pb->next;
	}
	return pa;   

}
//a+c =b+c
ListNode* GetIntNode_b(LinkList heada, LinkList headb)
{
	if (heada == NULL || heada->next || headb == NULL || headb->next == NULL)
	{
		return NULL;
	}
	ListNode* pa = heada->next;
	ListNode* pb = headb->next;
	while (pa != pb)
	{
		if (pa == NULL)
		{
			pa = headb->next;
		}
		pa = pa->next;
		if (pb == NULL)
		{
			pb = heada->next;
		}
		pb = pb->next;
	}
	return pa;

}

//旋转链表
ListNode* RotaRight(LinkList head, int k)
{
	if (head == NULL || head->next == NULL)return NULL;
		
	int n = 1;
	ListNode* p = head;
	while (p->next != NULL)
	{
		n += 1;
		p = p->next;
	}
	int  mov = n - k%n;
	while (mov--)
	{
		p = p->next;
	}
	head = p->next;
	p->next = NULL;
	return head;
}

//分割链表
ListNode*  Praition(LinkList head, int k)
{
	if (head == NULL || head->next == NULL)
		return NULL;
	ListNode* pre = (ListNode*)malloc(sizeof(ListNode));
	ListNode* newhead = (ListNode*)malloc(sizeof(ListNode));
	pre->next = head;
	head = pre;
	newhead->next = NULL;
	ListNode* p = pre->next;
	ListNode* s = newhead;
	while (p != NULL)
	{
		if (p->data>= k)
		{
			pre->next = p->next;
			p->next = NULL;
			s->next = p;
			s = s->next;
			p =pre->next;

		}
		else
		{
			p = p->next;
			pre = pre->next;

		}

	}
	pre->next = newhead->next;
	pre = head;
	head = head->next;
	free(pre);
	pre = NULL;
	free(newhead); 
	newhead = NULL;
	return head;
}

//单链表快排
ListNode*  ListPraition(ListNode* begin,ListNode*end)
{
	if (begin== end || begin->next ==end)
	{
		return begin ;
	}
	ListNode* slow =begin;
	ListNode* fast = begin->next;
	int tmp = begin->data;
	while(fast != end)
	{
		if (fast->data <= tmp)
		{
			slow = slow->next;
			Swap(&slow->data, &fast->data);
		}
		fast = fast->next;
		
	}
	Swap(&slow->data, &begin->data);
	return slow; 

}
void QuickPass(ListNode* begin, ListNode* end)
{
	if (begin == end || begin->next == end)return;
	ListNode* pmid = ListPraition(begin, end);
	QuickPass(begin, pmid);  
	QuickPass(pmid->next, end);
}

//判断回文链表
//暴力法
bool IsPail(LinkList head)
{
	int res = false;
	if (head == NULL || head->next == NULL)
	{
		return !res;
	}
	int n = 1;
	ListNode* p = head;
	while (p->next != NULL)
	{
		n++;
		p = p->next;
	}
	int* data = (int*)malloc(sizeof(int) * n);
	int i = 0;
	p = head;
	while (p!=NULL)
	{

		data[i] = p->data;
		i++;
		p = p->next;
	}
	int left = 0, right = n - 1;
	while (left < right)
	{
		if (data[left] != data[right])
		{
			return !res;
		}
		left++;
		right--;

	}
	return !res;
	free(data);
	data = NULL;
	return res;

}
//双指针  逆置
bool IsPail_a(LinkList head)
{
	int res = false;
	if (head == NULL || head->next == NULL)
	{
		return !res;
	}
	ListNode* slow = head;
	ListNode* fast = head;
	while (fast->next != NULL && fast->next->next != NULL)
	{
		slow = slow->next;
		fast = fast->next->next;
	}
	ListNode* p = slow->next;
	slow->next = NULL;
	while (p != NULL)
	{
		ListNode* s = p;
		p = p->next;
		s->next = slow->next;
		slow->next = s;
	}
	ListNode* right = slow->next;
	ListNode* pre = head;
	while (right != NULL)
	{
		if (right->data != pre->data)
		{
			break;
		}
		pre = pre->next;
		right = right->next;
	}
	p = slow->next;
	slow->next = NULL;
	while (p != NULL)
	{
		ListNode* s = p;
		p = p->next;
		s->next = slow->next;
		slow->next = s;
	}
	return !res;
}

//插入排序
//插入排序
ListNode* InsertPass(LinkList head)
{
	if (head == NULL || head->next == NULL)
	{
		return head;
	}
	ListNode* sort_head = head;
	ListNode* sort_tail= head;
	ListNode* ip = head->next;
	ListNode* next = NULL;
	while (ip != NULL)
	{
		next = ip->next;
		if (ip->data <= sort_head->data)
		{
			ip->next = sort_tail;
			sort_head = ip;
		}
		else if (ip->data >= sort_head->data)
		{
			sort_tail->next = ip;
			sort_tail= ip;
		}
		else
		{
			ListNode* p = sort_head;
			while (p != sort_tail)
			{
				if (ip->data >= p->data && ip->data < p->next->data)
				{

				}
				p = p->next;
			}
		}
		ip = next;	
	}
	sort_tail->next = NULL;
	return sort_head;
}

//合并两个有序单链表
ListNode* MergeList(LinkList headA, LinkList headB)
{
	ListNode* pa = headA;
	ListNode* pb = headB;
	ListNode* headC =(ListNode*)malloc(sizeof(ListNode));
	ListNode* pc = headC;
	while(pa!=NULL&&pb!=NULL)
	{
		if (pa->data <= pb->data)
		{
			pc->next = pa;
			pa = pa->next;
		}
		else
		{
			pc->next = pb;
			pb = pb->next;
		}
		pc = pc->next;
		
	}
	if (pa != NULL)pc->next = pa;
	if (pb != NULL)pc->next = pb;
	pc = headC;
	headC = pc->next;
	free(pc);
    return headC->next;
}

//链表求和
ListNode* AddListNum(LinkList headA, LinkList headB)
{
	if (headA == NULL && headB == NULL)return NULL;
	ListNode* pa = headA;
	ListNode* pb = headB;
	ListNode* headC = (ListNode*)malloc(sizeof(ListNode));
	ListNode* pc = headC;
	pc->next = NULL;
	int sum = 0,car = 0;
	while (pa != NULL || pb != NULL || car != NULL)
	{
		sum = 0;
		if (pa != NULL) { sum += pa->data; pa = pa->next; }
		if (pb != NULL) { sum += pb->data; pb = pb->next; }
		car = sum / 10;
		sum = sum % 10;
		ListNode* s = (ListNode*)malloc(sizeof(ListNode));
		s->next = NULL;
		s->data = sum;
		pc->next = s;
		pc = pc->next;
	}
	pc = headC;
	headC = headC->next;
	free(pc);
	return headC->next;
}

//删除链表中重复的数据
ListNode* deleteDuplicates(ListNode* head)
{
	if (!head ) return head;
	ListNode* dummy = (ListNode*)malloc(sizeof(ListNode));
	dummy->next=head;

	ListNode* slow = dummy;
	ListNode* fast = head;
	while (fast) {
		while (fast->next && fast->data == fast->next->data) fast = fast->next;
		if (slow->next != fast) slow->next = fast->next;
		else slow = slow->next;
		fast = fast->next;
	}
	ListNode* cur = dummy->next;
	free(dummy);
	return cur;
}
//头插
ListNode* insertionSortList(ListNode* head)
{
	if (head == nullptr)return head;
	ListNode* dummy = Buynode();
	dummy->next = head;

	ListNode* last = head;
	ListNode* curr = head->next;
	while (curr != nullptr)
	{
		if (last->data <= curr->data)  last = last->next;
		else
		{
			ListNode* prev = dummy;
			while (prev->next->data <= curr->data)
				prev = prev->next;

			last->next = curr->next;
			curr->next = prev->next;
			prev->next = curr;
		}
		curr = last->next;
	}
	ListNode* cur = dummy->next;
	free(dummy);
	return cur;
}

//两数相加
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2)
{
	std::stack<int> s1, s2;
	//压栈
	while (l1 != nullptr)
	{
		s1.push(l1->data);
		l1 = l1->next;
	}
	while (l2 != nullptr)
	{
		s2.push(l2->data);
		l2 = l2->next;
	}

	int carry = 0;
	ListNode* ans = nullptr;
	while (!s1.empty() || !s2.empty() ||carry != 0)
	{
		int a = s1.empty() ? 0 : s1.top();
		int b = s2.empty() ? 0 : s2.top();
		if (!s1.empty()) s1.pop();
		if (!s2.empty()) s2.pop();
		int cur = a + b + carry;
		carry = cur / 10;
		cur %= 10;
		//将cur链接到
		
		ListNode* curnode = new ListNode();
		curnode->data = cur;
		curnode->next = ans;
		ans = curnode;
		
	}
	
	return ans;
}

测试代码

#include"LinkList.h"
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//测试两数相加
#if 1
int main()
{
	int ar[] = { 7,2,4,3 };
	int n = sizeof(ar) / sizeof(ar[0]);
	LinkList head = InitList();
	for (int i = 0; i < n; ++i)
	{
		Push_Back(head, ar[i]);
	}
	PrintList(head);
	int ar1[] = {5,6,4};
	int n1 = sizeof(ar1) / sizeof(ar1[0]);
	LinkList head1 = InitList();
	for (int i = 0; i < n1; ++i)
	{
		Push_Back(head1, ar1[i]);
	}
	PrintList(head1);
	LinkList ans=addTwoNumbers(head, head1);
	PrintList(ans);
	DestroyList(head);
	DestroyList(head1);
	return 0;
}
#endif 
//测试删除 函数Remove_all
#if 0
int main()
{
	int ar[] = { 4,2,1,3};
	int n = sizeof(ar) / sizeof(ar[0]);
	LinkList head = InitList();
	for (int i = 0; i < n; ++i)
	{
		Push_Back(head, ar[i]);
	}
	PrintList(head);
	insertionSortList(head);
	PrintList(head);
	DestroyList(head);
	return 0;
}
#endif 


//测试插入排序
#if 0
int main()
{

	LinkList head = InitList();
	head = InsertPass(head);
	return 0;
	DestroyList(head);

}
#endif

//测试快排
#if 0
int main()
{

	LinkList head = InitList();
	for (int i = 0; i < 10; ++i)
	{
		Push_Back(head, rand() % 100);

	}
	PrintList(head);
	QuickPass(head->next, NULL);
	PrintList(head);
	return 0;
	DestroyList(head);

}
#endif

//测试划分链表
#if 0
int main()
{

	LinkList head = InitList();
	for (int i = 0; i < 10; ++i)
	{
		Push_Back(head, rand() % 100);

	}
	PrintList(head);
	head->next = Praition(head->next, 62);
	PrintList(head);
	return 0;
	DestroyList(head);

}
#endif


//不带头结点的逆置链表
#if 0
int main()
{

	LinkList head = InitList();
	for (int i = 0; i < 10; ++i)
	{
		Push_Back(head, i + 10);

	}
	PrintList(head);
	ReverseList_d(head);
	PrintList(head);
	return 0;
	DestroyList(head);

}
#endif

//逆置链表（带头结点）
#if 0
int main()
{
	
		LinkList head = InitList();
		for (int i = 0; i < 10; ++i)
		{
			Push_Back(head,i+10);

		}
		PrintList(head);
		ReverseList_d(head);
		PrintList(head);
		return 0;
		DestroyList(head);

}
#endif

//测试删除 函数Remove_all
#if 0
int main()
{
	int ar[] = { 12,23,34,12,12,11,21,12,12,12,12,34,44,12 };
	int n = sizeof(ar) / sizeof(ar[0]);
	LinkList head = InitList();
	for (int i = 0; i < n; ++i)
	{
		Push_Back(head, ar[i]);
	}
	PrintList(head);
	Remove_All(head, 12);
	PrintList(head);
	DestroyList(head);
	return 0;
}
#endif 
//测试删除 函数Remove 
#if 0
int main()
{
	LinkList head = InitList();
	for (int i = 0; i < 10; ++i)
	{
		Push_Back(head, rand()%100);

	}
	PrintList(head);
	int val;
	while (scanf_s("%d", &val), val != -1)
	{
		printf("%d\n", Remove(head, val));
		
		PrintList(head);
	}
	return 0;
	DestroyList(head);
}
#endif
//测试 计算个数
#if 0
int main()
{
	LinkList head = InitList();
	for(int i = 0; i < 10; ++i)
	{
		Push_Back(head, i+10);
		
	}
	PrintList(head);
	while (!IsEmpty(head))
	{
		Pop_Front(head);
		PrintList(head);
	}

	return 0;
}
#endif
//测试头插 尾插
#if 0
int main()
{
	LinkList head = InitList();
	for (int i = 1; i <= 10; ++i)
	{
		Push_Back(head, i);
		//Push_Front(head, i);
		PrintList(head);
	}
	InsertPos(head, 12, 12);
	PrintList(head);
	return 0;
}
#endif