#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <iterator>
#include <initializer_list>
#include <deque>
#include <list>
#include <array>
#include <forward_list>
#include <sstream>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <memory>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <type_traits>
#include <utility>
#include <tuple>
#include <bitset>
#include <regex>
#include <random>
#include <iomanip>
#include <ctime>
#include <cmath>
using namespace::std;
using ElementType = int;
#define ERROR -1
struct LNode;
typedef LNode* PtrToLNode;
typedef PtrToLNode Position;
typedef PtrToLNode List;
struct LNode
{
ElementType Data;
PtrToLNode Next;
};
int Length(List L)
{
Position p;
int cnt = 0;
p = L;
while (p)
{
p = p->Next;
++cnt;
}
return cnt;
}
ElementType FindKth(List L, int k)
{
Position p;
p = L;
int cnt = 1;
while (p&&cnt < k)
{
p = p->Next;
++cnt;
}
if ((cnt == k) && p)
return p->Data;
else
return ERROR;
}
Position Find(List L, ElementType aim)
{
Position p;
p = L;
while (p)
{
if (aim == p->Data)
return p;
p = p->Next;
}
return nullptr;
}
List Insert(List L, ElementType X, int i)
{
Position tmp, pre;
tmp = (Position)malloc(sizeof(LNode));
tmp->Data = X;
if (i == 1)
{
tmp->Next = L;
return tmp;
}
else
{
int cnt = 1;
pre = L;
while (pre&&cnt < i - 1)
{
pre = pre->Next;
++cnt;
}
if (pre == nullptr || cnt != i - 1)
{
cout << "invalid input i" << endl;
return nullptr;
}
else
{
tmp->Next = pre->Next;
pre->Next = tmp;
return L;
}
}
}
List Insert2(List L, ElementType X, int i)
{
Position pre, tmp;
int cnt = 0;
pre = L;
while (pre&&cnt < i - 1)
{
pre = pre->Next;
++cnt;
}
if (pre == nullptr || cnt != i - 1)
{
cout << "invalid i" << endl;
return nullptr;
}
else
{
tmp = (Position)malloc(sizeof(LNode));
tmp->Data = X;
tmp->Next = pre->Next;
pre->Next = tmp;
return L;
}
}
bool mydelete(List L, int i)
{
Position pre, tmp;
int cnt = 0;
pre = L;
while (pre&&cnt < i - 1)
{
pre = pre->Next;
++cnt;
}
if (pre == nullptr || cnt != i - 1 || pre->Next == nullptr)
{
cout << "invalid delete" << endl;
return false;
}
else
{
tmp = pre->Next;
pre->Next = tmp->Next;
free(tmp);
return true;
}
}
void show(List L)
{
Position p = L->Next;
while (p)
{
cout << p->Data << endl;
p = p->Next;
}
}
#define MIN 2
#define MAX 6
void deleterange(List L, int min, int max)
{
int a[20];
for (auto i = 0; i != 20; ++i)
a[i] = 0;
Position p = L->Next;
int j=0;
for(int i = 1; p != nullptr; ++i)
{
if (p->Data >= MIN && p->Data <= MAX)
{
a[j] = i;
++j;
}
p = p->Next;
}
for (auto i = 0; i != j; ++i)
{
mydelete(L, a[i]);
for (auto k = 0; k != j; ++k)
{
--a[k];
}
}
}
int main()
{
PtrToLNode first = (PtrToLNode)malloc(sizeof(LNode));
first->Data = 1;
PtrToLNode second = (PtrToLNode)malloc(sizeof(LNode));
second->Data = 2;
first->Next = second;
second->Next = nullptr;
List L = (List)malloc(sizeof(LNode));
L->Next = first;
Insert2(L, 3, 3);
Insert2(L, 4, 4);
Insert2(L, 7, 5);
Insert2(L, 5, 6);
Insert2(L, 3, 7);
Insert2(L, 4, 8);
show(L);
cout << "End" << endl;
deleterange(L, MIN, MAX);
show(L);
return 0;
}
其实这个题的思想很简单就是遍历,但由于之前设计的线性表寻找返回指针,但删除却要求元素下标,所以变得更麻烦了。