Từ 1 tới 9 trên tổng số 9 kết quả

Đề tài: Hàm xóa phần tử trùng nhau trong danh sách liên kết

  1. #1
    Ngày gia nhập
    04 2017
    Bài viết
    1

    Mặc định Hàm xóa phần tử trùng nhau trong danh sách liên kết

    Hàm này e viết theo như e hiểu thì đúng mà sao chạy toàn sai :(( ai có thể hướng dẫn em đã sai chỗ nào không????

    Code:
    void DELETE_DUPLICATE(List L){
    	Position p=FIRST(L);
    	while (p!=ENDLIST(L)){
    		Position  q=NEXT(p,L); // get the following of position p  
    		while (q!=ENDLIST(L)){
    			if (RETRIEVE(p,L) == RETRIEVE(q,L)){
    				DELETE_LIST(q,L);
    			}
    			q=NEXT(q,L);
    		}
    		p=NEXT(p,L);
    
    }
    }

  2. #2
    Ngày gia nhập
    02 2014
    Nơi ở
    TP.HCM
    Bài viết
    730

    Đề tài này lập đi lập lại vài lần rồi, tốt nhất bạn đưa mã nguồn lên (hoặc bản nhái chạy được), chứ cắt khúc như này thì ai dám chắc sai ở đây hay chỗ khác. Ngôn ngữ gì, thư viện nào,... được sử dụng.
    Yêu mã hơn yêu em !!!

  3. #3
    Ngày gia nhập
    04 2017
    Bài viết
    1

    đây là code của e, hàm đó khi nhập vào 3 phần tử giống nhau nó chỉ xóa 1 phần tử vd: nhập 1 1 1 thì kết quả chỉ trả về 1 1 :(( còn nhập 2 phần tử 1 1 thì bị lỗi :(((

    Code:
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<conio.h>
    
    
    typedef int ElementType; //type of elements 
    typedef struct Node{
    	    ElementType Element;// contain an element 
      		Node* Next; /*pointer to link to the following cell*/
    }k;
    typedef Node* Position; // type of position (pointer) 
    typedef Position List;
    
    Position FIRST(List L){
    	Position P=L;
    	return P;
    }
    Position ENDLIST(List L){
    	Position P=FIRST(L);
    	while(P->Next != NULL){
    		P=P->Next;
    	}
    	return P;
    }
    Position NEXT(Position P,List L){
    
    	return P->Next;
    }
    ElementType RETRIEVE(Position P, List L){
    	if (P->Next!=NULL)
    		return P->Next->Element;
    }
    int LENGTH(List L){
    	Position P=L;
    	int i=0;
    	while(P->Next != NULL){
    		i++;
    		P=P->Next;
    	}
    	return i;
    }
    Position CONVERT(int n, List L){
    	Position p=L;
    	while(n>1){
    		if(p->Next!=NULL)
    			p=p->Next;
    		n--;
    	}
    	return p;
    }
    Position PREVIOUS(Position P, List L){
    	Position T=L;
    	int i;
    	
    	for(i=1;i<=LENGTH(L);i++){
    		if(RETRIEVE(T,L) == RETRIEVE(P,L)){
    			i=i-1;
    			break;
    		}
    		T=T->Next;
    	}
    
    	
    	return CONVERT(i,L);
    	
    }
    	
    
    
    
    
    
    
    void MAKENULL_LIST(List& Header){
    	(Header)=(Node*)malloc(sizeof(Node));
    	Header->Next= NULL;
    }
    
    int EMPTY_LIST(List L){
    	return (L->Next==NULL);
    }
    void INSERT_LIST(ElementType X, Position P, List& L){
    	Position T=(Node*)malloc(sizeof(Node));
    	T->Element=X;
    	T->Next=P->Next;
    	P->Next=T;
    }
    
    
    
    
    void DELETE_LIST(Position P, List& L){
    	Position T;
    	if (P->Next!=NULL){
    		T=P->Next; 	/*point to deleted cell to free its space*/
    		P->Next=T->Next; /*re-connecting the pointer to the following cell*/
    		free(T); //free the space of deleted cell
    	}
    }
    
    Position LOCATE(ElementType X, List L){
    	Position P = L;
    	while (P->Next != NULL)
    		if (P->Next->Element == X)  break; //return P;
    		else P = P->Next;
    	return P;
    }
    
    
    void READ_LIST1(List L){
    	int n,x;
    	printf("how many elements of sequence ?");
    	scanf("%d",&n);
    	for (int i=1; i<=n; i++){
    		printf("input the element %d : ",i);
    		scanf("%d",&x);
    		INSERT_LIST(x,CONVERT( n, L), L);
    	}
    }
    
    void READ_LIST2(List L){
    	int n,x;
    	printf("how many elements of sequence ?");
    	scanf("%d",&n);
    	for (int i=1; i<=n; i++){
    		printf("input the element %d : ",i);
    		scanf("%d",&x);
    		INSERT_LIST(x,CONVERT( 1, L), L);
    	}
    }
    
    void swap(Position p, Position q ){
    	ElementType T;
    	T=p->Next->Element;
    	p->Next->Element=q->Next->Element;
    	q->Next->Element=T;
    }
    void SORT(List L){
    	Position p= FIRST(L); // begin at first element 
    	
    	while (p!=ENDLIST(L)){
    		Position  q=NEXT(p,L); // get the following of position p  
    		while (q!=ENDLIST(L)){
    			if (RETRIEVE(p,L) > RETRIEVE(q,L))
    				swap(p,q); // swap two element
    				q=NEXT(q,L);
    		}
    		p=NEXT(p,L);
    }
    }
    
    void READ_LIST3(List L){
    	int n,x;
    	printf("how many elements of sequence ?");
    	scanf("%d",&n);
    	for (int i=1; i<=n; i++){
    		printf("input the element %d : ",i);
    		scanf("%d",&x);
    		INSERT_LIST(x,CONVERT(n,L), L);
    		SORT(L);
    	}
    }
    
    void PRINT_LIST(List L){
    	Position P=FIRST(L);
    	while(P->Next!=NULL){
    		printf("%d ",P->Next->Element);
    		P=P->Next;
    	}
    }
    
    
    
    
    void INSERT_LAST(ElementType X, List L){
    	Position P=FIRST(L);
    	while(P != ENDLIST(L)){
    		P=P->Next;
    	}
    	INSERT_LIST(X,P,L);
    }
    void INSERT_FIRST(ElementType X, List L){
    	Position P=FIRST(L);
    	INSERT_LIST(X,P,L);
    }
    void INSERT_SORTED_LIST(ElementType X, List L){
    	Position p=FIRST(L);
    	while(p != NULL){
    		if(X <RETRIEVE(p,L)){
    			INSERT_LIST(X,p,L);
    			break;
    		}else{
    			p=p->Next;
    		}
    	}
    	if(p == NULL){
    		INSERT_LAST(X,L);
    }
    }
    
    void DELETE_SORTED_LIST(ElementType X, List L){
    	Position P=FIRST(L);
    	while(P != ENDLIST(L)){
    		if( X <= RETRIEVE(P,L)){
    			break;
    		}
    		else{
    		 P=P->Next;
    		}
    }
    	if(X == RETRIEVE(P,L)){
    		DELETE_LIST(P,L);
    	}
    }
    
    void DELETE_DUPLICATE(List L){
    	Position p=FIRST(L);
    	Position k=FIRST(L);
    	
    	while (p!=ENDLIST(L)){
    		Position  q=NEXT(p,L); // get the following of position p  
    		while (q!=ENDLIST(L)){
    			if (RETRIEVE(p,L) == RETRIEVE(q,L)){
    				DELETE_LIST(q,L);
    			}
    			q=NEXT(q,L);
    		}
    		p=NEXT(p,L);
    }
    
    
    }
    
    
    
    
    	
    
    
    
    
    
    int main(){
    	List L;
    	ElementType X;
    	Position P;
    	MAKENULL_LIST(L);
    /*1
    	READ_LIST1(L);
    //	READ_LIST2(L);
    	PRINT_LIST(L);*/
    	
    /*3b
    	READ_LIST1(L);
    	SORT(L);
    	PRINT_LIST(L);*/
    	
    /*4
    	READ_LIST1(L);
    	SORT(L);
    	printf("elements after sorting: ");
    	PRINT_LIST(L);
    	printf("\nenter element to insert: ");
    	scanf("%d",&X);
    	INSERT_SORTED_LIST(X,L);
    	PRINT_LIST(L);*/
    	
    /*5	READ_LIST1(L);
    	SORT(L);
    	printf("elements after sorting: ");
    	PRINT_LIST(L);
    	printf("\nenter element to delete: ");
    	scanf("%d",&X);
    	DELETE_SORTED_LIST(X,L);
    	PRINT_LIST(L);*/
    	
    /*6	READ_LIST3(L);
    	PRINT_LIST(L);*/
    	
    	READ_LIST1(L);
    	SORT(L);
    	printf("elements after sorting: ");
    	PRINT_LIST(L);
    	DELETE_DUPLICATE(L);
    	printf("\nlist after delete duplicate elements: ");
    	PRINT_LIST(L);
    	
    	
    	
    	
    	return 0;
    }

  4. #4
    Ngày gia nhập
    01 2013
    Bài viết
    1,476

    Thực ra hàm này để xóa node đứng sau, vậy thì bạn lại so p và q để xóa q->next, sao mà đúng.

    Ngoài ra một số hàm bạn viết sai về mặt ý nghĩa.
    Đã được chỉnh sửa lần cuối bởi prog10 : 05-09-2017 lúc 12:39 PM.

  5. #5
    Ngày gia nhập
    04 2017
    Bài viết
    1

    dạ cám ơn bác, bác làm e bừng tỉnh và e đã debug đc, cám ơn bác nhiều. xin chia sẻ code sau khi đã sửa của e dành cho ai cần:

    Code:
    void DELETE_DUPLICATE(List L){
    	Position p=FIRST(L);
    	while (p!=ENDLIST(L)){
    		Position  q=NEXT(p,L); // get the following of position p  
    		while (q!=ENDLIST(L)){
    			if (RETRIEVE(p,L) == RETRIEVE(q,L)){
    				DELETE_LIST(q,L);
    			}else{
    				q=NEXT(q,L);
    			}
    		}
    		p=NEXT(p,L);
    }
    }

  6. #6
    Ngày gia nhập
    01 2013
    Bài viết
    1,476

    Mặc định Hàm xóa phần tử trùng nhau trong danh sách liên kết

    Hàm RETRIEVE của bạn vẫn có vấn đề do bạn đang lấy p->next so với q->next, do đặt tên không đúng bản chất.

    Mà không cần phải chạy ENDLIST suốt như vậy, chạy tới NULL hẳn luôn.
    Đã được chỉnh sửa lần cuối bởi prog10 : 05-09-2017 lúc 02:00 PM.

  7. #7
    Ngày gia nhập
    04 2017
    Bài viết
    1

    Ủa?? mà e nghĩ bản chất của danh sách liên kết đơn là ở vị trí P thì mình có dữ liệu của P->next mà bác?? đâu phải ngay vị trí đó là dữ liệu của nó đâu???

  8. #8
    Ngày gia nhập
    01 2013
    Bài viết
    1,476

    Trích dẫn Nguyên bản được gửi bởi shanee1998 Xem bài viết
    Ủa?? mà e nghĩ bản chất của danh sách liên kết đơn là ở vị trí P thì mình có dữ liệu của P->next mà bác?? đâu phải ngay vị trí đó là dữ liệu của nó đâu???
    Không đúng, dữ liệu của P là P->Element, còn P->next->Element là của node ngay sau.

  9. #9
    Ngày gia nhập
    06 2017
    Bài viết
    40

    Thường thì thao tác trên node phải thực hiện trên node hiện tại. Ai lại đi thao tác trên node kế. Bạn thớt nên xem lại đi.
    ElementType RETRIEVE(Position P, List L)
    {
    if (P->Next!=NULL)
    return P->Next->Element; //Bạn đang đi ngược đường rồi. Đường đi khó không ai cấm nhưng bạn sẽ đi ngược với thế giới
    }

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn