链表1－单链表

链表也是一种线性表，但与线性表不同的是，链表的物理存储结构是一堆地址任意的存储单元。也就是说，链表的数据在内存中的物理位置可能相互邻接，也有可能不邻接。

单链表的基本操作如下：

  1 //链表的基本操作
  2 //定义结点类
  3 template <typename Type> class Node{
  4 public:
  5     Type data;
  6     Node<Type> *next;
  7     Node(const Type &_data){
  8         data=_data;
  9         next=NULL;
 10     }
 11
 12 //定义链表类
 13 template <typename Type> class LinkedList{
 14 private:
 15     Node<Type> *head;
 16 public:
 17     //构造
 18     LinkedList(){
 19         head=NULL;
 20     }
 21
 22     //析构
 23     ~LinkedList(){
 24         Node<Type> *current_node=head;
 25         while(current_node!=NULL){
 26             Node<Type> *delete_node=current_node;
 27             current_node=current_node->next;
 28             delete delete_node;
 29         }
 30     }
 31
 32     //插入函数,这里插入的是指针，需要在主函数内先开好内存
 33     void insert(Node<Type> *node, int index){
 34         //special case 1: empty list
 35         if(head==NULL){
 36             if(index!=0){
 37                 return;
 38             }
 39             head=node;
 40             return;
 41         }
 42         //special case 2: insert the head
 43         if(index==0){
 44             node->next=head;
 45             head=node;
 46             return;
 47         }
 48         //general case: first find the node before the target position
 49         Node<Type> *current_node=head;
 50         int count=0;
 51         while(current_node->next!=NULL&&count<index-1){
 52             current_node=current_node->next;
 53             count++;
 54         }
 55         //make sure the index is legal, then insert
 56         if(count==index-1){
 57             node->next=current_node->next;
 58             current_node->next=node;
 59         }
 60     }
 61
 62     //遍历函数
 63     void output(){
 64         if(head==NULL){
 65             return;
 66         }
 67         Node<Type> *current_node=head;
 68         while(current_node!=NULL){
 69             cout<<current_node->data<<" ";
 70             current_node=current_node->next;
 71         }
 72         cout<<endl;
 73     }
 74
 75     //删除函数
 76     void delete_node(int index){
 77         if(head==NULL){
 78             return;
 79         }
 80         Node<Type> *current_node=head;
 81         int count=0;
 82         if(index==0){
 83             head=head->next;
 84             delete current_node;
 85             return;
 86         }
 87         //找目标位置的前一位
 88         while(current_node->next!=NULL&&count<index-1){
 89             current_node=current_node->next;
 90             count++;
 91         }
 92         //注意删除位置不能是最后一位的后一位
 93         if(count==index-1&&current_node->next!=NULL){
 94             Node<Type> *delete_node=current_node->next;
 95             current_node->next=delete_node->next;
 96             delete delete_node;
 97         }
 98     }
 99
100
101     //返回给定值节点的地址
102      Node<Type>* find_node(Type value){
103         Node<Type> *current_node=head;
104         while(current_node!=NULL){
105             if(current_node->data==value){
106                 return current_node;
107             }
108             current_node=current_node->next;
109         }
110         return NULL;
111     }
112
113
114     //反转函数
115     void reverse(){
116         if(head==NULL||head->next==NULL){
117             return;
118         }
119         Node<Type> *next_node,*current_node;
120         current_node=head->next;
121         //拆掉头节点
122         head->next=NULL;
123         //把头节点的下一个节点指向头节点，再将其更新为新的头节点
124         while(current_node!=NULL){
125             next_node=current_node->next;
126             current_node->next=head;
127             head=current_node;
128             current_node=next_node;
129         }
130     }
131 };
132
133
134 int main(){
135     LinkedList<int> linkedlist;
136     for(int i=0;i<5;i++){
137         //调用insert函数,i为插入的值,i-1为插入下标
138         Node<int> *node=new Node<int>(i+1);
139         linkedlist.insert(i,node);
140     }