//funny quiz,in the board ,three condition in if judgement,
//spent lots of time
//one:recursive two:no recursive
struct ListNode* deleteDuplicates(struct ListNode* head) {
if(head == NULL || head->next == NULL)
return head;
struct ListNode* cur = head;
struct ListNode* nxt = head->next;
if(cur->val != nxt->val)
cur->next = deleteDuplicates(cur->next);
else if(cur->next->next == NULL && cur->val == nxt->val)
return NULL;
else
{
while(nxt->next)
{
if(cur->val == nxt->val)
{
nxt = nxt->next;
if(nxt->next == NULL && nxt->val == cur->val)
return NULL;
}
else
break;
}
head = deleteDuplicates(nxt);
}
return head;
}
int main(int argc, char const *argv[]) {
// struct ListNode* head = BuildByLength(9);
// struct ListNode* newNode = malloc(sizeof(struct ListNode));
// newNode->val = 5;
// newNode->next = NULL;
// SortedInsert(&head, newNode);
struct ListNode* nn1 = malloc(sizeof(struct ListNode));
nn1->val = 6;
nn1->next = NULL;
// SortedInsert(&head, nn1);
// PrintList(head);
// printf("---After Remove Duplicates\n");
// deleteDuplicates(head);
// PrintList(head);
deleteDuplicates(nn1);
PrintList(deleteDuplicates(nn1));
struct ListNode* nn2;
Push(&nn2, 2);
Push(&nn2, 1);
PrintList(deleteDuplicates(nn2));
// free(newNode);
// free(nn1);
return 0;
}
ListNode* deleteDuplicates(ListNode* head) {
if(head == NULL || head->next == NULL)
return head;
if(head->val == head->next->val){
head->next = head->next->next;
head = deleteDuplicates(head);
} else {
head->next = deleteDuplicates(head->next);
}
}
ListNode *deleteDuplicates(ListNode *head) {
if(head==NULL||head->next==NULL) return head;
ListNode * p=head;
if(p->val==p->next->val){
p->next=p->next->next;
ListNode * a=deleteDuplicates(p);
}
else{
ListNode * a=deleteDuplicates(p->next);
}
return head;
}
ListNode* deleteDuplicates(ListNode* head) {
if (!head) return 0;
if (!head->next) return head;
int val = head->val;
ListNode* p = head->next;
if (p->val != val) {
head->next = deleteDuplicates(p);
return head;
} else {
while (p && p->val == val) p = p->next;
return deleteDuplicates(p);
}
}
ListNode* deleteDuplicates(ListNode* head) {
if(head==NULL || head->next==NULL){
return head;
}
if(head->val == head->next->val){
while(head->next && head->val==head->next->val){
head = head->next;
}
return deleteDuplicates(head->next);
}
else{
head->next = deleteDuplicates(head->next);
return head;
}
}
int main(int argc, const char * argv[]) {
// insert code here...
ListNode* head = new ListNode(1);
ListNode* node1 = new ListNode(1);
ListNode* node2 = new ListNode(2);
ListNode* node3 = new ListNode(2);
ListNode* node4 = new ListNode(2);
ListNode* node5 = new ListNode(5);
ListNode* node6 = new ListNode(5);
head->next = node1;
node1->next = node2;
node2->next = node3;
node3->next = node4;
node4->next = node5;
node5->next = node6;
ListNode* cur = deleteDuplicates(head);
ListNode* pre = cur;
while (cur != NULL) {
std::cout<<cur->val<<std::endl;
pre = cur;
cur = cur->next;
delete pre;
}
return 0;
}
int main(void){
int values[] = {1, 1, 2, 2, 3};
int i, size = sizeof(values)/sizeof(int);
struct ListNode *p, *head;
for (i=0; i<size; i++){
printf("%d ", values[i]);
if (i==0){
head = p = (struct ListNode *)malloc(sizeof(struct ListNode));
p->val = values[i];
p->next = NULL;
}else{
p->next = (struct ListNode *)malloc(sizeof(struct ListNode));
p->next->next = NULL;
p->next->val = values[i];
p = p->next;
}
}
printf("\n");
head = deleteDuplicates(head);
p = head;
while (p != NULL){
printf("%d ", p->val);
p = p->next;
}
printf("\n");
return 0;
}
ListNode *deleteDuplicates(ListNode *head) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if(head==NULL)
return NULL;
if(head->next ==NULL)
return head;
ListNode* prev, *front, *back, *it;
prev=NULL;
front=head;
it=head->next;
bool duplicate=false;
while(it!=NULL){
if(it->val == front->val){
back=it;
it=it->next;
duplicate=true;// set the flag to true
}
else{ // current value not equal to front's
if(!duplicate){ // no duplicate nodes
// update all pointers
prev=front;
front=it;
it=it->next;
}
else{ // need to call delete
if(prev==NULL) // delete from the frist node
return deleteDuplicates(it);
else{
DeleteMultiNodes(prev,front,back);
return deleteDuplicates(head);
}
}
}
}
if(duplicate){
if(prev==NULL)
return NULL;
else
prev->next=NULL;
}
return head;
}
bool LinkedListsExpert::testDeleteDuplicates(){
bool checker = true;
std::forward_list<int> list1 = {1,5,3,1,2,10,3,3,2};
list1 = deleteDuplicates(list1);
std::forward_list<int> list2 = {1,5,3,2,10};
checker = (list1 == list2);
return checker;
}
/**
* @param head: The first node of linked list.
* @return: head node
*/
ListNode * deleteDuplicates(ListNode *head) {
// write your code here
if (NULL == head) {
return NULL;
}
bool head_flag = false;
while (head && head->next && head->next->val == head->val) {
head_flag = true;
head->next = head->next->next;
}
if (head_flag) {
return deleteDuplicates(head->next);
}
else {
head->next = deleteDuplicates(head->next);
return head;
}
}
ListNode* deleteDuplicates(ListNode* head) {
if (!head || !head->next) return head;
int tmp = head->val;
ListNode* cur = head->next;
while (cur && cur->val == tmp) cur = cur->next;
head->next = deleteDuplicates(cur);
return head;
}
ListNode *deleteDuplicates(ListNode *head) {
if (!head) return head;
ListNode *nextElem = head->next;
while (nextElem && nextElem->val == head->val) {
nextElem = nextElem->next;
}
head->next = deleteDuplicates(nextElem);
return head;
}
int main()
{
int nums[] = { -3, -3, -3, -2, -1, -1, 0, 0, 0, 0, 0 };
pListNode list = CreateList(nums, sizeof(nums) / sizeof(int));
PrintList(list);
PrintList(deleteDuplicates(list));
return 0;
}
/**
* @param head: The first node of linked list.
* @return: head node
*/
ListNode *deleteDuplicates(ListNode *head) {
if (head == NULL || head->next == NULL) return head;
ListNode* next = deleteDuplicates(head->next);
if (head->val == next->val) {
delete head;
return next;
} else {
head->next = next;
return head;
}
}
//version 2 clean easy to understand
struct ListNode* deleteDuplicates(struct ListNode* head) {
if(head == NULL || head->next == NULL)
return head;
struct ListNode* nxt = head->next;
if(head->val != nxt->val)
head->next = deleteDuplicates(head->next);
else
{
while(nxt->next && nxt->next->val == head->val)
nxt = nxt->next;
if(!nxt->next)
return NULL;
else
return deleteDuplicates(nxt->next);
}
return head;
}
int main()
{
int sets[] = {0, 0, 0, 1, 4, 4, 6, 7, 7};
struct ListNode *beforerm = initlist(sets, sizeof(sets)/sizeof(int));
printf("before remove, list is :\n");
printlist(beforerm);
struct ListNode *afterrm = deleteDuplicates(beforerm);
printf("\nafter remove, list is :\n");
printlist(afterrm);
}
ListNode* deleteDuplicates(ListNode* head) {
if (head == NULL || head->next == NULL)
return head;
ListNode *p = head->next;
if (head->val == p->val)
{
while (p && p->val == head->val)
{
ListNode *r = p;
delete r;
p = p->next;
}
delete head;
return deleteDuplicates(p);
}
else
{
head->next = deleteDuplicates(head->next);
return head;
}
}
int main(int argc, char const *argv[])
{
List L1, L2, L;
L1 = CreateEvenList(10);
L2 = CreateOddList(10);
PrintList(L1);
PrintList(L2);
L1 = deleteDuplicates(L1);
L2 = deleteDuplicates(L2);
PrintList(L1);
PrintList(L2);
L1 = CreateDupList(10);
PrintList(L1);
L1 = deleteDuplicates(L1);
PrintList(L1);
return 0;
}
ListNode *deleteDuplicates(ListNode *head){
if(head==NULL||head->next==NULL) return head;
ListNode *p=head;
while(p->next!=NULL&&p->val==p->next->val){
p=p->next;
}
if(p!=head){
while(p!=head){
ListNode *tmp=head;
head=head->next;
free(tmp);
}
return deleteDuplicates(head->next);
}
head->next=deleteDuplicates(head->next);
return head;
}
int main(int argc, char **argv) {
struct ListNode *node1 = malloc(sizeof(struct ListNode));
node1->val = 1;
struct ListNode *node2 = malloc(sizeof(struct ListNode));
node2->val = 2;
struct ListNode *node3 = malloc(sizeof(struct ListNode));
node3->val = 2;
node1->next = node2;
node2->next = node3;
node3->next = NULL;
deleteDuplicates(node1);
assert(node1->next == node2);
assert(node2->next == NULL);
}
main()
{
int i,n,data;
struct node *start=NULL;
printf("Enter the number of elements : ");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("Enter the element to be inserted : ");
scanf("%d",&data);
start=insert_s(start,data);
}
display(start);
deleteDuplicates(start);
display(start);
}/*End of main()*/
void Duplicados::on_deleteDuplicates_clicked()
{
vector<QString> cartas = deleteDuplicates(getArray());
ui->Array2->clear();
cout<<"imprimendo data 2"<<endl;
for(int i=0; i<cartas.size(); i++)
{
cout<<cartas[i].toStdString()<<endl;
}
cout<<"termino de imprimir data"<<endl;
for(int i=0; i<cartas.size(); i++)
{
QListWidgetItem *item = new QListWidgetItem();
item->setText(cartas[i]);
if(item->text()!="")
ui->Array2->addItem(item);
}
/*int size = 12;
char carts[size] = {'a','b','c','d','a','b','c','e','f','a','b','g'};
for(int i=0; i<size; i++)
{
for(int j=i+1; j<size;j++)
{
if(carts[i]==carts[j])
{
//cout<<"es igual: "<<carts[i].toStdString()<<endl;
for(int k=j+1;k<size;k++)
{
carts[k-1]=carts[k];
}
carts[--size]=' ';
//size_nuevas++;
}
}
}
for(int i=0; i<size; i++)
{
cout<<carts[i];
}*/
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
if (a.arguments().count() < 2) {
qDebug() << "Usage: qtstats path-to-qt";
return 0;
}
const QString qtPath = a.arguments().at(1);
qDebug() << "Looking at Qt at" << qtPath;
bool loadData = true;
if (loadData) {
Database("qtstats.sqlite").deleteDatabase();
}
Database database("qtstats.sqlite");
AttributedTable commitsTable(&database, "Commits");
commitsTable.setTableScema(QStringList() << "Branch" << "Sha1" << "CommitTime" << "PatchSize",
QStringList() << "VARCHAR" << "VARCHAR" << "INTEGER" << "INTEGER");
commitsTable.setColumnRoleAttributes(commitsTable.columnNames(),
QStringList() << "Index" << "Data" << "TimeIndex" << "Data");
if (loadData) {
loadData(&database, qtPath);
}
database.execQuery("CREATE INDEX CommitsIndex ON Commits (CommitTime)", true);
deleteDuplicates(&database, commitsTable);
TimeGroupCounter counter(&database);
counter.skipColumn("Sha1");
AttributedTable aggregatedCommits = counter.aggregate(commitsTable);
trimZeroValues(&database, aggregatedCommits);
aggregatedCommits.setAttribute("Title", "Weekly Commit Rate For " + QDir(qtPath).dirName());
aggregatedCommits.setAttribute("CountTitle", "Commit Count");
aggregatedCommits.setAttribute("TimeTitle", "Time");
aggregatedCommits.setAttribute("timeChart", "true");
// Generate report
ReportGenerator(&database, aggregatedCommits.tableName()).generateReport(QDir::currentPath());
}
int main(){
ListNode *n1 = new ListNode(1);
ListNode *n2 = new ListNode(1);
ListNode *n3 = new ListNode(2);
ListNode *n4 = new ListNode(2);
ListNode *n5 = new ListNode(3);
n1->next = n2;
n2->next = n3;
n3->next = n4;
n4->next = n5;
n5->next = NULL;
printList(n1);
n1 = deleteDuplicates(n1);
printList(n1);
return 0;
}
int main()
{
struct ListNode * t1[4];
for(int i = 0; i< 4; i++){
t1[i] = malloc(sizeof(struct ListNode));
}
t1[0]->val = 1;
t1[1]->val = 2;
t1[2]->val = 2;
t1[3]->val = 5;
t1[0]->next = t1[1];
t1[1]->next = t1[2];
t1[2]->next = t1[3];
t1[3]->next = NULL;
struct ListNode * hhh = deleteDuplicates(t1[0]);
printList(hhh);
}
ListNode* deleteDuplicates(ListNode* head) {
if (!head || head->next == NULL) return head;
while (head && head->next && head->next->val == head->val) {
// should delete heading elements
ListNode* p = head->next->next;
int val = head->val;
delete head;
delete head->next;
while (p && p->val == val) {
ListNode* tmp = p;
p = p->next;
delete tmp;
}
head = p;
}
if (head)
head->next = deleteDuplicates(head->next);
return head;
}
int main() {
int nums[] = { 1, 2, 2, 2, 3, 3 };
struct ListNode *head = buildList(nums, sizeof(nums) / sizeof(nums[0]));
struct ListNode *p = head;
while (p) {
printf("%d->", p->val);
p = p->next;
}
printf("NIL\n");
struct ListNode *new_head = deleteDuplicates(head);
p = new_head;
while (p) {
printf("%d->", p->val);
p = p->next;
}
printf("NIL\n");
return 0;
}
ListNode *deleteDuplicates(ListNode *head) {
if (head == NULL)
return NULL;
// delete all the node(s) with the same val as head
ListNode *p = head->next;
while (p != NULL) {
if (p->val == head->val) {
head->next = p->next;
delete p;
p = head->next;
} else
break;
}
// check next
if (p == NULL)
return head;
// recursion
head->next = deleteDuplicates(p);
return head;
}
ListNode *deleteDuplicates(ListNode *head) {
bool tag = false;
while(head){
if(head->next && head->val == head->next->val){
head = head->next;
tag = true;
} else
break;
}
if(tag && head){
head = head->next;
return deleteDuplicates(head);
}
if(head == NULL)
return head;
ListNode *pre = head, *mid = head->next, *after;
int val = pre->val;
while(mid){
if(mid->val == val){
mid = mid->next;
pre->next = mid;
} else{
after = mid->next;
if(after && after->val == mid->val){
val = mid->val;
mid = after->next;
pre->next = mid;
} else{
pre = mid;
val = pre->val;
mid = mid->next;
}
}
}
return head;
}
