数据结构 把两个单链表中相同的数字找出来并赋给第三个链表，但是不重复显示？vb几万行TXT文本记录如何快速除重并乱序排列

本文目录

• 数据结构 把两个单链表中相同的数字找出来并赋给第三个链表，但是不重复显示
• vb几万行TXT文本记录如何快速除重并乱序排列
• 一个C语言程序
• Algorithm小白入门 -- 数组
• 用C++设计一个单向链表类模板，可以定义多种数据类型如整型、双精度、字符型、字符串型等
• c++编写的链表

数据结构 把两个单链表中相同的数字找出来并赋给第三个链表，但是不重复显示

首先说你的代码没问题，只是没有处理重复元素，现在给你提供几个思路：1。在建立A链表和B链表的时候就去重2。用一个辅助哈希数组标记C链表中的元素，保证不出现重复3。每次在C链表中添加元素时都遍历一遍C链表，如果要添加的元素在C中已经出现，就不要添加了，否则，就添加第一个最麻烦，但思路清晰，从源头解决问题，第二个最省时间，但要有额外的内存开销，第三个比较费时间，但对你来说，似乎最好实现。。。。请斟酌后修改代码。希望能帮到你。

vb几万行TXT文本记录如何快速除重并乱序排列

关键是这个“几万”。在vb中，数组的大小是有限的,也刚好是“几万”。简单点的办法是利用数据库。取每一行的内容，hash值保存到一个表中，hash字段为主键,它就不允许重复,添加数据时就可以完成去重。然后用随机数从里面取记录就好，取一条记录就删除一条,伪代码如下:for i=行数 to 1 step -1行号=int(rnd()*i+1)行内容 = 读记录(行号）删记录(行号)输出(行内容+CRLF)next如果不想使用数据库,也可以使用链表或二叉树/B树。在vb中实现链表比较费空间,而且链表在去重方面效率不高。使用树则在去重方面会很高，随机取出则低，你也可以结合二者来使用。完全在vb中实现的话，建议只保存每行的hash和行的开始偏移及行长度，这样会节约一点内存,但文件IO就会高一些。

一个C语言程序

修订版:#include 《stdio.h》#include 《stdlib.h》#include 《string.h》typedef int T;// 打印数组void Print(T* beg, T* end, const char* msg){ printf(msg); while(beg != end) printf("%d ", *beg++); putchar(’\n’);}// 把元素向左移以覆盖重复元素void MoveUp(T* dest, T* src, T* end){ while(src != end) *dest++ = *src++;}// 去重T* Unique(T* beg, T* end){ T* dupBeg = end; if(end - beg 《= 1) return end; while(++beg != end) { if(*(beg - 1) == *beg) { dupBeg = beg; while(*++dupBeg == *(dupBeg - 1) && dupBeg != end); if(dupBeg == end) return beg; else { MoveUp(beg, dupBeg, end); end -= dupBeg - beg; } } } return end;}// 求差集T* SetDiff(T* a, T* endOfA, T* b, T* endOfB, T* c){ T* p; for(; a != endOfA; ++a) { for(p = b; p != endOfB; ++p) if(*p == *a) break; if(p == endOfB) *c++ = *a; } return c;}inline int Cmp(const void* lhs, const void* rhs){ return *(const T*)lhs - *(const T*)rhs;}int main(){ // 只是个示例，元素个数很多的话可以用动态数组 T a); T b); T* c, *endOfC; // 排序 qsort(a, endOfA - a, sizeof(T), Cmp); qsort(b, endOfB - b, sizeof(T), Cmp); // 去重 endOfA = Unique(a, endOfA); endOfB = Unique(b, endOfB); Print(a, endOfA, "Set A: "); Print(b, endOfB, "Set B: "); // c = a - b; c = (T*)malloc(sizeof(T) * (endOfA - a)); endOfC = SetDiff(a, endOfA, b, endOfB, c); Print(c, endOfC, "Difference of A & B: "); free(c); return 0;}这样的话用C++更简单，直接set_difference:#include 《iostream》#include 《list》#include 《algorithm》#include 《iterator》using namespace std;int main(){int a = {12,23,18,15,12,13};int b = {4,12,26,23,14};list《int》 la(a, a + 6);list《int》 lb(b, b + 5);list《int》 lc;// 排序la.sort();lb.sort();// 去重la.unique();lb.unique();// 求差集，存在lc中set_difference(la.begin(), la.end(), lb.begin(), lb.end(), back_inserter(lc));// 打印copy(lc.begin(), lc.end(), ostream_iterator《int》(cout, " "));}至于存储数据的数据结构，list，deque都是理想的选择，vector不太适合，因为你的数据量比较大，其他的就不用我说了吧，数据结构 + 《algorithm》 就可以了，STL的算法和数据结构效率应该够高了吧，思路给你，具体的地方需要的话自己改一下。如果嫌list是占用空间大的话可以用deque，但是unique和sort等方法就必须使用《algorithm》中的了，还有别忘了erase。

Algorithm小白入门 -- 数组

快慢指针一般都初始化指向链表的头结点 head ，前进时快指针 fast 在前，慢指针 slow 在后，巧妙解决一些链表中的问题。

用两个指针，一个跑得快，一个跑得慢。如果不含有环，跑得快的那个指针最终会遇到 null ，说明链表不含环；如果含有环，快指针最终会超慢指针一圈，和慢指针相遇，说明链表含有环。

当快慢指针相遇时，让其中任一个指针指向头节点，然后让它俩以相同速度前进，再次相遇时所在的节点位置就是环开始的位置。

让快指针一次前进两步，慢指针一次前进一步，当快指针到达链表尽头时，慢指针就处于链表的中间位置。

使用快慢指针，让快指针先走n步，然后快慢指针开始同速前进。这样当快指针走到链表末尾null时，慢指针所在的位置就是倒数第n个链表节点（n不会超过链表长度）。

左右指针在数组中实际是指两个索引值，一般初始化为 left = 0, right = nums.length - 1 。

只要数组有序，就可以考虑用双指针技巧。上面题有点类似二分查找，通过调节 left 和 right 可以调整 sum 的大小。

若给的数组无序，使用穷举法如下：

通过一个哈希表减少时间复杂度，优化如下：

此类问题还可以衍生要求设计一个类，拥有两个 API：

使用哈希表辅助 find 方法如下：

上述针对频繁使用 find 方法的场景还可以优化：

对于 TwoSum 问题，一个难点就是给的数组无序。对于一个无序的数组，似乎没什么技巧，只能暴力穷举所有可能。

一般情况下，我们会首先把数组排序再考虑双指针技巧。

另外， HashMap 或 HashSet 也可以辅助处理无序数组相关的简单问题。

对于数组来说，在尾部插入、删除元素是比较高效的，时间复杂度是 O(1) ，但若在中间或开头插入、删除元素，就会涉及数据的搬移，时间复杂度为 O(N) ，效率较低。

使用上面介绍的 双指针技巧 中的 快慢指针 技巧，也可避免直接删除数组中的元素，降低算法的复杂度。

有序链表去重和有序数组去重的区别是把数组赋值操作变成操作指针而已：

总结：双指针技巧分为两类，一类是「快慢指针」，一类是「左右指针」。前者解决主要解决链表中的问题，比如典型的判定链表中是否包含环；后者主要解决数组（或者字符串）中的问题，比如二分查找。数组「原地修改」的算法问题，其实核心也是快慢指针技巧。

参考链接：

双指针技巧直接秒杀五道算法题

twoSum问题的核心思想

双指针技巧秒杀四道数组/链表题目

用C++设计一个单向链表类模板，可以定义多种数据类型如整型、双精度、字符型、字符串型等

DEV C++用下面版本# include 《iostream》# include 《string》template 《class T》class List;template 《class T》std::ostream &operator 《《(std::ostream &os, const List《T》 &lst);template 《class T》class Node{private:T Data;Node《T》 *Prev;Node《T》 *Next;friend class List《T》;friend std::ostream &operator 《《 《T》(std::ostream &os, const List《T》 &lst);public:Node(const T &Val):Data(Val), Prev(NULL), Next(NULL) {}~Node(){if(Prev)Prev = NULL;if(Next)Next = NULL;}};template 《class T》class List{private:Node《T》 *Head;Node《T》 *Tail;int Size;void Destory(void)//销毁链表{while(Head)this-》pop_back();}static void swap(Node《T》 *p1, Node《T》 *p2)//交换节点的数据域{T Val = p1-》Data;p1-》Data = p2-》Data;p2-》Data = Val;}void BubbleSort(void)//冒泡排序（升序）{Node《T》 *start;Node《T》 *end;bool flag = true;for(end = Tail; flag && end-》Prev; end = end-》Prev){flag = false;for(start = Head; start != end; start = start-》Next){if(start-》Data 》 start-》Next-》Data){flag = true;swap(start, start-》Next);}}}}bool search(const T &Val)//查找指定元素，返回true或false{Node《T》 *Temp = Head;while(Temp){if(Temp-》Data == Val)return true;Temp = Temp-》Next;}return false;}bool search(const T &Val) const//重载函数，用于const对象{Node《T》 *Temp = Head;while(Temp){if(Temp-》Data == Val)return true;Temp = Temp-》Next;}return false;}friend std::ostream &operator 《《 《T》(std::ostream &os, const List《T》 &lst);public:List():Head(NULL), Tail(NULL), Size(0) {}//默认构造函数List(const List《T》 &lst):Head(NULL), Tail(NULL), Size(0)//复制构造函数{Node《T》 *Temp = lst.Head;while(Temp){push_back(Temp-》Data);Temp = Temp-》Next;}}~List()//析构函数{Destory();}void push_back(const T &Val)//将数据插入链表尾部{Node《T》 *Temp = new Node《T》(Val);if(!Head)Head = Tail = Temp;else{Tail-》Next = Temp;Temp-》Prev = Tail;Tail = Temp;}++Size;}void pop_back(void)//弹出链表尾节点{if(Head){if(Head != Tail){Node《T》 *Temp = Tail;Tail = Tail-》Prev;delete Temp;Tail-》Next = Temp = NULL;}else{delete Head;Head = Tail = NULL;}--Size;}}int size(void)//返回链表中节点个数{return Size;}int size(void) const//重载函数，用于const对象{return Size;}void sort(void)//对链表排序{this-》BubbleSort();}void erase(const T &Val)//删除指定节点{Node《T》 *Temp = Head;Node《T》 *temp;while(Temp){if(Temp-》Data == Val){if(Temp-》Prev){temp = Temp;temp-》Prev-》Next = temp-》Next;if(temp-》Next)temp-》Next-》Prev = temp-》Prev;elseTail = temp-》Prev;Temp = temp-》Next;delete temp;}else{temp = Temp;if(temp-》Next)temp-》Next-》Prev = NULL;elseTail = temp-》Prev;Head = Temp = temp-》Next;delete temp;}}elseTemp = Temp-》Next;}}void find(const T &Val)//查找指定元素，有输出Yes，无输出"None"{std::cout《《"查找数据域为 "《《Val《《" 的节点：";if(search(Val))std::cout《《"Yes!"《《std::endl;elsestd::cout《《"None!"《《std::endl;}void find(const T &Val) const//重载函数，用于const对象{std::cout《《"查找数据域为 "《《Val《《" 的节点：";if(search(Val))std::cout《《"Yes!"《《std::endl;elsestd::cout《《"None!"《《std::endl;}void remove(void)//除去重复元素{List《T》 lst;Node《T》 *Temp = Head;while(Temp){if(!lst.search(Temp-》Data))lst.push_back(Temp-》Data);Temp = Temp-》Next;}*this = lst;}T maximum(void)//查找最大值，若空对象操作此函数则抛出异常{if(!Head)throw 0;List《T》 lst(*this);lst.sort();return lst.Tail-》Data;}const T maximum(void) const//重载函数，用于const对象{if(!Head)throw 0;List《T》 lst(*this);lst.sort();return lst.Tail-》Data;}T minimum(void)//查找最小值，若空对象操作此函数则抛出异常{if(!Head)throw 0;List《T》 lst(*this);lst.sort();return lst.Head-》Data;}const T minimum(void) const//重载函数，用于const对象{if(!Head)throw 0;List《T》 lst(*this);lst.sort();return lst.Head-》Data;}List《T》 &operator =(const List &lst)//重载赋值运算符{if(Head)this-》Destory();Node《T》 *Temp = lst.Head;while(Temp){this-》push_back(Temp-》Data);Temp = Temp-》Next;}return *this;}};template 《class T》std::ostream &operator 《《(std::ostream &os, const List《T》 &lst)//重载输出运算符{Node《T》 *Temp = lst.Head;while(Temp){os《《Temp-》Data;if(Temp-》Next)os《《’\t’;Temp = Temp-》Next;}return os;}int main(void){List《int》 lst;lst.push_back(2);//push_back用于输入lst.push_back(1);lst.push_back(1);lst.push_back(4);lst.push_back(2);std::cout《《lst《《std::endl;lst.pop_back();//pop_back用于弹出尾节点std::cout《《lst《《std::endl;lst.sort();//sort用于排序std::cout《《lst《《std::endl;lst.remove();//remove用于除去重复节点std::cout《《lst《《std::endl;lst.erase(1);//erase用于删除指定节点std::cout《《lst《《std::endl;lst.find(4);//find用于查找指定节点，有输出Yes，无输出Nonelst.find(1);std::cout《《lst.maximum()《《std::endl;//maximum返回最大节点的数据域std::cout《《lst.minimum()《《std::endl;//minimum返回最小节点的数据域return 0;}VC6.0用下面版本# include 《iostream》# include 《string》template 《class T》class List;template 《class T》class Node{private:T Data;Node《T》 *Prev;Node《T》 *Next;friend class List《T》;friend std::ostream &operator 《《(std::ostream &os, const List《T》 &lst); //这一语句其实是错误的，但是VC6.0的BUG让我不得不这么写public:Node(const T &Val):Data(Val), Prev(NULL), Next(NULL) {}~Node(){if(Prev)Prev = NULL;if(Next)Next = NULL;}};template 《class T》class List{private:Node《T》 *Head;Node《T》 *Tail;int Size;void Destory(void)//销毁链表{while(Head)this-》pop_back();}static void swap(Node《T》 *p1, Node《T》 *p2)//交换节点的数据域{T Val = p1-》Data;p1-》Data = p2-》Data;p2-》Data = Val;}void BubbleSort(void)//冒泡排序（升序）{Node《T》 *start;Node《T》 *end;bool flag = true;for(end = Tail; flag && end-》Prev; end = end-》Prev){flag = false;for(start = Head; start != end; start = start-》Next){if(start-》Data 》 start-》Next-》Data){flag = true;swap(start, start-》Next);}}}}bool search(const T &Val)//查找指定元素，返回true或false{Node《T》 *Temp = Head;while(Temp){if(Temp-》Data == Val)return true;Temp = Temp-》Next;}return false;}bool search(const T &Val) const//重载函数，用于const对象{Node《T》 *Temp = Head;while(Temp){if(Temp-》Data == Val)return true;Temp = Temp-》Next;}return false;}friend std::ostream &operator 《《(std::ostream &os, const List《T》 &lst);public:List():Head(NULL), Tail(NULL), Size(0) {}//默认构造函数List(const List《T》 &lst):Head(NULL), Tail(NULL), Size(0)//复制构造函数{Node《T》 *Temp = lst.Head;while(Temp){push_back(Temp-》Data);Temp = Temp-》Next;}}~List()//析构函数{Destory();}void push_back(const T &Val)//将数据插入链表尾部{Node《T》 *Temp = new Node《T》(Val);if(!Head)Head = Tail = Temp;else{Tail-》Next = Temp;Temp-》Prev = Tail;Tail = Temp;}++Size;}void pop_back(void)//弹出链表尾节点{if(Head){if(Head != Tail){Node《T》 *Temp = Tail;Tail = Tail-》Prev;delete Temp;Tail-》Next = Temp = NULL;}else{delete Head;Head = Tail = NULL;}--Size;}}int size(void)//返回链表中节点个数{return Size;}int size(void) const//重载函数，用于const对象{return Size;}void sort(void)//对链表排序{this-》BubbleSort();}void erase(const T &Val)//删除指定节点{Node《T》 *Temp = Head;Node《T》 *temp;while(Temp){if(Temp-》Data == Val){if(Temp-》Prev){temp = Temp;temp-》Prev-》Next = temp-》Next;if(temp-》Next)temp-》Next-》Prev = temp-》Prev;elseTail = temp-》Prev;Temp = temp-》Next;delete temp;}else{temp = Temp;if(temp-》Next)temp-》Next-》Prev = NULL;elseTail = temp-》Prev;Head = Temp = temp-》Next;delete temp;}}elseTemp = Temp-》Next;}}void find(const T &Val)//查找指定元素，有输出Yes，无输出"None"{std::cout《《"查找数据域为 "《《Val《《" 的节点：";if(search(Val))std::cout《《"Yes!"《《std::endl;elsestd::cout《《"None!"《《std::endl;}void find(const T &Val) const//重载函数，用于const对象{std::cout《《"查找数据域为 "《《Val《《" 的节点：";if(search(Val))std::cout《《"Yes!"《《std::endl;elsestd::cout《《"None!"《《std::endl;}void remove(void)//除去重复元素{List《T》 lst;Node《T》 *Temp = Head;while(Temp){if(!lst.search(Temp-》Data))lst.push_back(Temp-》Data);Temp = Temp-》Next;}*this = lst;}T maximum(void)//查找最大值，若空对象操作此函数则抛出异常{if(!Head)throw 0;List《T》 lst(*this);lst.sort();return lst.Tail-》Data;}const T maximum(void) const//重载函数，用于const对象{if(!Head)throw 0;List《T》 lst(*this);lst.sort();return lst.Tail-》Data;}T minimum(void)//查找最小值，若空对象操作此函数则抛出异常{if(!Head)throw 0;List《T》 lst(*this);lst.sort();return lst.Head-》Data;}const T minimum(void) const//重载函数，用于const对象{if(!Head)throw 0;List《T》 lst(*this);lst.sort();return lst.Head-》Data;}List《T》 &operator =(const List &lst)//重载赋值运算符{if(Head)this-》Destory();Node《T》 *Temp = lst.Head;while(Temp){this-》push_back(Temp-》Data);Temp = Temp-》Next;}return *this;}};template 《class T》std::ostream &operator 《《(std::ostream &os, const List《T》 &lst)//重载输出运算符{Node《T》 *Temp = lst.Head;while(Temp){os《《Temp-》Data;if(Temp-》Next)os《《’\t’;Temp = Temp-》Next;}return os;}int main(void){List《int》 lst;lst.push_back(2);//push_back用于输入lst.push_back(1);lst.push_back(1);lst.push_back(4);lst.push_back(2);std::cout《《lst《《std::endl;lst.pop_back();//pop_back用于弹出尾节点std::cout《《lst《《std::endl;lst.sort();//sort用于排序std::cout《《lst《《std::endl;lst.remove();//remove用于除去重复节点std::cout《《lst《《std::endl;lst.erase(1);//erase用于删除指定节点std::cout《《lst《《std::endl;lst.find(4);//find用于查找指定节点，有输出Yes，无输出Nonelst.find(1);std::cout《《lst.maximum()《《std::endl;//maximum返回最大节点的数据域std::cout《《lst.minimum()《《std::endl;//minimum返回最小节点的数据域return 0;}

c++编写的链表

2.遍历链表，做排序处理。程序如下：link *p = head;link *ptemp = NULL;if (p == NULL || p-next == NULL) return;//去重while (p-》next != tail){ if (p-》element == p-》next-》element) { ptemp = p-》next; p-》next = ptemp-》next; delete ptemp; ptemp = NULL; p = p-》next; }}//排序ptemp = head-》next;link *ph = head;int itemp = 0;while (ph-》next != tail){ while (ptemp-》next != tail && ph-》element 》 ptemp-》element) { itemp = ptemp-》element; ptemp-》element = ph-》element; ph-》element = itemp; ptemp = ptemp-》next; } ph = ph-》next;}程序未作验证，请参考！