单链表基本实现（c++）

    因为找实习，公司工作人员让我实现了一下单链表的基本算法。

    单链表其实是一种比较简单的数据结构，不同于数组，单链表的节点在内存中并不是连续存放的，而是靠节点中的指针来连接起来。所以单链表不如数组那样可以随机存取，但是，在其他方面，比如增加元素，插入元素，删除元素方面，单链表要比数组效率高。

    下面是我实现的代码：

   头文件 linkedlist.h

#ifndef LINKEDLIST_H
#define LINKEDLIST_H

typedef struct Node
{
	int data;
	struct Node *next;
}Node;

class LinkedList
{
private:
	Node *head;
	int length;
public:
	LinkedList();
	~LinkedList();
	void insert(int i, int value);
	void deleteElem(int e);
	void create(int *a, int n);
	bool isEmpty();
	void insertsort();
	void quicksort();
        int getlength();
	void display();
private:
	void quicksort2(Node *head, Node *tail);
	Node * partion(Node *head, Node *tail);
	
//	implement create, insert, remove and sort methods.
};

#endif

   实现文件 linkedlist.cpp

#include<iostream>
#include<assert.h>

using namespace std;

#include"LinkedList.h"

//单链表构造函数
LinkedList::LinkedList()
{
	head = NULL;
	length = 0;
}
//单链表析构函数——回收单链表每个节点的存储空间
LinkedList::~LinkedList()
{
	Node *pNode, *qNode;
	pNode = NULL; qNode = head;

	while(qNode)
	{
		pNode = qNode;
        qNode = qNode->next;
		delete pNode;
	}
   
	head = NULL;
}
// 在第i个节点后面插入数据域为value的节点
//i=0表示在最前面位置插入
void LinkedList::insert(int i, int value)
{
	int j = 1;
	Node *p = head;
	Node *ins;

    if(i < 0 || i > length)
	{
		cout<<"out range! fails to insert!"<<endl;
		return;
	}                                  //超出有效范围，插入失败，返回0

	ins = new Node;
	assert(ins != NULL);
	ins->data = value;

	if(i == 0)                         //i==0,在最前面插入
	{
		ins->next = head;
		head = ins;
		length++;
	}
	else                              //i!=0,在第i个元素后面进行插入
	{
		while(p && j < i)             //遍历到第i个元素，在其后进行插入
		{
			j++;
			p = p->next;
		}
		ins->next = p->next;
		p->next = ins;
		length++;
	}

}

bool LinkedList::isEmpty()
{
	if(head == NULL)
		return true;
	else
		return false;
}
void LinkedList::deleteElem(int e)
{
	Node *p = head;
	Node *pre = NULL;
	while(p && p->data != e)
	{
		pre=p;
		p = p->next;
	}

	if(p == NULL)
	{ 
		cout<<"no such node whose value equals e"<<endl;
    	return;
	}

	if(pre == NULL)
	{
		head = head ->next;
		length--;
	}
	else
	{
		pre->next = p->next;
		length--;
	}

	free(p);
	
	return;
}

int LinkedList::getlength()
{
	return length;
}
void LinkedList::quicksort2(Node *head, Node *tail)
{
	if(head != tail)
	{
		Node *mid = partion(head, tail);
	//	display();
		quicksort2(head, mid);
		quicksort2(mid->next, tail);
	}
}
void LinkedList::quicksort()
{
	Node *tail = head;

	while(tail)
		tail = tail->next;
	quicksort2(head,tail);
}
Node * LinkedList::partion(Node *head, Node *tail)
{
	Node *p, *mid;
	int key, temp;

	mid = head;
	p = mid->next;
	key =head->data;

	while(p != tail)
		{
			if(p->data <= key)
			{
				mid = mid->next;
                // 交换数据域，p->data 《——》 mid->data
				temp = p->data;
				p->data = mid->data;
				mid->data = temp;				
			}
			p = p->next;
		}
		
	temp = mid->data;
	mid->data = head->data;
	head->data = temp;

    return mid;//返回划分出来的中间点。
}
void LinkedList::insertsort()
{
	Node *p = head;
	Node *q, *r, *prer;


	if(!p || !p->next)
		return;                 //只有一个元素或为空 ，不用排序；直接返回。

	q = p->next;
	while(q)
	{
		if(p->data > q->data)
		{
			r = head;
			prer = NULL;
			while(r->data < q->data)
			{
				prer = r;
				r = r->next;
			}
			if(prer == NULL)
			{
				p->next = q->next;
				q->next = r;
				head = q;
				q = p->next;
			}
			else
			{
				p->next = q->next;
				prer->next = q;
				q->next = r;
				q = p->next;
			}
		}
		else
		{
			p = p->next;
			q = q->next;
		}
	}
}

void LinkedList::create(int a[], int n)
{
	int i = 0;
	Node *p;
	for(i = n-1; i >=0; i--)
	{
		p = new Node;
		assert(p!=NULL);
		p->data = a[i];
		p->next = head;
		head = p;
		length++;
	}
}

void LinkedList::display()
{
	Node *p = head;
	if(isEmpty())
	   cout<<"there is nothing!  It is empty!"<<endl;
	else
	{
     //  cout<<"the list has "<<getlength()<<" members: "<<endl;
		while(p)
		{
			cout<<p->data<<" ";
			p = p->next;
		}
	}
	cout<<endl;
}

   上面链表的排序算法出来插入排序，还实现了单链表的快速排序，快速排序的时间复杂度要比插入的时间复杂度低。

   总的来说，单链表实现起来比较简单，但是能力是在一点一滴的积累中锻炼出来的。