读书笔记：线性表-单向链表

  1 #pragma once
  2 #include<iostream>
  3 using namespace std;
  4 
  5 class LinkListNode
  6 {
  7 public:
  8     // data mumber
  9     int element;
 10     LinkListNode *next;
 11 
 12      
 13     //construcion function
 14     LinkListNode() = default;
 15 
 16     LinkListNode(const int theElement, LinkListNode *next)
 17     {
 18         this->element = theElement;
 19         this->next = next;
 20     }
 21 };
 22 
 23 class LinkList
 24 {
 25     friend void operator << (ostream &os, LinkList &x);
 26 public:
 27     LinkList()
 28     {
 29         ListSize = 0;
 30         head = NULL;
 31     }
 32 
 33     // Function
 34     void insert(int theIndex, const int theElement);
 35     void erase(int theIndex);
 36     void erase(int firstIndex, int lastIndex);
 37     void output(ostream &os) const;
 38 
 39 
 40     int& operator [] (int theIndex);
 41 private:
 42     LinkListNode *head;
 43     int ListSize;
 44 };
 45 
 46 void operator << (ostream &os, LinkList &x) 
 47 {
 48     x.output(os);
 49 }
 50 
 51 void LinkList::output(ostream &os) const 
 52 {
 53     LinkListNode *p = head;
 54     while (p != NULL)  {
 55         os << p->element << ‘ ‘;
 56         p = p->next;
 57     }
 58 }
 59 
 60 // insert Function, you can insert element into List in all place, 
 61 // and if the Index of your input is out of list‘range, the program will making some error information to tell you, and 
 62 // you can change the Index ,so that make it right
 63 void LinkList::insert(int theIndex, const int theElement)
 64 {
 65     char c = ‘y‘;
 66     while (c != ‘n‘)  {
 67         try {
 68             if (0 > theIndex || theIndex > ListSize)
 69                 throw range_error("the Index is out of LinkList‘ range ");
 70             //main of function body
 71             else  {
 72                 if(theIndex == 0)
 73                     head = new LinkListNode(theElement, head);
 74                 else {
 75                     LinkListNode *p = head;
 76                     for (int i = 0; i < theIndex - 1; i++)
 77                         p = p->next;
 78                     p->next = new LinkListNode(theElement, p->next);
 79                 }
 80                 ListSize++;
 81                 c = ‘n‘;
 82             }
 83         }
 84         catch (range_error err)  {
 85             cout << err.what()
 86                 << endl << "input Index again ? \n" << "y or n" << endl;
 87             cin >> c;
 88             if (c == ‘y‘)
 89                 cin >> theIndex;
 90         }
 91     }
 92 }
 93 
 94 // Erase function, use it , you can delete a Node form list, but your Index can‘t out ou the list‘range too, and
 95 // the funciton also has a error imformation unit
 96 void LinkList::erase(int theIndex)
 97 {
 98     LinkListNode * delNode;
 99     try  {
100         if (theIndex < 0 || theIndex >= ListSize)
101             throw range_error("error Index \n[No erase]");
102         else  {
103             if (theIndex == 0) {
104                 delNode = head;
105                 head = head->next;
106             }
107             else {
108                 LinkListNode *p = head;
109                 for (int i = 0; i < theIndex - 1; i++)
110                     p = p->next;
111                 delNode = p->next;
112                 p->next = p->next->next;
113             }
114         }
115         ListSize--;
116         delete delNode;
117     }
118     catch (range_error err) {
119         cout << err.what();
120     }
121 }
122 
123 // This is Erase funciton too, in deffrent to last function, this can delete a range of elements, and it has Error checking too
124 void LinkList::erase(int firstIndex, int lastIndex)
125 {
126     LinkListNode *fNode;
127     LinkListNode *tNode;
128     try {
129         if (firstIndex < 0 || lastIndex >= ListSize)
130             throw range_error("the range of your input is error");
131         else {
132             LinkListNode *p = head;
133             int i;
134             for (i = 0; i < firstIndex - 1; i++)
135                 p = p->next;
136             fNode = p->next;
137             LinkListNode *q = p;
138             for (; i < lastIndex - 1; i++)
139                  p = p->next;
140             tNode = p->next;
141 
142             if (firstIndex == 0)
143                 head = tNode->next;
144             else q->next = tNode->next;
145         }
146         while (fNode != tNode) {
147             LinkListNode *temp = fNode->next;
148             delete fNode;
149             fNode = temp;
150             ListSize--;
151         }
152     } catch(range_error err){
153         cout << err.what();
154     }
155 }
156 
157 // this is a operator, you can input index ,and you will get the element of the list‘index
158 int& LinkList::operator[] (int theIndex)
159 {
160     LinkListNode *p = head;
161     for (int i = 0; i < theIndex; i++)
162         p = p->next;
163     return p->element;
164 }