单链表基本实现（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;
}

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

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