• 【数据结构】链表的十三种操作

    菜单 

    1. //0、显示菜单
    2. void menu()
    3. {
    4.     cout << "菜单：" << endl;
    5.     cout << "1.初始化或重置链表" << endl;
    6.     cout << "2.销毁链表" << endl;
    7.     cout << "3.清空链表" << endl;
    8.     cout << "4.链表长度" << endl;
    9.     cout << "5.指定位置的元素值" << endl;
    10.     cout << "6.链表已存在元素的位序" << endl;
    11.     cout << "7.求输入元素的直接前驱" << endl;
    12.     cout << "8.求输入元素的直接后继" << endl;
    13.     cout << "9.在第i个位置插入一个元素" << endl;
    14.     cout << "10.删除第i个元素" << endl;
    15.     cout << "11.输出有的链表元素" << endl;
    16.     cout << "12.初始化并用头插法（或尾插法）输入元素" << endl;
    17.     cout << "13.实现单链表的逆序存放" << endl;
    18.     cout << "-1.退出程序" << endl;
    19. }

    定义结构体 

    1. // 定义结构体
    2. typedef struct DNode
    3. {
    4.     EleType data;
    5.     struct DNode *prior,*next;
    6. }Dnode,*DLinkList;

    1.初始化或重置链表

    1.  
    2. // 1、初始化双向链表
    3. bool Init_linkList(DLinkList& L)
    4. {
    5.     L = (DNode*) malloc(sizeof(DNode));
    6.     if(L == nullptr)
    7.         return false;
    8.     else
    9.     {
    10.         L->prior = nullptr;
    11.         L->next = nullptr;
    12.         return true;
    13.     }
    14. }

    2.销毁链表

    注：销毁链表时需要循环释放每个结点所占用的空间。

    1.  
    2. // 2、销毁链表
    3. void DestroyLink(DNode *L){//为了避免内存泄露，每次创建链表运行完程序应将创建的链表销毁，避免内存泄露
    4.     DNode *temp;
    5.     DNode *pre;
    6.     temp= L->next;
    7.     while(temp != nullptr){
    8.         pre = temp;
    9.         temp = temp->next;
    10.         free(pre);
    11.     }
    12.     free(L);
    13. }

    3.清空链表

    1.  
    2. // 3、清空双链表
    3. bool ClearDLink(DNode* L)
    4. {
    5.     DNode *temp;
    6.     DNode *pre;
    7.     temp= L->next;
    8.     while(temp != nullptr){
    9.         pre = temp;
    10.         temp = temp->next;
    11.         free(pre);
    12.     }
    13.     L->next = nullptr;
    14.     L->prior = nullptr;
    15.     if(L->next == nullptr)
    16.         return true;
    17.     else
    18.         return false;
    19. }

    4.链表长度

    1.  
    2. // 4、求双链表长度
    3. int LengthLink(Dnode*L)
    4. {
    5.     int cnt = 0;
    6.     DNode *temp;
    7.     temp= L->next;
    8.     while(temp != nullptr){
    9.         temp = temp->next;
    10.         cnt ++;
    11.     }
    12.     return cnt;
    13. }

    5.指定位置的元素值

    1.  
    2. // 5、指定位置元素
    3. int elem_check(Dnode*L,int address)// 判断这个位置是否合法
    4. {
    5.     int cnt = LengthLink(L);
    6.     if(address <= 0 || address > cnt) return false;
    7.     return true;
    8. }
    9.  
    10. EleType ElemLink(Dnode *L,int address)// 如果这个位置合法，则进行查找
    11. {
    12.     int cnt = 0;
    13.     EleType flag;
    14.     DNode *temp;
    15.     DNode *pre;
    16.     temp= L->next;
    17.     while(temp != nullptr){
    18.         pre = temp;
    19.         temp = temp->next;
    20.         if(++ cnt == address) flag = pre->data;
    21.     }
    22.     return flag;
    23. }

    6.链表已存在元素的位序

    1.  
    2. // 6.链表已存在元素的位序
    3.  
    4. bool judge_address(Dnode *L,EleType elem)
    5. {
    6.     DNode *temp;
    7.     temp= L->next;
    8.     while(temp != nullptr){
    9.         if(temp->data == elem) return true;
    10.         temp = temp->next;
    11.     }
    12.     return false;
    13. }
    14.  
    15. int AddressLink(Dnode *L,EleType elem)
    16. {
    17.     int address = 0;
    18.     int cnt = 0;
    19.     DNode *temp;
    20.     temp= L->next;
    21.     while(temp != nullptr){
    22.         cnt ++;
    23.         if(temp->data == elem) address = cnt;
    24.         temp = temp->next;
    25.     }
    26.     return address;
    27. }

    7.求输入元素的直接前驱

    1.  
    2. // 7.求输入元素的直接前驱
    3.  
    4. bool judge_before(Dnode *L,EleType elem)
    5. {
    6.     DNode *temp;
    7.     temp= L->next;
    8.     while(temp != nullptr){
    9.         if(temp->data == elem)
    10.         {
    11.             if(temp->prior == L) return false;
    12.             else return true;
    13.         }
    14.         temp = temp->next;
    15.     }
    16.     return false;
    17. }
    18.  
    19. EleType BeforeLink(Dnode *L,EleType elem)
    20. {
    21.     EleType flag;
    22.     DNode *temp;
    23.     temp= L->next;
    24.     while(temp != nullptr){
    25.         if(temp->data == elem)
    26.         {
    27.             flag = temp->prior->data;
    28.         }
    29.         temp = temp->next;
    30.     }
    31.     return flag;
    32. }

    求前驱是指，输入一个元素值（而不是位置），求该元素在顺序表中的直接前驱元素值。

    8.求输入元素的直接后继

    1.  
    2. // 8.求输入元素的直接后继
    3. bool judge_after(Dnode *L,EleType elem)
    4. {
    5.     DNode *temp;
    6.     temp= L->next;
    7.     while(temp != nullptr){
    8.         if(temp->data == elem)
    9.         {
    10.             if(temp->next == nullptr) return false;
    11.             else return true;
    12.         }
    13.         temp = temp->next;
    14.     }
    15.     return false;
    16. }
    17.  
    18. EleType AfterLink(Dnode *L,EleType elem)
    19. {
    20.     EleType flag;
    21.     DNode *temp;
    22.     temp= L->next;
    23.     while(true){
    24.         if(temp->data == elem)
    25.         {
    26.             flag = temp->next->data;
    27.             break;
    28.         }
    29.         temp = temp->next;
    30.     }
    31.     return flag;
    32. }

    求后继是指：输入一个元素值（而不是位置），求该元素在顺序表中的直接后继元素值。

    9.在第i个位置插入一个元素

    1.  
    2. // 9.在第i个位置插入一个元素
    3.  
    4. void LinkListInit(Dnode* L,int address,EleType elem)
    5. {
    6.     Dnode* l;
    7.     l = (DNode*) malloc(sizeof(DNode));
    8.     l->data = elem;
    9.     int cnt = 0;
    10.     DNode *temp;
    11.     temp= L->next;
    12.     int len = LengthLink(L);
    13.     if(address == len + 1)
    14.     {
    15.         temp = L;
    16.         while(true)
    17.         {
    18.             if(temp->next == nullptr)
    19.             {
    20.                 l->next = nullptr;
    21.                 l->prior = temp;
    22.                 temp->next = l;
    23.                 return;
    24.             }
    25.             temp = temp->next;
    26.         }
    27.     }
    28.     else
    29.     {
    30.         while(temp != nullptr){
    31.             cnt ++;
    32.             if(cnt == address)
    33.             {
    34.                 l->next = temp;
    35.                 l->prior = temp->prior;
    36.                 temp->prior->next = l;
    37.                 temp->prior = l;
    38.                 return;
    39.             }
    40.             temp = temp->next;
    41.         }
    42.     }
    43. }

    10.删除第i个元素

    1.  
    2. // 10.删除第i个元素
    3. void drop(Dnode* L,int address)
    4. {
    5.     int cnt = 0;
    6.     DNode *temp;
    7.     temp= L->next;
    8.     int len = LengthLink(L);
    9.     if(len == address)
    10.     {
    11.         while(true)
    12.         {
    13.             if(temp->next == nullptr)
    14.             {
    15.                 temp->prior->next = nullptr;
    16.                 free(temp);
    17.                 return;
    18.             }
    19.             temp = temp->next;
    20.         }
    21.     }
    22.     while(temp != nullptr){
    23.         cnt ++;
    24.         if(cnt == address)
    25.         {
    26.             temp->prior->next = temp->next;
    27.             temp->next->prior = temp->prior;
    28.             free(temp);
    29.             return;
    30.         }
    31.         temp = temp->next;
    32.     }
    33. }

    11.输出有的链表元素

    1.  
    2. // 11.输出有的链表元素
    3. void show(Dnode* L)
    4. {
    5.     DNode *temp;
    6.     temp= L->next;
    7.     while(temp != nullptr){
    8.         cout << temp->data << "  ";
    9.         temp = temp->next;
    10.     }
    11.     cout << endl;
    12. }

    12.清空链表并用头插法（或尾插法）输入元素

    1.  
    2. // 12.清空并用头插法（或尾插法）输入元素
    3. void show12(Dnode* L,int sum)
    4. {
    5.     ClearDLink(L);
    6.     for(int i = 0; i < sum; i ++)
    7.     {
    8.         Dnode* l;
    9.         l = (DNode*) malloc(sizeof(DNode));
    10.         EleType num;
    11.         cin >> num;
    12.         l->data = num;
    13.         l->next = L->next;
    14.         l->prior = L;
    15.         if(L->next != nullptr)
    16.         {
    17.             L->next->prior = l;
    18.         }
    19.         L->next = l;
    20.     }
    21.     show(L);
    22. }

    13.实现单链表的逆序存放

    1.  
    2. void show13(Dnode* L)
    3. {
    4.     queue q;
    5.     DNode *temp;
    6.     DNode *p;
    7.     temp= L->next;
    8.     while(temp != nullptr){
    9.         q.push(temp->data);
    10.         p = temp;
    11.         temp = temp->next;
    12.         free(p);
    13.     }
    14.     L->next = nullptr;
    15.     L->prior = nullptr;
    16.     while(!q.empty())
    17.     {
    18.         EleType s;
    19.         s = q.front();
    20.         q.pop();
    21.         DNode* l;
    22.         l = (Dnode*) malloc(sizeof(DNode));
    23.         l->data = s;
    24.         l->next = L->next;
    25.         l->prior = L;
    26.         if(L->next != nullptr)
    27.         {
    28.             L->next->prior = l;
    29.         }
    30.         L->next = l;
    31.     }
    32. }

    要求：所有的提示语和输出语句不允许出现在自定义的函数中(输出函数除外)，只能在main函数中出现提示语。

    注意，每个功能模块一定要考虑非法的情况，并作出相应的提示，例如：求前驱，要分别能够测试第一个元素的前驱、其他正常的元素的前驱、输入一个在表中不存在的元素求其前驱，这三种情况应给出相应的提示语和结果值；插入和删除时要考虑插入或删除的位置是否合法等。

    代码 

    1. #include
    2. using namespace std;
    3. typedef int EleType;
    4.  
    5. // 定义结构体
    6. typedef struct DNode
    7. {
    8.     EleType data;
    9.     struct DNode *prior,*next;
    10. }Dnode,*DLinkList;
    11.  
    12. //0、显示菜单
    13. void menu()
    14. {
    15.     cout << "菜单：" << endl;
    16.     cout << "1.初始化或重置链表" << endl;
    17.     cout << "2.销毁链表" << endl;
    18.     cout << "3.清空链表" << endl;
    19.     cout << "4.链表长度" << endl;
    20.     cout << "5.指定位置的元素值" << endl;
    21.     cout << "6.链表已存在元素的位序" << endl;
    22.     cout << "7.求输入元素的直接前驱" << endl;
    23.     cout << "8.求输入元素的直接后继" << endl;
    24.     cout << "9.在第i个位置插入一个元素" << endl;
    25.     cout << "10.删除第i个元素" << endl;
    26.     cout << "11.输出有的链表元素" << endl;
    27.     cout << "12.初始化并用头插法（或尾插法）输入元素" << endl;
    28.     cout << "13.实现单链表的逆序存放" << endl;
    29.     cout << "-1.退出程序" << endl;
    30. }
    31.  
    32. // 1、初始化双向链表
    33. bool Init_linkList(DLinkList& L)
    34. {
    35.     L = (DNode*) malloc(sizeof(DNode));
    36.     if(L == nullptr)
    37.         return false;
    38.     else
    39.     {
    40.         L->prior = nullptr;
    41.         L->next = nullptr;
    42.         return true;
    43.     }
    44. }
    45.  
    46. // 2、销毁链表
    47. void DestroyLink(DNode *L){//为了避免内存泄露，每次创建链表运行完程序应将创建的链表销毁，避免内存泄露
    48.     DNode *temp;
    49.     DNode *pre;
    50.     temp= L->next;
    51.     while(temp != nullptr){
    52.         pre = temp;
    53.         temp = temp->next;
    54.         free(pre);
    55.     }
    56.     free(L);
    57. }
    58.  
    59.  
    60. // 3、清空双链表
    61. bool ClearDLink(DNode* L)
    62. {
    63.     DNode *temp;
    64.     DNode *pre;
    65.     temp= L->next;
    66.     while(temp != nullptr){
    67.         pre = temp;
    68.         temp = temp->next;
    69.         free(pre);
    70.     }
    71.     L->next = nullptr;
    72.     L->prior = nullptr;
    73.     if(L->next == nullptr)
    74.         return true;
    75.     else
    76.         return false;
    77. }
    78.  
    79. // 4、求双链表长度
    80. int LengthLink(Dnode*L)
    81. {
    82.     int cnt = 0;
    83.     DNode *temp;
    84.     temp= L->next;
    85.     while(temp != nullptr){
    86.         temp = temp->next;
    87.         cnt ++;
    88.     }
    89.     return cnt;
    90. }
    91.  
    92. // 5、指定位置元素
    93. int elem_check(Dnode*L,int address)
    94. {
    95.     int cnt = LengthLink(L);
    96.     if(address <= 0 || address > cnt) return false;
    97.     return true;
    98. }
    99. EleType ElemLink(Dnode *L,int address)
    100. {
    101.     int cnt = 0;
    102.     EleType flag;
    103.     DNode *temp;
    104.     DNode *pre;
    105.     temp= L->next;
    106.     while(temp != nullptr){
    107.         pre = temp;
    108.         temp = temp->next;
    109.         if(++ cnt == address) flag = pre->data;
    110.     }
    111.     return flag;
    112. }
    113.  
    114. // 6.链表已存在元素的位序
    115.  
    116. bool judge_address(Dnode *L,EleType elem)
    117. {
    118.     DNode *temp;
    119.     temp= L->next;
    120.     while(temp != nullptr){
    121.         if(temp->data == elem) return true;
    122.         temp = temp->next;
    123.     }
    124.     return false;
    125. }
    126.  
    127. int AddressLink(Dnode *L,EleType elem)
    128. {
    129.     int address = 0;
    130.     int cnt = 0;
    131.     DNode *temp;
    132.     temp= L->next;
    133.     while(temp != nullptr){
    134.         cnt ++;
    135.         if(temp->data == elem) address = cnt;
    136.         temp = temp->next;
    137.     }
    138.     return address;
    139. }
    140.  
    141. // 7.求输入元素的直接前驱
    142.  
    143. bool judge_before(Dnode *L,EleType elem)
    144. {
    145.     DNode *temp;
    146.     temp= L->next;
    147.     while(temp != nullptr){
    148.         if(temp->data == elem)
    149.         {
    150.             if(temp->prior == L) return false;
    151.             else return true;
    152.         }
    153.         temp = temp->next;
    154.     }
    155.     return false;
    156. }
    157.  
    158. EleType BeforeLink(Dnode *L,EleType elem)
    159. {
    160.     EleType flag;
    161.     DNode *temp;
    162.     temp= L->next;
    163.     while(temp != nullptr){
    164.         if(temp->data == elem)
    165.         {
    166.             flag = temp->prior->data;
    167.         }
    168.         temp = temp->next;
    169.     }
    170.     return flag;
    171. }
    172.  
    173. // 8.求输入元素的直接后继
    174. bool judge_after(Dnode *L,EleType elem)
    175. {
    176.     DNode *temp;
    177.     temp= L->next;
    178.     while(temp != nullptr){
    179.         if(temp->data == elem)
    180.         {
    181.             if(temp->next == nullptr) return false;
    182.             else return true;
    183.         }
    184.         temp = temp->next;
    185.     }
    186.     return false;
    187. }
    188.  
    189. EleType AfterLink(Dnode *L,EleType elem)
    190. {
    191.     EleType flag;
    192.     DNode *temp;
    193.     temp= L->next;
    194.     while(true){
    195.         if(temp->data == elem)
    196.         {
    197.             flag = temp->next->data;
    198.             break;
    199.         }
    200.         temp = temp->next;
    201.     }
    202.     return flag;
    203. }
    204.  
    205.  
    206. // 9.在第i个位置插入一个元素
    207.  
    208. void LinkListInit(Dnode* L,int address,EleType elem)
    209. {
    210.     Dnode* l;
    211.     l = (DNode*) malloc(sizeof(DNode));
    212.     l->data = elem;
    213.     int cnt = 0;
    214.     DNode *temp;
    215.     temp= L->next;
    216.     int len = LengthLink(L);
    217.     if(address == len + 1)
    218.     {
    219.         temp = L;
    220.         while(true)
    221.         {
    222.             if(temp->next == nullptr)
    223.             {
    224.                 l->next = nullptr;
    225.                 l->prior = temp;
    226.                 temp->next = l;
    227.                 return;
    228.             }
    229.             temp = temp->next;
    230.         }
    231.     }
    232.     else
    233.     {
    234.         while(temp != nullptr){
    235.             cnt ++;
    236.             if(cnt == address)
    237.             {
    238.                 l->next = temp;
    239.                 l->prior = temp->prior;
    240.                 temp->prior->next = l;
    241.                 temp->prior = l;
    242.                 return;
    243.             }
    244.             temp = temp->next;
    245.         }
    246.     }
    247. }
    248.  
    249. // 10.删除第i个元素
    250. void drop(Dnode* L,int address)
    251. {
    252.     int cnt = 0;
    253.     DNode *temp;
    254.     temp= L->next;
    255.     int len = LengthLink(L);
    256.     if(len == address)
    257.     {
    258.         while(true)
    259.         {
    260.             if(temp->next == nullptr)
    261.             {
    262.                 temp->prior->next = nullptr;
    263.                 free(temp);
    264.                 return;
    265.             }
    266.             temp = temp->next;
    267.         }
    268.     }
    269.     while(temp != nullptr){
    270.         cnt ++;
    271.         if(cnt == address)
    272.         {
    273.             temp->prior->next = temp->next;
    274.             temp->next->prior = temp->prior;
    275.             free(temp);
    276.             return;
    277.         }
    278.         temp = temp->next;
    279.     }
    280. }
    281.  
    282. // 11.输出有的链表元素
    283. void show(Dnode* L)
    284. {
    285.     DNode *temp;
    286.     temp= L->next;
    287.     while(temp != nullptr){
    288.         cout << temp->data << "  ";
    289.         temp = temp->next;
    290.     }
    291.     cout << endl;
    292. }
    293.  
    294. // 12.初始化并用头插法（或尾插法）输入元素
    295. void show12(Dnode* L,int sum)
    296. {
    297.     ClearDLink(L);
    298.     for(int i = 0; i < sum; i ++)
    299.     {
    300.         Dnode* l;
    301.         l = (DNode*) malloc(sizeof(DNode));
    302.         EleType num;
    303.         cin >> num;
    304.         l->data = num;
    305.         l->next = L->next;
    306.         l->prior = L;
    307.         if(L->next != nullptr)
    308.         {
    309.             L->next->prior = l;
    310.         }
    311.         L->next = l;
    312.     }
    313.     show(L);
    314. }
    315.  
    316. void show13(Dnode* L)
    317. {
    318.     queue q;
    319.     DNode *temp;
    320.     DNode *p;
    321.     temp= L->next;
    322.     while(temp != nullptr){
    323.         q.push(temp->data);
    324.         p = temp;
    325.         temp = temp->next;
    326.         free(p);
    327.     }
    328.     L->next = nullptr;
    329.     L->prior = nullptr;
    330.     while(!q.empty())
    331.     {
    332.         EleType s;
    333.         s = q.front();
    334.         q.pop();
    335.         DNode* l;
    336.         l = (Dnode*) malloc(sizeof(DNode));
    337.         l->data = s;
    338.         l->next = L->next;
    339.         l->prior = L;
    340.         if(L->next != nullptr)
    341.         {
    342.             L->next->prior = l;
    343.         }
    344.         L->next = l;
    345.     }
    346. }
    347.  
    348.  
    349. int main()
    350. {
    351.     DLinkList L;
    352.     int op = -1;
    353.     bool flag = false;
    354.     menu();
    355.     while(op != 0)
    356.     {
    357.         cout << "<------------------------------>" << endl << "请输入你的选择：";
    358.         cin >> op;
    359.         if(op == 1)
    360.         {
    361.             // 1.初始化或重置链表
    362.             if(Init_linkList(L))
    363.             {
    364.                 cout << "初始化成功！" << endl;
    365.                 flag = true;
    366.             }
    367.             else cout << "初始化失败！" << endl;
    368.         }else if(op == 2)
    369.         {
    370.             if(!flag)
    371.             {
    372.                 cout << "链表已被销毁" << endl;
    373.                 continue;
    374.             }
    375.             // 2.销毁链表
    376.             DestroyLink(L);
    377.             flag = false;
    378.             cout << "成功销毁链表！" << endl;
    379.         }else if(op == 3)
    380.         {
    381.             // 3.清空链表
    382.             if(!flag)
    383.             {
    384.                 cout << "链表已被销毁" << endl;
    385.                 continue;
    386.             }
    387.             if(ClearDLink(L))
    388.                 cout << "清空链表成功！" << endl;
    389.             else
    390.                 cout << "清空链表失败！" << endl;
    391.         }else if(op == 4)
    392.         {
    393.             // 4.链表长度
    394.             if(!flag)
    395.             {
    396.                 cout << "链表已被销毁" << endl;
    397.                 continue;
    398.             }
    399.             int l = LengthLink(L);
    400.             cout << "链表长度为：" << l << endl;
    401.         }else if(op == 5)
    402.         {
    403.             // 5.指定位置的元素值
    404.             if(!flag)
    405.             {
    406.                 cout << "链表已被销毁" << endl;
    407.                 continue;
    408.             }
    409.             int address;
    410.             cout << "请输入位置：";
    411.             cin >> address;
    412.             if(elem_check(L,address))
    413.             {
    414.                 EleType ans = ElemLink(L,address);
    415.                 cout << "第" << address << "位置的元素为：" << ans << endl;
    416.             }
    417.             else
    418.             {
    419.                 cout << "这个位置没有元素！" << endl;
    420.             }
    421.         }else if(op == 6)
    422.         {
    423.             // 6.链表已存在元素的位序
    424.             if(!flag)
    425.             {
    426.                 cout << "链表已被销毁" << endl;
    427.                 continue;
    428.             }
    429.             EleType elem;
    430.             cout << "请输入查找的元素：";
    431.             cin >> elem;
    432.             if(judge_address(L,elem))
    433.             {
    434.                 int address = AddressLink(L,elem);
    435.                 cout << "值" << elem << "的位置在" << address << endl;
    436.             }
    437.             else
    438.             {
    439.                 cout << "链表中不存在这个值！" << endl;
    440.             }
    441.         }else if(op == 7)
    442.         {
    443.             // 7.求输入元素的直接前驱
    444.             if(!flag)
    445.             {
    446.                 cout << "链表已被销毁" << endl;
    447.                 continue;
    448.             }
    449.             EleType elem;
    450.             cout << "请输入查找的元素：";
    451.             cin >> elem;
    452.             if(judge_before(L,elem))
    453.             {
    454.                 EleType ans;
    455.                 ans = BeforeLink(L,elem);
    456.                 cout << "元素" << elem << "的直接前驱为：" << ans << endl;
    457.             }
    458.             else
    459.             {
    460.                 cout << "这个值没有直接前驱！" << endl;
    461.             }
    462.         }else if(op == 8)
    463.         {
    464.             // 8.求输入元素的直接后继
    465.             if(!flag)
    466.             {
    467.                 cout << "链表已被销毁" << endl;
    468.                 continue;
    469.             }
    470.             EleType elem;
    471.             cout << "请输入查找的元素：";
    472.             cin >> elem;
    473.             if(judge_after(L,elem))
    474.             {
    475.                 EleType ans;
    476.                 ans = AfterLink(L,elem);
    477.                 cout << "元素" << elem << "的直接后继为：" << ans << endl;
    478.             }
    479.             else
    480.             {
    481.                 cout << "这个值没有直接后继！" << endl;
    482.             }
    483.         }
    484.         else if(op == 9)
    485.         {
    486.             // 9.在第i个位置插入一个元素
    487.             if(!flag)
    488.             {
    489.                 cout << "链表已被销毁" << endl;
    490.                 continue;
    491.             }
    492.             int len;
    493.             len = LengthLink(L);
    494.             int address;
    495.             cout << "输入插入位置：";
    496.             cin >> address;
    497.             EleType elem;
    498.             cout << "输入插入元素：";
    499.             cin >> elem;
    500.             if(address < 1 || address > len + 1)
    501.             {
    502.                 cout << "这个位置不能插入元素" << endl;
    503.             }
    504.             else
    505.             {
    506.                 LinkListInit(L,address,elem);
    507.                 cout << "插入成功！" << endl;
    508.             }
    509.         }
    510.         else if(op == 10)
    511.         {
    512.             // 10.删除第i个元素
    513.             if(!flag)
    514.             {
    515.                 cout << "链表已被销毁" << endl;
    516.                 continue;
    517.             }
    518.             int address;
    519.             cout << "请输入元素位置：";
    520.             cin >> address;
    521.             int len = LengthLink(L);
    522.             if(address < 1 || address > len)
    523.             {
    524.                 cout << "这个位置不能删除"<< endl;
    525.                 continue;
    526.             }
    527.             drop(L,address);
    528.             cout << "删除成功！" << endl;
    529.         }
    530.         else if(op == 11)
    531.         {
    532.             // 11.输出有的链表元素
    533.             if(!flag)
    534.             {
    535.                 cout << "链表已被销毁" << endl;
    536.                 continue;
    537.             }
    538.             show(L);
    539.         }
    540.         else if(op == 12)
    541.         {
    542.             // 12.初始化并用头插法（或尾插法）输入元素
    543.             if(!flag)
    544.             {
    545.                 cout << "链表已被销毁" << endl;
    546.                 continue;
    547.             }
    548.             cout << "初始化并用头插法（或尾插法）输入元素" << endl;
    549.             cout << "请输入插入元素个数：";
    550.             int sum;
    551.             cin >> sum;
    552.             show12(L,sum);
    553.         }
    554.         else if(op == 13)
    555.         {
    556.             // 13.实现单链表的逆序存放
    557.             if(!flag)
    558.             {
    559.                 cout << "链表已被销毁" << endl;
    560.                 continue;
    561.             }
    562.             show13(L);
    563.         }
    564.         else if(op == -1) break;
    565.     }
    566.     cout << "程序结束！" << endl;
    567. }
    568.

  • 相关阅读:
    C++ day4
    服务端没有 listen，客户端发起连接建立，会发生什么？
    配置 4G 模块为WAN口上网
    qt调用python脚本中的函数
    处理尚不存在的 DOM 节点
    JavaScript-前端环境搭建-nodejs-打包分发-Webstorm-vue安装创建
    论文解析-moETM-多组学整合模型
    Java native 关键字
    【Java】泛型 之 泛型和反射
    03 【资源处理】
  • 原文地址：https://blog.csdn.net/littlegengjie/article/details/134039810